diff --git a/.gitignore b/.gitignore index ee06baff610..15741f4f0c0 100644 --- a/.gitignore +++ b/.gitignore @@ -45,7 +45,6 @@ aiohttp/_http_writer.html aiohttp/_websocket.c aiohttp/_websocket.html aiohttp/_websocket/mask.c -aiohttp/_websocket/reader_c.c bin build coverage.xml diff --git a/Makefile b/Makefile index 2ac94cb78ad..2e983d89eee 100644 --- a/Makefile +++ b/Makefile @@ -58,11 +58,6 @@ endif aiohttp/_find_header.c: $(call to-hash,aiohttp/hdrs.py ./tools/gen.py) ./tools/gen.py -# Special case for reader since we want to be able to disable -# the extension with AIOHTTP_NO_EXTENSIONS -aiohttp/_websocket/reader_c.c: aiohttp/_websocket/reader_py.py - cython -3 --module-name aiohttp._websocket.reader_c -X freethreading_compatible=True $(CYTHON_EXTRA) -o $@ $< -I aiohttp -Werror - # _find_headers generator creates _headers.pyi as well aiohttp/%.c: aiohttp/%.pyx $(call to-hash,$(CYS)) aiohttp/_find_header.c cython -3 -X freethreading_compatible=True $(CYTHON_EXTRA) -o $@ $< -I aiohttp -Werror @@ -81,12 +76,12 @@ vendor/llhttp/node_modules: vendor/llhttp/package.json generate-llhttp: .llhttp-gen .PHONY: cythonize -cythonize: .install-cython $(PYXS:.pyx=.c) aiohttp/_websocket/reader_c.c +cythonize: .install-cython $(PYXS:.pyx=.c) .PHONY: cythonize-nodeps -cythonize-nodeps: $(PYXS:.pyx=.c) aiohttp/_websocket/reader_c.c +cythonize-nodeps: $(PYXS:.pyx=.c) -.install-deps: .install-cython $(PYXS:.pyx=.c) aiohttp/_websocket/reader_c.c $(call to-hash,$(CYS) $(REQS)) +.install-deps: .install-cython $(PYXS:.pyx=.c) $(call to-hash,$(CYS) $(REQS)) @$(PIP) install -r requirements/dev.in -c requirements/dev.txt @touch .install-deps @@ -157,7 +152,8 @@ clean: @rm -f aiohttp/_http_parser.c @rm -f aiohttp/_http_writer.c @rm -f aiohttp/_websocket.c - @rm -f aiohttp/_websocket/reader_c.c + @rm -f aiohttp/_websocket/*.so + @rm -f aiohttp/_websocket/*.pyd @rm -rf .tox @rm -f .develop @rm -f .flake diff --git a/aiohttp/_websocket/__init__.py b/aiohttp/_websocket/__init__.py index 836257cc47a..b04ee3ab5b5 100644 --- a/aiohttp/_websocket/__init__.py +++ b/aiohttp/_websocket/__init__.py @@ -1 +1,16 @@ """WebSocket protocol versions 13 and 8.""" + +import importlib.util +import os +import sys + +# The mypyc-compiled reader shadows reader.py on import, so force .py import. +if os.environ.get("AIOHTTP_NO_EXTENSIONS"): + _spec = importlib.util.spec_from_file_location( + f"{__name__}.reader", os.path.join(os.path.dirname(__file__), "reader.py") + ) + assert _spec is not None and _spec.loader is not None + reader = importlib.util.module_from_spec(_spec) + sys.modules[_spec.name] = reader + _spec.loader.exec_module(reader) + del _spec diff --git a/aiohttp/_websocket/_wrbase.py b/aiohttp/_websocket/_wrbase.py new file mode 100644 index 00000000000..8c8a24b0a57 --- /dev/null +++ b/aiohttp/_websocket/_wrbase.py @@ -0,0 +1,27 @@ +import asyncio +from typing import TYPE_CHECKING, cast + +if TYPE_CHECKING: + from .models import WSMessage + from .reader import WebSocketDataQueue + + +class _WeakrefBase: + """Hack for https://github.com/mypyc/mypyc/issues/1102""" + + +class _InterpretedReadMixin: + """Hack for https://github.com/mypyc/mypyc/issues/1214""" + + async def read(self) -> "WSMessage": + q = cast("WebSocketDataQueue", self) + if not q._buffer and not q._eof: + assert not q._waiter + waiter: "asyncio.Future[None]" = q._loop.create_future() + q._waiter = waiter + try: + await waiter + except (asyncio.CancelledError, asyncio.TimeoutError): + q._waiter = None + raise + return q._read_from_buffer() diff --git a/aiohttp/_websocket/reader.py b/aiohttp/_websocket/reader.py index 293754f781f..ad2989032e7 100644 --- a/aiohttp/_websocket/reader.py +++ b/aiohttp/_websocket/reader.py @@ -1,31 +1,658 @@ """Reader for WebSocket protocol versions 13 and 8.""" -from typing import TYPE_CHECKING - -from ..helpers import NO_EXTENSIONS - -if TYPE_CHECKING or NO_EXTENSIONS: - from .reader_py import ( - WebSocketDataQueue as WebSocketDataQueuePython, - WebSocketReader as WebSocketReaderPython, - ) - - WebSocketReader = WebSocketReaderPython - WebSocketDataQueue = WebSocketDataQueuePython -else: - try: - from .reader_c import ( # type: ignore[import-not-found] - WebSocketDataQueue as WebSocketDataQueueCython, - WebSocketReader as WebSocketReaderCython, - ) - - WebSocketReader = WebSocketReaderCython - WebSocketDataQueue = WebSocketDataQueueCython - except ImportError: # pragma: no cover - from .reader_py import ( - WebSocketDataQueue as WebSocketDataQueuePython, - WebSocketReader as WebSocketReaderPython, - ) - - WebSocketReader = WebSocketReaderPython - WebSocketDataQueue = WebSocketDataQueuePython +import asyncio +import builtins +import sys +import weakref +from collections import deque +from typing import Final + +from mypy_extensions import i64, mypyc_attr + +from ..base_protocol import BaseProtocol +from ..compression_utils import TooManyMembersError, ZLibDecompressor +from ..helpers import _EXC_SENTINEL, set_exception +from ..log import ws_logger +from ..streams import EofStream +from ._wrbase import _InterpretedReadMixin, _WeakrefBase +from .helpers import ( + UNPACK_CLOSE_CODE as _UNPACK_CLOSE_CODE, + UNPACK_LEN3 as _UNPACK_LEN3, + websocket_mask as _websocket_mask, +) +from .models import ( + WS_DEFLATE_TRAILING as _WS_DEFLATE_TRAILING, + WebSocketError, + WSCloseCode, + WSMessage, + WSMessageBinary as _WSMessageBinary, + WSMessageClose as _WSMessageClose, + WSMessagePing as _WSMessagePing, + WSMessagePong as _WSMessagePong, + WSMessageText as _WSMessageText, + WSMessageTextBytes as _WSMessageTextBytes, + WSMsgType, +) + +# Per-frame imported names: Final re-binds turn globals-dict lookups into +# static loads. Use sites below are unchanged. +UNPACK_CLOSE_CODE: Final = _UNPACK_CLOSE_CODE +UNPACK_LEN3: Final = _UNPACK_LEN3 +websocket_mask: Final = _websocket_mask +WS_DEFLATE_TRAILING: Final = _WS_DEFLATE_TRAILING +WSMessageBinary: Final = _WSMessageBinary +WSMessageClose: Final = _WSMessageClose +WSMessagePing: Final = _WSMessagePing +WSMessagePong: Final = _WSMessagePong +WSMessageText: Final = _WSMessageText +WSMessageTextBytes: Final = _WSMessageTextBytes + +ALLOWED_CLOSE_CODES: Final = {int(i) for i in WSCloseCode} - { + int(WSCloseCode.ABNORMAL_CLOSURE) +} + +# States for the reader, used to parse the WebSocket frame. +READ_HEADER: Final = 1 +READ_PAYLOAD_LENGTH: Final = 2 +READ_PAYLOAD_MASK: Final = 3 +READ_PAYLOAD: Final = 4 + +# Largest declared payload length the reader can represent: the compiled +# reader stores it in a Py_ssize_t, which holds 2**31-1 on the 32-bit builds +# (the win32 and armv7l wheels) and 2**63-1 everywhere else. +# TODO: Remove when we drop 32 bit support. +MAX_PAYLOAD_LEN: Final = sys.maxsize + +WS_MSG_TYPE_BINARY: Final = WSMsgType.BINARY +WS_MSG_TYPE_TEXT: Final = WSMsgType.TEXT + +# WSMsgType values as literal Final ints (guarded below) so mypyc inlines them +OP_CODE_NOT_SET: Final = -1 +OP_CODE_CONTINUATION: Final = 0 +OP_CODE_TEXT: Final = 1 +OP_CODE_BINARY: Final = 2 +OP_CODE_CLOSE: Final = 8 +OP_CODE_PING: Final = 9 +OP_CODE_PONG: Final = 10 +assert ( + OP_CODE_CONTINUATION, + OP_CODE_TEXT, + OP_CODE_BINARY, + OP_CODE_CLOSE, + OP_CODE_PING, + OP_CODE_PONG, +) == ( + WSMsgType.CONTINUATION, + WSMsgType.TEXT, + WSMsgType.BINARY, + WSMsgType.CLOSE, + WSMsgType.PING, + WSMsgType.PONG, +), "OP_CODE_* literals out of sync with WSMsgType" + +EMPTY_FRAME_ERROR: Final = (True, b"") +EMPTY_FRAME: Final = (False, b"") + +COMPRESSED_NOT_SET: Final = -1 +COMPRESSED_FALSE: Final = 0 +COMPRESSED_TRUE: Final = 1 + +TUPLE_NEW: Final = tuple.__new__ + +# Overhead added to each message to ensure that tiny messages can't use +# unreasonable amounts of memory. +MSG_SIZE_OVERHEAD: Final = 128 + +STALLED_READER_COLLECTED: Final = ( + "WebSocketReader was garbage collected while stalled; " + "callers of set_parser() must hold a strong reference" +) + + +@mypyc_attr(allow_interpreted_subclasses=True) +class WebSocketDataQueue(_InterpretedReadMixin): + """WebSocketDataQueue resumes and pauses an underlying stream. + + It is a destination for WebSocket data. + """ + + def __init__( + self, protocol: BaseProtocol, limit: int, *, loop: asyncio.AbstractEventLoop + ) -> None: + self._size: i64 = 0 + self._protocol = protocol + self._limit: i64 = limit * 2 + self._loop = loop + self._eof = False + self._waiter: asyncio.Future[None] | None = None + self._exception: type[BaseException] | BaseException | None = None + self._buffer: deque[WSMessage] = deque() + self._get_buffer = self._buffer.popleft + self._put_buffer = self._buffer.append + self._stalled_reader: "weakref.ref[WebSocketReader] | None" = None + + def is_eof(self) -> bool: + return self._eof + + def exception(self) -> type[BaseException] | BaseException | None: + return self._exception + + def set_exception( + self, + exc: type[BaseException] | BaseException, + exc_cause: builtins.BaseException = _EXC_SENTINEL, + ) -> None: + self._eof = True + self._exception = exc + if (waiter := self._waiter) is not None: + self._waiter = None + set_exception(waiter, exc, exc_cause) + + def _release_waiter(self) -> None: + if (waiter := self._waiter) is None: + return + self._waiter = None + if not waiter.done(): + waiter.set_result(None) + + def feed_eof(self) -> None: + self._eof = True + self._release_waiter() + self._exception = None # Break cyclic references + + def feed_data(self, data: "WSMessage") -> None: + # Unbox into the typed local before adding, so mypyc unboxes once + # and keeps the sum in C instead of a tagged-int add. + size: i64 = data.size + self._size += size + MSG_SIZE_OVERHEAD + self._put_buffer(data) + self._release_waiter() + if self._size > self._limit and not self._protocol._reading_paused: + self._protocol.pause_reading() + + def _read_from_buffer(self) -> WSMessage: + if self._buffer: + data = self._get_buffer() + size: i64 = data.size + self._size -= size + MSG_SIZE_OVERHEAD + if self._stalled_reader is not None and self._size <= self._limit // 2: + # Resume parsing once the queue drains to the low-water mark. + # Each resume re-slices the parser's unparsed tail, so waiting + # for headroom makes a drain cost one copy per batch of + # messages instead of one per message. + if (reader := self._stalled_reader()) is not None: + reader.feed_data(b"") + else: + # The stash died with the reader. Deliver what was already + # queued, then surface the contract violation on the next + # read instead of hanging. Log as well, since a caller that + # stops reading early never sees the deferred exception. A + # real failure that was already recorded stays the reported + # cause. + self._stalled_reader = None + ws_logger.warning(STALLED_READER_COLLECTED) + if self._exception is None: + self.set_exception(RuntimeError(STALLED_READER_COLLECTED)) + # Resuming the transport while a stash remains would admit + # another socket read into the tail for every couple of messages + # drained, moving the memory bound from the queue into the tail. + if ( + self._stalled_reader is None + and self._size < self._limit + and self._protocol._reading_paused + ): + self._protocol.resume_reading() + return data + if self._exception is not None: + raise self._exception + raise EofStream + + +@mypyc_attr(allow_interpreted_subclasses=True) +class WebSocketReader(_WeakrefBase): + def __init__( + self, + queue: WebSocketDataQueue, + max_msg_size: int, + compress: bool, + decode_text: bool, + ) -> None: + self.queue = queue + self._max_msg_size: i64 = max_msg_size + self._decode_text = decode_text + # Parked on the queue while parsing is stalled; created once so + # stalling does not allocate. + self._weak_self = weakref.ref(self) + # mypyc's generated dealloc never calls PyObject_ClearWeakRefs + # (https://github.com/mypyc/mypyc/issues/1102), so a refcount death + # with live weakrefs leaves them dangling and the next deref + # crashes. The self reference forces collection through the cycle + # collector, which clears weakrefs before deallocation. This is + # NOT version-gated: crashes were observed on 3.11 (macOS), 3.12 + # (Windows) and 3.14 (Windows), while the same 3.14 cleared refs on + # Linux -- interpreter forgiveness is platform/patch dependent and + # cannot be relied on anywhere. Cost: the reader and its buffers + # are reclaimed by full GC passes, not refcounting. Never break + # this cycle manually; remove when the mypyc issue is resolved. + self._gc_cycle = self + + self._exc: Exception | None = None + self._partial = bytearray() + self._state: i64 = READ_HEADER + + self._opcode: i64 = OP_CODE_NOT_SET + self._frame_fin = False + self._frame_opcode: i64 = OP_CODE_NOT_SET + # Reads of an in-flight frame, joined once when it completes. + self._payload_fragments: list[bytes] = [] + # Fold reads into _payload_buffer past this count to bound the object + # count (bytes are bounded by max_msg_size). + self._max_fragments: i64 = max(1024, max_msg_size // 256) if max_msg_size else 0 + self._payload_buffer = bytearray() + self._frame_payload_len: i64 = 0 + + self._tail: bytes = b"" + self._has_mask = False + self._frame_mask: bytes | None = None + self._payload_bytes_to_read: i64 = 0 + self._payload_len_flag: i64 = 0 + self._compressed: i64 = COMPRESSED_NOT_SET + self._decompressobj: ZLibDecompressor | None = None + self._compress = compress + + def feed_eof(self) -> None: + self.queue.feed_eof() + + # data can be bytearray on Windows because proactor event loop uses bytearray + # and asyncio types this to Union[bytes, bytearray, memoryview] so we need + # coerce data to bytes if it is not + def feed_data(self, data: bytes | bytearray | memoryview) -> tuple[bool, bytes]: + if type(data) is not bytes: + data = bytes(data) + + if self._exc is not None: + return True, data + + try: + self._feed_data(data) + except Exception as exc: + self._exc = exc + set_exception(self.queue, exc) + return EMPTY_FRAME_ERROR + + return EMPTY_FRAME + + def _handle_frame( + self, + fin: bool, + opcode: i64, + payload: bytes | bytearray, + compressed: i64, + ) -> None: + msg: WSMessage + if opcode in (OP_CODE_TEXT, OP_CODE_BINARY, OP_CODE_CONTINUATION): + # Validate continuation frames before processing + if opcode == OP_CODE_CONTINUATION and self._opcode == OP_CODE_NOT_SET: + raise WebSocketError( + WSCloseCode.PROTOCOL_ERROR, + "Continuation frame for non started message", + ) + + # load text/binary + if not fin: + # got partial frame payload + if opcode != OP_CODE_CONTINUATION: + self._opcode = opcode + self._partial += payload + return + + has_partial = bool(self._partial) + if opcode == OP_CODE_CONTINUATION: + opcode = self._opcode + self._opcode = OP_CODE_NOT_SET + # previous frame was non finished + # we should get continuation opcode + elif has_partial: + raise WebSocketError( + WSCloseCode.PROTOCOL_ERROR, + "The opcode in non-fin frame is expected " + f"to be zero, got {opcode!r}", + ) + + assembled_payload: bytes | bytearray + if has_partial: + assembled_payload = self._partial + payload + self._partial.clear() + else: + assembled_payload = payload + + # Decompress process must to be done after all packets + # received. + if compressed != 0: + if not self._decompressobj: + self._decompressobj = ZLibDecompressor(suppress_deflate_header=True) + # XXX: It's possible that the zlib backend (isal is known to + # do this, maybe others too?) will return max_length bytes, + # but internally buffer more data such that the payload is + # >max_length, so we return one extra byte and if we're able + # to do that, then the message is too big. + try: + payload_merged = self._decompressobj.decompress_sync( + assembled_payload + WS_DEFLATE_TRAILING, + ( + self._max_msg_size + 1 + if self._max_msg_size != 0 + else self._max_msg_size + ), + ) + except TooManyMembersError as exc: + raise WebSocketError( + WSCloseCode.MESSAGE_TOO_BIG, + "Compressed message has too many deflate members", + ) from exc + if self._max_msg_size != 0 and len(payload_merged) > self._max_msg_size: + raise WebSocketError( + WSCloseCode.MESSAGE_TOO_BIG, + f"Decompressed message exceeds size limit {self._max_msg_size}", + ) + elif type(assembled_payload) is bytes: + payload_merged = assembled_payload + else: + payload_merged = bytes(assembled_payload) + + size = len(payload_merged) + if opcode == OP_CODE_TEXT: + if self._decode_text: + try: + text = payload_merged.decode("utf-8") + except UnicodeDecodeError as exc: + raise WebSocketError( + WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message" + ) from exc + + # XXX: The Text and Binary messages here can be a performance + # bottleneck, so we use tuple.__new__ to improve performance. + # This is not type safe, but many tests should fail in + # test_client_ws_functional.py if this is wrong. + msg = TUPLE_NEW(WSMessageText, (text, size, "", WS_MSG_TYPE_TEXT)) + else: + # Return raw bytes for TEXT messages when decode_text=False + msg = TUPLE_NEW( + WSMessageTextBytes, (payload_merged, size, "", WS_MSG_TYPE_TEXT) + ) + else: + msg = TUPLE_NEW( + WSMessageBinary, (payload_merged, size, "", WS_MSG_TYPE_BINARY) + ) + + self.queue.feed_data(msg) + elif opcode == OP_CODE_CLOSE: + payload_len = len(payload) + if payload_len >= 2: + close_code = UNPACK_CLOSE_CODE(payload[:2])[0] + # https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.2 + if close_code > 4999 or ( + close_code < 3000 and close_code not in ALLOWED_CLOSE_CODES + ): + raise WebSocketError( + WSCloseCode.PROTOCOL_ERROR, + f"Invalid close code: {close_code}", + ) + try: + close_message = payload[2:].decode("utf-8") + except UnicodeDecodeError as exc: + raise WebSocketError( + WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message" + ) from exc + msg = WSMessageClose( + data=close_code, size=payload_len, extra=close_message + ) + elif payload: + raise WebSocketError( + WSCloseCode.PROTOCOL_ERROR, + f"Invalid close frame: {fin} {opcode} {payload!r}", + ) + else: + msg = WSMessageClose(data=0, size=payload_len, extra="") + + self.queue.feed_data(msg) + elif opcode == OP_CODE_PING: + self.queue.feed_data( + WSMessagePing(data=bytes(payload), size=len(payload), extra="") + ) + elif opcode == OP_CODE_PONG: + self.queue.feed_data( + WSMessagePong(data=bytes(payload), size=len(payload), extra="") + ) + else: + raise WebSocketError( + WSCloseCode.PROTOCOL_ERROR, f"Unexpected opcode={opcode!r}" + ) + + def _feed_data(self, data: bytes) -> None: + """Return the next frame from the socket.""" + self.queue._stalled_reader = None + if self._tail: + data, self._tail = self._tail + data, b"" + + start_pos: i64 = 0 + data_len: i64 = len(data) + + while True: + if start_pos < data_len and self.queue._size > self.queue._limit: + # Over the high-water mark with unparsed bytes left: stash the + # remainder and stall. Gating on unparsed bytes keeps a read + # that ended on a frame boundary from arming an empty stall, + # which would hold the transport paused with nothing to drain. + self.queue._stalled_reader = self._weak_self + break + + # read header + if self._state == READ_HEADER: + if data_len - start_pos < 2: + break + first_byte: i64 = data[start_pos] + second_byte: i64 = data[start_pos + 1] + start_pos += 2 + + fin = (first_byte >> 7) & 1 + rsv1 = (first_byte >> 6) & 1 + rsv2 = (first_byte >> 5) & 1 + rsv3 = (first_byte >> 4) & 1 + opcode = first_byte & 0xF + + # frame-fin = %x0 ; more frames of this message follow + # / %x1 ; final frame of this message + # frame-rsv1 = %x0 ; + # 1 bit, MUST be 0 unless negotiated otherwise + # frame-rsv2 = %x0 ; + # 1 bit, MUST be 0 unless negotiated otherwise + # frame-rsv3 = %x0 ; + # 1 bit, MUST be 0 unless negotiated otherwise + # + # Remove rsv1 from this test for deflate development + if rsv2 != 0 or rsv3 != 0 or (rsv1 != 0 and not self._compress): + raise WebSocketError( + WSCloseCode.PROTOCOL_ERROR, + "Received frame with non-zero reserved bits", + ) + + if opcode not in ( + OP_CODE_CONTINUATION, + OP_CODE_TEXT, + OP_CODE_BINARY, + OP_CODE_CLOSE, + OP_CODE_PING, + OP_CODE_PONG, + ): + raise WebSocketError( + WSCloseCode.PROTOCOL_ERROR, + f"Unexpected opcode={opcode!r}", + ) + + if opcode > 0x7 and fin == 0: + raise WebSocketError( + WSCloseCode.PROTOCOL_ERROR, + "Received fragmented control frame", + ) + + has_mask = (second_byte >> 7) & 1 + length = second_byte & 0x7F + + # Control frames MUST have a payload + # length of 125 bytes or less + if opcode > 0x7 and length > 125: + raise WebSocketError( + WSCloseCode.PROTOCOL_ERROR, + "Control frame payload cannot be larger than 125 bytes", + ) + + # Control frames (opcode > 0x7) may be interleaved between the + # fragments of a data message and never carry the per-message + # compressed bit, so they must not touch the compression state. + # https://datatracker.ietf.org/doc/html/rfc6455#section-5.4 + # https://datatracker.ietf.org/doc/html/rfc7692#section-6.1 + if opcode > 0x7: + if rsv1 != 0: + raise WebSocketError( + WSCloseCode.PROTOCOL_ERROR, + "Received frame with non-zero reserved bits", + ) + else: + # Set compress status if last package is FIN + # OR set compress status if this is first fragment + # Raise error if not first fragment with rsv1 = 0x1 + if self._frame_fin or self._compressed == COMPRESSED_NOT_SET: + self._compressed = ( + COMPRESSED_TRUE if rsv1 != 0 else COMPRESSED_FALSE + ) + elif rsv1 != 0: + raise WebSocketError( + WSCloseCode.PROTOCOL_ERROR, + "Received frame with non-zero reserved bits", + ) + self._frame_fin = bool(fin) + + self._frame_opcode = opcode + self._has_mask = bool(has_mask) + self._payload_len_flag = length + self._state = READ_PAYLOAD_LENGTH + + # read payload length + if self._state == READ_PAYLOAD_LENGTH: + len_flag: i64 = self._payload_len_flag + if len_flag == 126: + if data_len - start_pos < 2: + break + first_byte = data[start_pos] + second_byte = data[start_pos + 1] + start_pos += 2 + self._payload_bytes_to_read = first_byte << 8 | second_byte + elif len_flag > 126: + if data_len - start_pos < 8: + break + # The declared length is an unsigned 64-bit integer that + # does not necessarily fit _payload_bytes_to_read. + frame_len = UNPACK_LEN3(data, start_pos)[0] + if frame_len > MAX_PAYLOAD_LEN: + raise WebSocketError( + WSCloseCode.MESSAGE_TOO_BIG, + f"Message size {int(frame_len) + len(self._partial)} " + f"exceeds limit {self._max_msg_size if self._max_msg_size != 0 else MAX_PAYLOAD_LEN}", + ) + self._payload_bytes_to_read = frame_len + start_pos += 8 + else: + self._payload_bytes_to_read = len_flag + + # Reject oversized data frames before buffering any payload + # bytes. Control frames are capped at 125 bytes (checked in + # READ_HEADER) so only text/binary/continuation need this. + if self._max_msg_size != 0 and self._frame_opcode in ( + OP_CODE_TEXT, + OP_CODE_BINARY, + OP_CODE_CONTINUATION, + ): + partial_len: i64 = len(self._partial) + # payload_bytes_to_read is an i64 C value, use + # subtraction here to avoid an integer overflow. + if self._payload_bytes_to_read >= self._max_msg_size - partial_len: + # i64 is sticky in mixed arithmetic: int(i64) + i64 + # would coerce back to i64 and wrap for a declared + # length near 2**63, so box both operands first. + raise WebSocketError( + WSCloseCode.MESSAGE_TOO_BIG, + f"Message size {int(self._payload_bytes_to_read) + int(partial_len)} " + f"exceeds limit {self._max_msg_size}", + ) + + self._state = READ_PAYLOAD_MASK if self._has_mask else READ_PAYLOAD + + # read payload mask + if self._state == READ_PAYLOAD_MASK: + if data_len - start_pos < 4: + break + self._frame_mask = data[start_pos : start_pos + 4] + start_pos += 4 + self._state = READ_PAYLOAD + + if self._state == READ_PAYLOAD: + chunk_len: i64 = data_len - start_pos + if self._payload_bytes_to_read >= chunk_len: + f_end_pos = data_len + self._payload_bytes_to_read -= chunk_len + else: + f_end_pos = start_pos + self._payload_bytes_to_read + self._payload_bytes_to_read = 0 + + had_fragments = self._frame_payload_len + self._frame_payload_len += f_end_pos - start_pos + f_start_pos = start_pos + start_pos = f_end_pos + + if self._payload_bytes_to_read != 0: + if f_start_pos < f_end_pos: # skip a header-only read + self._payload_fragments.append(data[f_start_pos:f_end_pos]) + if ( + self._max_fragments != 0 + and len(self._payload_fragments) > self._max_fragments + ): + # Fold to bound the object count. Not a pause: nothing + # resumes reading until the frame is queued. + self._payload_buffer += b"".join(self._payload_fragments) + self._payload_fragments.clear() + break + + payload: bytes | bytearray + if had_fragments != 0: + self._payload_fragments.append(data[f_start_pos:f_end_pos]) + if self._payload_buffer: # folded prefix + self._payload_buffer += b"".join(self._payload_fragments) + if self._has_mask: + assert self._frame_mask is not None + websocket_mask(self._frame_mask, self._payload_buffer) + payload = self._payload_buffer + self._payload_buffer = bytearray() # detach; payload aliases it + elif self._has_mask: + assert self._frame_mask is not None + payload_bytearray = bytearray(b"".join(self._payload_fragments)) + websocket_mask(self._frame_mask, payload_bytearray) + payload = payload_bytearray + else: + payload = b"".join(self._payload_fragments) + self._payload_fragments.clear() + elif self._has_mask: + assert self._frame_mask is not None + payload_bytearray = bytearray(data[f_start_pos:f_end_pos]) + websocket_mask(self._frame_mask, payload_bytearray) + payload = payload_bytearray + else: + payload = data[f_start_pos:f_end_pos] + + self._handle_frame( + self._frame_fin, self._frame_opcode, payload, self._compressed + ) + self._frame_payload_len = 0 + self._state = READ_HEADER + + self._tail = data[start_pos:] if start_pos < data_len else b"" diff --git a/aiohttp/_websocket/reader_c.c b/aiohttp/_websocket/reader_c.c new file mode 100644 index 00000000000..8153231353d --- /dev/null +++ b/aiohttp/_websocket/reader_c.c @@ -0,0 +1,28414 @@ +/* Generated by Cython 3.3.0 */ + +#ifndef PY_SSIZE_T_CLEAN +#define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +/* InitLimitedAPI */ +#if defined(Py_LIMITED_API) + #if !defined(CYTHON_LIMITED_API) + #define CYTHON_LIMITED_API 1 + #endif +#elif defined(CYTHON_LIMITED_API) + #ifdef _MSC_VER + #pragma message ("Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead.") + #else + #warning Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead. + #endif +#endif + +#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 < 0x03090000 + #error Cython requires Python 3.9+. +#elif defined(Py_LIMITED_API) && (Py_LIMITED_API & 0xFFFF0000) > (PY_VERSION_HEX & 0xFFFF0000) + #error 'Py_LIMITED_API' can only select past Python X.Y versions, not future ones. +#else +#define __PYX_ABI_VERSION "3_3_0" +#define CYTHON_HEX_VERSION 0x030300F0 +#define CYTHON_FUTURE_DIVISION 1 +/* CModulePreamble */ +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifdef __has_builtin + #define __Pyx_has_cbuiltin(name) __has_builtin(name) +#else + #define __Pyx_has_cbuiltin(name) (0) +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API + #if Py_LIMITED_API < 0x03090000 + #error "Cython 3.3 requires the Python Limited API version to be 3.9 or greater." + #endif + #endif + #if defined(GRAALVM_PYTHON) || defined(PYPY_VERSION) + #ifdef _MSC_VER + #pragma message ("Py_LIMITED_API is defined on PyPy or GraalPy. This takes precedence over Cython's specialized\ + code for PyPy and GraalPy and is unlikely to work.") + #else + #warning "Py_LIMITED_API is defined on PyPy or GraalPy. This takes precedence over Cython's specialized\ + code for PyPy and GraalPy and is unlikely to work." + #endif + #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #endif + #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_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_VECTORCALL + #define CYTHON_VECTORCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) + #ifndef CYTHON_VECTORCALL_TPNEW + #define CYTHON_VECTORCALL_TPNEW (CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030E0000) + #endif + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (__PYX_LIMITED_VERSION_HEX >= 0x030F0000 && PY_VERSION_HEX > 0x030F00A8) + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND (__PYX_LIMITED_VERSION_HEX >= 0x030A0000) + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #ifndef CYTHON_USE_OWN_PREP_RERAISE_STAR + #define CYTHON_USE_OWN_PREP_RERAISE_STAR 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 1 + #endif + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 + #if __PYX_LIMITED_VERSION_HEX < 0x030E0000 + #undef CYTHON_OPAQUE_OBJECTS + #define CYTHON_OPAQUE_OBJECTS 0 + #elif !defined(CYTHON_OPAQUE_OBJECTS) + #define CYTHON_OPAQUE_OBJECTS (__PYX_LIMITED_VERSION_HEX >= 0x030F0000) + #endif +#elif defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #endif + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 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_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_VECTORCALL + #define CYTHON_VECTORCALL 1 + #endif + #if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX < 0x030E0000 + #undef CYTHON_VECTORCALL_TPNEW + #define CYTHON_VECTORCALL_TPNEW 0 + #elif !defined(CYTHON_VECTORCALL_TPNEW) + #define CYTHON_VECTORCALL_TPNEW CYTHON_VECTORCALL + #endif + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 1 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #ifndef CYTHON_USE_OWN_PREP_RERAISE_STAR + #define CYTHON_USE_OWN_PREP_RERAISE_STAR 1 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 + #undef CYTHON_OPAQUE_OBJECTS + #define CYTHON_OPAQUE_OBJECTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 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_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_VECTORCALL + #define CYTHON_VECTORCALL 1 + #endif + #if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX < 0x030E0000 + #undef CYTHON_VECTORCALL_TPNEW + #define CYTHON_VECTORCALL_TPNEW 0 + #elif !defined(CYTHON_VECTORCALL_TPNEW) + #define CYTHON_VECTORCALL_TPNEW (PYPY_VERSION_NUM >= 0x07030800 && CYTHON_VECTORCALL) + #endif + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PYPY_VERSION_NUM >= 0x07030C00) + #endif + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_NUM >= 0x07031100) + #endif + #ifndef CYTHON_USE_OWN_PREP_RERAISE_STAR + #define CYTHON_USE_OWN_PREP_RERAISE_STAR 1 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 + #undef CYTHON_OPAQUE_OBJECTS + #define CYTHON_OPAQUE_OBJECTS 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #ifdef Py_GIL_DISABLED + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 1 + #else + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #endif + #if PY_VERSION_HEX < 0x030A0000 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #elif !defined(CYTHON_USE_TYPE_SLOTS) + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLIST_INTERNALS) + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING || PY_VERSION_HEX >= 0x030B00A2 + #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 + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #elif !defined(CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS) + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #elif !defined(CYTHON_FAST_GIL) + #define CYTHON_FAST_GIL (PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_VECTORCALL + #define CYTHON_VECTORCALL 1 + #endif + #if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX < 0x030E0000 + #undef CYTHON_VECTORCALL_TPNEW + #define CYTHON_VECTORCALL_TPNEW 0 + #elif !defined(CYTHON_VECTORCALL_TPNEW) + #define CYTHON_VECTORCALL_TPNEW CYTHON_VECTORCALL + #endif + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #ifndef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING (PY_VERSION_HEX >= 0x030d00B1) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5 && !CYTHON_USE_MODULE_STATE) + #endif + #ifndef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 1 + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_OWN_PREP_RERAISE_STAR + #define CYTHON_USE_OWN_PREP_RERAISE_STAR (PY_VERSION_HEX < 0x030C00B2) + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS (!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) + #endif + #if defined(CYTHON_IMMORTAL_CONSTANTS) && PY_VERSION_HEX < 0x030C0000 + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 // definitely won't work + #elif !defined(CYTHON_IMMORTAL_CONSTANTS) + #define CYTHON_IMMORTAL_CONSTANTS (PY_VERSION_HEX >= 0x030C0000 && !CYTHON_USE_MODULE_STATE && CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) + #endif + #ifndef CYTHON_OPAQUE_OBJECTS + #define CYTHON_OPAQUE_OBJECTS 0 + #endif +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#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(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L + #define CYTHON_UNUSED [[maybe_unused]] + #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_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#include +typedef uintptr_t __pyx_uintptr_t; +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif +#ifdef Py_UNREACHABLE + #define __Pyx_UNREACHABLE() Py_UNREACHABLE() +#elif __Pyx_has_cbuiltin(__builtin_unreachable) + #define __Pyx_UNREACHABLE() __builtin_unreachable() +#elif defined(__clang__) || defined(__INTEL_COMPILER) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))) + #define __Pyx_UNREACHABLE() __builtin_unreachable() +#elif defined(_MSC_VER) + #define __Pyx_UNREACHABLE() __assume(0) +#else + #define __Pyx_UNREACHABLE() Py_FatalError("Unreachable C code path reached") +#endif +#ifndef Py_UNREACHABLE + #define Py_UNREACHABLE() __Pyx_UNREACHABLE() +#endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT 0 +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 +#define __Pyx_PyErr_FetchException(petype, peval, petb) PyErr_Fetch(petype, peval, petb) +#define __Pyx_PyErr_RestoreException(etype, eval, etb) PyErr_Restore(etype, eval, etb) +#else +#define __Pyx_PyErr_FetchException(petype, peval, petb) *(petype)=NULL; *(peval)=PyErr_GetRaisedException(); *(petb)=NULL +#define __Pyx_PyErr_RestoreException(etype, eval, etb) PyErr_SetRaisedException(eval) +#endif + +/* CInitCode */ +#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 + +/* PythonCompatibility */ +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#define __Pyx_BUILTIN_MODULE_NAME "builtins" +#define __Pyx_DefaultClassType PyType_Type +#if CYTHON_COMPILING_IN_LIMITED_API + #ifndef CO_OPTIMIZED + static int CO_OPTIMIZED; + #endif + #ifndef CO_NEWLOCALS + static int CO_NEWLOCALS; + #endif + #ifndef CO_VARARGS + static int CO_VARARGS; + #endif + #ifndef CO_VARKEYWORDS + static int CO_VARKEYWORDS; + #endif + #ifndef CO_ASYNC_GENERATOR + static int CO_ASYNC_GENERATOR; + #endif + #ifndef CO_GENERATOR + static int CO_GENERATOR; + #endif + #ifndef CO_COROUTINE + static int CO_COROUTINE; + #endif +#else + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 + #endif +#endif +static int __Pyx_init_co_variables(void); +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static unsigned long __Pyx_Runtime_TPFLAGS_SEQUENCE; +static unsigned long __Pyx_Runtime_TPFLAGS_MAPPING; +#else +#define __Pyx_Runtime_TPFLAGS_SEQUENCE Py_TPFLAGS_SEQUENCE +#define __Pyx_Runtime_TPFLAGS_MAPPING Py_TPFLAGS_MAPPING +#endif +static int __Pyx_init_tpflags_variables(void); +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE (CYTHON_COMPILING_IN_LIMITED_API ? 0 : 1 << 5) +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING (CYTHON_COMPILING_IN_LIMITED_API ? 0 : 1 << 6) +#endif +#ifndef Py_TPFLAGS_IMMUTABLETYPE + #define Py_TPFLAGS_IMMUTABLETYPE (1UL << 8) +#endif +#ifndef Py_TPFLAGS_DISALLOW_INSTANTIATION + #define Py_TPFLAGS_DISALLOW_INSTANTIATION (1UL << 7) +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#if !defined(METH_FASTCALL) || CYTHON_COMPILING_IN_PYPY + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_VECTORCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(void)) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +#endif +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) +#else + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) +#endif +#if CYTHON_COMPILING_IN_PYPY + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); +#else + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 +#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_LIMITED_API + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) +#elif CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000 + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) GraalPyFrame_SetLineNumber((frame), (lineno)) +#elif CYTHON_COMPILING_IN_GRAAL + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #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 +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#endif +#if CYTHON_OPAQUE_OBJECTS && CYTHON_COMPILING_IN_LIMITED_API + #define __PYX_SHARED_SIZEOF(T) -((int)sizeof(T)) + #define __PYX_SHARED_RELATIVE_OFFSET Py_RELATIVE_OFFSET + #define CYTHON_OPAQUE_SHARED_TYPES 1 +#else + #define __PYX_SHARED_SIZEOF(T) sizeof(T) + #define __PYX_SHARED_RELATIVE_OFFSET 0 + #define CYTHON_OPAQUE_SHARED_TYPES 0 +#endif +#if CYTHON_USE_MODULE_STATE +static CYTHON_INLINE void *__Pyx__PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#define __Pyx_PyModule_GetState(o) (__pyx_mstatetype *)__Pyx__PyModule_GetState(o) +#else +#define __Pyx_PyModule_GetState(op) ((void)op,__pyx_mstate_global) +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE((PyObject *) obj), name, func_ctype) +#define __Pyx_PyObject_TryGetSlot(obj, name, func_ctype) __Pyx_PyType_TryGetSlot(Py_TYPE(obj), name, func_ctype) +#define __Pyx_PyObject_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#define __Pyx_PyObject_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype) __Pyx_PyType_GetSlot(type, name, func_ctype) + #define __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) (((type)->sub) ? ((type)->sub->name) : NULL) + #define __Pyx_PyType_TryGetSubSlot(type, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype)\ + ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000 ||\ + (PyType_GetFlags(type) & Py_TPFLAGS_HEAPTYPE) || __Pyx_get_runtime_version() >= 0x030A0000) ?\ + __Pyx_PyType_GetSlot(type, name, func_ctype) : NULL) + #define __Pyx_PyType_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSlot(obj, name, func_ctype) + #define __Pyx_PyType_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSlot(obj, name, func_ctype) +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) +#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL && PyErr_Occurred()) { + PyErr_WriteUnraisable(NULL); + } + return res; +} +#elif !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000 +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) +#endif +#define __Pyx_PyObject_GetIterNextFunc(iterator) __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc) +#if CYTHON_USE_TYPE_SPECS +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} +#else +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_KIND_04(u) __Pyx_PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#else + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #endif + #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) ((int)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, (Py_UCS4) ch) + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #else + #if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #endif + static CYTHON_INLINE int __Pyx_PyUnicode_KIND_04(PyObject *o) { + return __Pyx_PyUnicode_KIND(o) - (int) !!PyUnicode_IS_ASCII(o); + } +#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 + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif +#endif +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && PyUnstable_Object_IsUniquelyReferenced(obj)) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#elif CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) Py_IS_TYPE(obj, &PySet_Type) +#endif +enum __Pyx_ReferenceSharing { + __Pyx_ReferenceSharing_DefinitelyUnique, // We created it so we know it's unshared - no need to check + __Pyx_ReferenceSharing_OwnStrongReference, + __Pyx_ReferenceSharing_FunctionArgument, + __Pyx_ReferenceSharing_SharedReference, // Never trust it to be unshared because it's a global or similar +}; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && PY_VERSION_HEX >= 0x030E0000 +#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing)\ + (sharing == __Pyx_ReferenceSharing_DefinitelyUnique ? 1 :\ + (sharing == __Pyx_ReferenceSharing_FunctionArgument ? PyUnstable_Object_IsUniqueReferencedTemporary(o) :\ + (sharing == __Pyx_ReferenceSharing_OwnStrongReference ? PyUnstable_Object_IsUniquelyReferenced(o) : 0))) +#elif (CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing) (((void)sharing), Py_REFCNT(o) == 1) +#else +#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing) (((void)o), ((void)sharing), 0) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #if CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GetItemRef(o, i) (likely((i) >= 0) ? PySequence_GetItem(o, i) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) + #else + #define __Pyx_PyList_GetItemRef(o, i) PySequence_ITEM(o, i) + #endif +#elif CYTHON_COMPILING_IN_LIMITED_API || !(CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE) + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_XNewRef(PyList_GetItem(o, i)) +#else + #define __Pyx_PyList_GetItemRef(o, i) (likely(__Pyx_is_valid_index(i, PyList_GET_SIZE(o))) ?\ + __Pyx_NewRef(PyList_GET_ITEM(o, i)) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +#endif +#if CYTHON_AVOID_BORROWED_REFS || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) ((void)(unsafe_shared),\ + __Pyx_PyList_GetItemRef(o, i)) +#elif CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) (\ + __Pyx_IS_UNIQUELY_REFERENCED(o, unsafe_shared) ?\ + __Pyx_NewRef(PyList_GET_ITEM(o, i)) : __Pyx_PyList_GetItemRef(o, i)) + #else + #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) (\ + __Pyx_IS_UNIQUELY_REFERENCED(o, unsafe_shared) ?\ + __Pyx_XNewRef(PyList_GetItem(o, i)) : __Pyx_PyList_GetItemRef(o, i)) + #endif +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) ((void)(unsafe_shared),\ + __Pyx_NewRef(PyList_GET_ITEM(o, i))) +#else + #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) ((void)(unsafe_shared),\ + __Pyx_XNewRef(PyList_GetItem(o, i))) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyDict_GetItemRef(dict, key, result) PyDict_GetItemRef(dict, key, result) +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyObject_GetItem(dict, key); + if (*result == NULL) { + if (PyErr_ExceptionMatches(PyExc_KeyError)) { + PyErr_Clear(); + return 0; + } + return -1; + } + return 1; +} +#else +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyDict_GetItemWithError(dict, key); + if (*result == NULL) { + return PyErr_Occurred() ? -1 : 0; + } + Py_INCREF(*result); + return 1; +} +#endif +#if defined(CYTHON_DEBUG_VISIT_CONST) && CYTHON_DEBUG_VISIT_CONST + #define __Pyx_VISIT_CONST(obj) Py_VISIT(obj) +#else + #define __Pyx_VISIT_CONST(obj) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GET_ITEM(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GET_ITEM(o, i) +#else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GetItem(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GetItem(o, i) +#endif +#if CYTHON_ASSUME_SAFE_SIZE + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyDict_GET_SIZE(o) PyDict_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GET_LENGTH(o) +#else + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyDict_GET_SIZE(o) PyDict_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString) + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) +#endif +#define __Pyx_PyLong_FromHash_t PyLong_FromSsize_t +#define __Pyx_PyLong_AsHash_t __Pyx_PyIndex_AsSsize_t +#if __PYX_LIMITED_VERSION_HEX >= 0x030A0000 + #define __Pyx_PySendResult PySendResult +#else + typedef enum { + PYGEN_RETURN = 0, + PYGEN_ERROR = -1, + PYGEN_NEXT = 1, + } __Pyx_PySendResult; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030A00A3 + typedef __Pyx_PySendResult (*__Pyx_pyiter_sendfunc)(PyObject *iter, PyObject *value, PyObject **result); +#else + #define __Pyx_pyiter_sendfunc sendfunc +#endif +#if !CYTHON_USE_AM_SEND +#define __PYX_HAS_PY_AM_SEND 0 +#elif __PYX_LIMITED_VERSION_HEX >= 0x030A0000 +#define __PYX_HAS_PY_AM_SEND 1 +#else +#define __PYX_HAS_PY_AM_SEND 2 // our own backported implementation +#endif +#if __PYX_HAS_PY_AM_SEND < 2 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#else + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + __Pyx_pyiter_sendfunc am_send; + } __Pyx_PyAsyncMethodsStruct; + #define __Pyx_SlotTpAsAsync(s) ((PyAsyncMethods*)(s)) +#endif +#if CYTHON_USE_AM_SEND && PY_VERSION_HEX < 0x030A00F0 + #define __Pyx_TPFLAGS_HAVE_AM_SEND (1UL << 21) +#else + #define __Pyx_TPFLAGS_HAVE_AM_SEND (0) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030A0000 +#ifdef __cplusplus +extern "C" +#endif +PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_init_co_variable(PyObject *inspect, const char* name, int *write_to) { + int value; + PyObject *py_value = PyObject_GetAttrString(inspect, name); + if (!py_value) return 0; + value = (int) PyLong_AsLong(py_value); + Py_DECREF(py_value); + *write_to = value; + return value != -1 || !PyErr_Occurred(); +} +static int __Pyx_init_co_variables(void) { + PyObject *inspect; + int result; + inspect = PyImport_ImportModule("inspect"); + result = +#if !defined(CO_OPTIMIZED) + __Pyx_init_co_variable(inspect, "CO_OPTIMIZED", &CO_OPTIMIZED) && +#endif +#if !defined(CO_NEWLOCALS) + __Pyx_init_co_variable(inspect, "CO_NEWLOCALS", &CO_NEWLOCALS) && +#endif +#if !defined(CO_VARARGS) + __Pyx_init_co_variable(inspect, "CO_VARARGS", &CO_VARARGS) && +#endif +#if !defined(CO_VARKEYWORDS) + __Pyx_init_co_variable(inspect, "CO_VARKEYWORDS", &CO_VARKEYWORDS) && +#endif +#if !defined(CO_ASYNC_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_ASYNC_GENERATOR", &CO_ASYNC_GENERATOR) && +#endif +#if !defined(CO_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_GENERATOR", &CO_GENERATOR) && +#endif +#if !defined(CO_COROUTINE) + __Pyx_init_co_variable(inspect, "CO_COROUTINE", &CO_COROUTINE) && +#endif + 1; + Py_DECREF(inspect); + return result ? 0 : -1; +} +static int __Pyx_init_tpflags_bitcount(unsigned long flag) { + int count = 0; + while (flag) { + count += (int) (flag & 1); + flag >>= 1; + } + return count; +} +static int __Pyx_init_tpflags_variables(void) { + if (__Pyx_Runtime_TPFLAGS_SEQUENCE != 0 && __Pyx_Runtime_TPFLAGS_MAPPING != 0) { + return 0; + } + PyObject *collections_abc = PyImport_ImportModule("collections.abc"); + if (!collections_abc) return -1; + int result = 0; + PyObject *sequence = NULL, *mapping = NULL; +#if __PYX_LIMITED_VERSION_HEX >= 0x030D0000 + if (PyObject_GetOptionalAttrString(collections_abc, "Sequence", &sequence) != 1) goto fail; + if (PyObject_GetOptionalAttrString(collections_abc, "Mapping", &mapping) != 1) goto fail; +#else + sequence = PyObject_GetAttrString(collections_abc, "Sequence"); + if (!sequence) goto fail_attr_lookup; + mapping = PyObject_GetAttrString(collections_abc, "Mapping"); + if (!mapping) goto fail_attr_lookup; +#endif + if (!PyType_Check(sequence) || !PyType_Check(mapping)) goto fail; + { + unsigned long sequence_flags = PyType_GetFlags((PyTypeObject*)sequence); + unsigned long mapping_flags = PyType_GetFlags((PyTypeObject*)mapping); + unsigned long mutual_flags = sequence_flags & mapping_flags; + sequence_flags = sequence_flags ^ mutual_flags; + mapping_flags = mapping_flags ^ mutual_flags; + if (__Pyx_Runtime_TPFLAGS_SEQUENCE == 0 && __Pyx_init_tpflags_bitcount(sequence_flags) == 1) { + __Pyx_Runtime_TPFLAGS_SEQUENCE = sequence_flags; + } + if (__Pyx_Runtime_TPFLAGS_MAPPING == 0 && __Pyx_init_tpflags_bitcount(mapping_flags) == 1) { + __Pyx_Runtime_TPFLAGS_MAPPING = mapping_flags; + } + } + cleanup: + Py_XDECREF(mapping); + Py_XDECREF(sequence); + Py_DECREF(collections_abc); + return result; +#if __PYX_LIMITED_VERSION_HEX < 0x030D0000 + fail_attr_lookup: + if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } +#endif + fail: + result = PyErr_Occurred() ? -1 : 0; + goto cleanup; +} +#else +static int __Pyx_init_co_variables(void) { + return 0; // It's a limited API-only feature +} +static int __Pyx_init_tpflags_variables(void) { + return 0; // It's a limited API-only feature +} +#endif + +/* MathInitCode */ +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #ifndef _USE_MATH_DEFINES + #define _USE_MATH_DEFINES + #endif +#endif +#include +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#ifndef CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#define CYTHON_CLINE_IN_TRACEBACK_RUNTIME 0 +#endif +#ifndef CYTHON_CLINE_IN_TRACEBACK +#define CYTHON_CLINE_IN_TRACEBACK CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#endif +#if CYTHON_CLINE_IN_TRACEBACK +#define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; __pyx_clineno = __LINE__; (void) __pyx_clineno; } +#else +#define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; (void) __pyx_clineno; } +#endif +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__aiohttp___websocket__reader_c +#define __PYX_HAVE_API__aiohttp___websocket__reader_c +/* Early includes */ +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#ifdef CYTHON_FREETHREADING_COMPATIBLE +#if CYTHON_FREETHREADING_COMPATIBLE +#define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_NOT_USED +#else +#define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_USED +#endif +#else +#define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_NOT_USED +#endif +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 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))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#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) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_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 Py_ssize_t __Pyx_ssize_strlen(const char *s); +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); +#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 CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyByteArray_AsString(s) PyByteArray_AS_STRING(s) +#else + #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyByteArray_AsString(s) PyByteArray_AsString(s) +#endif +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const 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_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +static CYTHON_INLINE PyObject *__Pyx_NewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_NewRef) + return Py_NewRef(obj); +#else + Py_INCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_XNewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_XNewRef) + return Py_XNewRef(obj); +#else + Py_XINCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b); +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x); +#define __Pyx_PyObject_RichCompareBool(a,b,cmp) __Pyx_PyObject_IsTrueAndDecref(PyObject_RichCompare((a),(b),(cmp))) +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t); +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); +#if CYTHON_ASSUME_SAFE_MACROS +#define __Pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AS_DOUBLE(x) +#define __Pyx_PyFloat_IsNonZero(x) (PyFloat_AS_DOUBLE(x) != 0.0) +#else +#define __Pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AsDouble(x) +#define __Pyx_PyFloat_IsNonZero(x) PyObject_IsTrue(x) +#endif +#define __Pyx_PyFloat_AsFloat(x) ((float) __Pyx_PyFloat_AsDouble(x)) +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_SignBits(x) ((int) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)) + #define __Pyx_PyLong_Sign(x) (1 - __Pyx_PyLong_SignBits(x)) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_SignBits(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_SignBits(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_SignBits(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + (((Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) (((Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + static CYTHON_INLINE Py_ssize_t __Pyx_PyLong_CompareSignAndSize(PyObject *a, PyObject *b) { + uintptr_t tag_a = ((PyLongObject*)a)->long_value.lv_tag; + uintptr_t tag_b = ((PyLongObject*)b)->long_value.lv_tag; + if (tag_a == tag_b) return 0; + int sign_a = (int) (tag_a & _PyLong_SIGN_MASK); + int sign_b = (int) (tag_b & _PyLong_SIGN_MASK); + if (sign_a > sign_b) return -1; + if (sign_a < sign_b) return 1; + Py_ssize_t size_a = (Py_ssize_t) (tag_a >> _PyLong_NON_SIZE_BITS); + Py_ssize_t size_b = (Py_ssize_t) (tag_b >> _PyLong_NON_SIZE_BITS); + return (1 - sign_a) * (size_a - size_b); + } + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_Sign(x) ((int) ((Py_SIZE(x) == 0) ? 0 : (Py_SIZE(x) < 0) ? -1 : 1)) + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + #define __Pyx_PyLong_CompareSignAndSize(a, b) (Py_SIZE(a) - Py_SIZE(b)) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif + #define __Pyx_PyLong_IsNonZero(x) (!__Pyx_PyLong_IsZero(x)) +#else + #define __Pyx_PyLong_IsNonZero(x) PyObject_IsTrue(x) +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#elif __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeASCII(c_str, size, NULL) +#else + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#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__ */ +/* PretendToInitialize */ +#ifdef __cplusplus +#if __cplusplus > 201103L +#include +#endif +template +static void __Pyx_pretend_to_initialize(T* ptr) { +#if __cplusplus > 201103L + if ((std::is_trivially_default_constructible::value)) +#endif + *ptr = T(); + (void)ptr; +} +#else +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#endif + + +#if !CYTHON_USE_MODULE_STATE +static PyObject *__pyx_m = NULL; +#endif +static const char * const __pyx_cfilenm = __FILE__; + +/* #### Code section: filename_table ### */ + +static const char* const __pyx_f[] = { + "aiohttp/_websocket/reader_py.py", + "aiohttp/_websocket/reader_c.pxd", + "(tree fragment)", +}; +/* #### Code section: utility_code_proto_before_types ### */ +/* Atomics.proto (used by UnpackUnboundCMethod) */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS +#define __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __pyx_atomic_int_type int +#define __pyx_nonatomic_int_type int +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__)) + #include +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ + (defined(_MSC_VER) && _MSC_VER >= 1700))) + #include +#endif +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type atomic_int + #define __pyx_atomic_ptr_type atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) atomic_fetch_add_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) atomic_load(value) + #define __pyx_atomic_store(value, new_value) atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) atomic_load_explicit(value, memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) atomic_load_explicit(value, memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #define __pyx_atomic_pointer_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C atomics" + #endif +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ +\ + (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type std::atomic_int + #define __pyx_atomic_ptr_type std::atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) std::atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) std::atomic_load(value) + #define __pyx_atomic_store(value, new_value) std::atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) std::atomic_load_explicit(value, std::memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) std::atomic_load_explicit(value, std::memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) std::atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #define __pyx_atomic_pointer_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C++ atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C++ atomics" + #endif +#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ + (__GNUC_MINOR__ > 1 ||\ + (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) + #define __pyx_atomic_ptr_type void* + #define __pyx_nonatomic_ptr_type void* + #define __pyx_atomic_incr_relaxed(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_incr_acq_rel(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_acq_rel(value) __sync_fetch_and_sub(value, 1) + #define __pyx_atomic_sub(value, arg) __sync_fetch_and_sub(value, arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = __sync_val_compare_and_swap(value, *expected, desired); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_store(value, new_value) __sync_lock_test_and_set(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_load_acquire(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) __sync_lock_test_and_set(value, (__pyx_atomic_ptr_type)new_value) + static CYTHON_INLINE int __pyx_atomic_pointer_cmp_exchange(__pyx_atomic_ptr_type* value, __pyx_nonatomic_ptr_type* expected, __pyx_nonatomic_ptr_type desired) { + __pyx_nonatomic_ptr_type old = __sync_val_compare_and_swap(value, *expected, desired); + int result = old == *expected; + *expected = old; + return result; + } + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using GNU atomics" + #endif +#elif CYTHON_ATOMICS && defined(_MSC_VER) + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type long + #define __pyx_atomic_ptr_type void* + #undef __pyx_nonatomic_int_type + #define __pyx_nonatomic_int_type long + #define __pyx_nonatomic_ptr_type void* + #pragma intrinsic (_InterlockedExchangeAdd, _InterlockedExchange, _InterlockedCompareExchange, _InterlockedCompareExchangePointer, _InterlockedExchangePointer) + #define __pyx_atomic_incr_relaxed(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_incr_acq_rel(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_decr_acq_rel(value) _InterlockedExchangeAdd(value, -1) + #define __pyx_atomic_sub(value, arg) _InterlockedExchangeAdd(value, -arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = _InterlockedCompareExchange(value, desired, *expected); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) _InterlockedExchangeAdd(value, 0) + #define __pyx_atomic_store(value, new_value) _InterlockedExchange(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) *(void * volatile *)value + #define __pyx_atomic_pointer_load_acquire(value) _InterlockedCompareExchangePointer(value, 0, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) _InterlockedExchangePointer(value, (__pyx_atomic_ptr_type)new_value) + static CYTHON_INLINE int __pyx_atomic_pointer_cmp_exchange(__pyx_atomic_ptr_type* value, __pyx_nonatomic_ptr_type* expected, __pyx_nonatomic_ptr_type desired) { + __pyx_atomic_ptr_type old = _InterlockedCompareExchangePointer(value, desired, *expected); + int result = old == *expected; + *expected = old; + return result; + } + #ifdef __PYX_DEBUG_ATOMICS + #pragma message ("Using MSVC atomics") + #endif +#else + #undef CYTHON_ATOMICS + #define CYTHON_ATOMICS 0 + #ifdef __PYX_DEBUG_ATOMICS + #warning "Not using atomics" + #endif +#endif + +/* CriticalSectionsDefinition.proto (used by CriticalSections) */ +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_PyCriticalSection void* +#define __Pyx_PyCriticalSection2 void* +#define __Pyx_PyCriticalSection_End(cs) +#define __Pyx_PyCriticalSection2_End(cs) +#else +#define __Pyx_PyCriticalSection PyCriticalSection +#define __Pyx_PyCriticalSection2 PyCriticalSection2 +#define __Pyx_PyCriticalSection_End PyCriticalSection_End +#define __Pyx_PyCriticalSection2_End PyCriticalSection2_End +#endif + +/* CriticalSections.proto (used by ParseKeywordsImpl) */ +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_PyCriticalSection_Begin(cs, arg) (void)(cs) +#define __Pyx_PyCriticalSection2_Begin(cs, arg1, arg2) (void)(cs) +#else +#define __Pyx_PyCriticalSection_Begin PyCriticalSection_Begin +#define __Pyx_PyCriticalSection2_Begin PyCriticalSection2_Begin +#endif +#if PY_VERSION_HEX < 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_BEGIN_CRITICAL_SECTION(o) { +#define __Pyx_END_CRITICAL_SECTION() } +#else +#define __Pyx_BEGIN_CRITICAL_SECTION Py_BEGIN_CRITICAL_SECTION +#define __Pyx_END_CRITICAL_SECTION Py_END_CRITICAL_SECTION +#endif + +/* IncludeStructmemberH.proto (used by CoroutineBase) */ +#include + +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ + +/*--- Type declarations ---*/ +struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue; +struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader; +struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read; + +/* "aiohttp/_websocket/reader_c.pxd":49 + * cdef unsigned int MSG_SIZE_OVERHEAD + * + * cdef class WebSocketDataQueue: # <<<<<<<<<<<<<< + * + * cdef readonly unsigned int _size +*/ +struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue { + PyObject_HEAD + struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_vtab; + unsigned int _size; + PyObject *_protocol; + unsigned int _limit; + PyObject *_loop; + int _eof; + PyObject *_waiter; + PyObject *_exception; + PyObject *_buffer; + PyObject *_get_buffer; + PyObject *_put_buffer; + PyObject *_stalled_reader; +}; + + +/* "aiohttp/_websocket/reader_c.pxd":71 + * cdef _read_from_buffer(self) + * + * cdef class WebSocketReader: # <<<<<<<<<<<<<< + * + * # cdef classes are not weak-referenceable without this; the queue parks a +*/ +struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader { + PyObject_HEAD + struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_vtab; + PyObject *__weakref__; + PyObject *_weak_self; + struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *queue; + unsigned int _max_msg_size; + int _decode_text; + PyObject *_exc; + PyObject *_partial; + unsigned int _state; + int _opcode; + int _frame_fin; + int _frame_opcode; + PyObject *_payload_fragments; + Py_ssize_t _max_fragments; + Py_ssize_t _frame_payload_len; + PyObject *_tail; + int _has_mask; + PyObject *_frame_mask; + Py_ssize_t _payload_bytes_to_read; + unsigned int _payload_len_flag; + int _compressed; + PyObject *_decompressobj; + int _compress; +}; + + +/* "aiohttp/_websocket/reader_py.py":141 + * self._protocol.pause_reading() + * + * async def read(self) -> WSMessage: # <<<<<<<<<<<<<< + * if not self._buffer and not self._eof: + * assert not self._waiter +*/ +struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read { + PyObject_HEAD + struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self; + PyObject *__pyx_t_0; + PyObject *__pyx_t_1; + PyObject *__pyx_t_2; +}; + + + +/* "aiohttp/_websocket/reader_py.py":81 + * + * + * class WebSocketDataQueue: # <<<<<<<<<<<<<< + * """WebSocketDataQueue resumes and pauses an underlying stream. + * +*/ + +struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue { + void (*_release_waiter)(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *); + void (*feed_data)(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *, PyObject *, int __pyx_skip_dispatch); + PyObject *(*_read_from_buffer)(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *); +}; +static struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_vtabptr_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue; + + +/* "aiohttp/_websocket/reader_py.py":190 + * + * + * class WebSocketReader: # <<<<<<<<<<<<<< + * def __init__( + * self, +*/ + +struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketReader { + PyObject *(*feed_data)(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *, PyObject *, int __pyx_skip_dispatch); + void (*_handle_frame)(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *, int, int, PyObject *, int, int __pyx_skip_dispatch); + void (*_feed_data)(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *, PyObject *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_vtabptr_7aiohttp_10_websocket_8reader_c_WebSocketReader; +/* #### Code section: utility_code_proto ### */ + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, 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; + #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__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } + #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); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() + #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_Py_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; Py_XDECREF(tmp);\ + } while (0) +#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) + +/* CopyObjectArray.proto (used by TupleOrListFromArrayImpl) */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length); +#endif + +/* TupleOrListFromArrayImpl.proto (used by TupleFromArray) */ +#if PY_VERSION_HEX >= 0x030F0000 && !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_PyTuple_FromArray(src, n) PyTuple_FromArray(src, ((n)<0) ? 0 : (n)) +#else +CYTHON_UNUSED static PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* TupleFromArray.proto (used by fastcall) */ + + +/* IncludeStringH.proto (used by PyObjectCompare) */ +#include + +/* PyObjectCompare.proto (used by UnicodeEquals) */ +static CYTHON_INLINE int __Pyx_PyObject_CompareBoolEq_str_str(PyObject *op1, PyObject *op2, int pyop); + +/* UnicodeEquals.proto (used by fastcall) */ +#define __Pyx_PyUnicode_Equals(s1, s2) __Pyx_PyObject_CompareBoolEq_str_str(s1, s2, Py_EQ) + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i)) +#else + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_XNewRef(PyTuple_GetItem(args, i)) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_VECTORCALL + #define __Pyx_ArgRef_FASTCALL(args, i) __Pyx_NewRef(args[i]) + #define __Pyx_NumKwargs_FASTCALL(kwds) __Pyx_PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif +#else + #define __Pyx_ArgRef_FASTCALL __Pyx_ArgRef_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS +#endif +#if CYTHON_VECTORCALL_TPNEW + #if !CYTHON_VECTORCALL + #error Enabling CYTHON_VECTORCALL_TPNEW without CYTHON_VECTORCALL is not supported + #endif + #define __Pyx_ArgRef_FASTCALL_TPNEW __Pyx_ArgRef_FASTCALL + #define __Pyx_NumKwargs_FASTCALL_TPNEW __Pyx_NumKwargs_FASTCALL + #define __Pyx_KwValues_FASTCALL_TPNEW __Pyx_KwValues_FASTCALL + #define __Pyx_GetKwValue_FASTCALL_TPNEW __Pyx_GetKwValue_FASTCALL + #define __Pyx_KwargsAsDict_FASTCALL_TPNEW __Pyx_KwargsAsDict_FASTCALL +#else + #define __Pyx_ArgRef_FASTCALL_TPNEW __Pyx_ArgRef_VARARGS + #define __Pyx_NumKwargs_FASTCALL_TPNEW __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL_TPNEW __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL_TPNEW __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL_TPNEW __Pyx_KwargsAsDict_VARARGS +#endif +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#if CYTHON_VECTORCALL +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(args + start, stop - start) +#else +#define __Pyx_ArgsSlice_FASTCALL __Pyx_ArgsSlice_VARARGS +#endif + +/* py_dict_items.proto (used by OwnedDictNext) */ +#define __Pyx_PyDict_items_TypePtr (&PyDictKeys_Type) +#define __Pyx_PyDict_items_Check(obj) PyObject_TypeCheck((obj), __Pyx_PyDictItems_TypePtr) +#define __Pyx_PyDict_items_CheckExact(obj) Py_IS_TYPE((obj), __Pyx_PyDictItems_TypePtr) +static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d); + +/* CallCFunction.proto (used by CallUnboundCMethod0) */ +#define __Pyx_CallCFunction(cfunc, self, args)\ + ((PyCFunction)(void(*)(void))(cfunc)->func)(self, args) +#define __Pyx_CallCFunctionWithKeywords(cfunc, self, args, kwargs)\ + ((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self, args, kwargs) +#define __Pyx_CallCFunctionFast(cfunc, self, args, nargs)\ + ((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs) +#define __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, nargs, kwnames)\ + ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs, kwnames) + +/* PyObjectCall.proto (used by PyObjectFastCall) */ +#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 (used by PyObjectFastCall) */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectFastCall.proto (used by PyObjectCallOneArg) */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject * const*args, size_t nargsf, PyObject *kwargs); + +/* PyObjectCallOneArg.proto (used by CallUnboundCMethod0) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* UnpackUnboundCMethod_decl.proto (used by UnpackUnboundCMethod) */ +typedef struct { + PyObject *type; + PyObject **method_name; + PyCFunction func; + PyObject *method; + int flag; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS + __pyx_atomic_int_type initialized; +#endif +} __Pyx_CachedCFunction; + +/* IgnoreException.proto (used by UnpackUnboundCMethod_impl) */ +static CYTHON_INLINE int __Pyx_IgnoreGivenException(PyObject *given_exception, PyObject *ignorable_exception); +#define __Pyx_IgnoreException(ignorable_exception) __Pyx_IgnoreGivenException(NULL, ignorable_exception) + +/* FastTypeChecks.proto (used by UnpackUnboundCMethod_impl) */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); +#define __Pyx_PyAnySet_Check(obj) __Pyx_TypeCheck2(obj, &PySet_Type, &PyFrozenSet_Type) +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) +#define __Pyx_PyAnySet_Check(obj) PyAnySet_Check(obj) +#endif + +/* PyObjectGetAttrStr.proto (used by UnpackUnboundCMethod_impl) */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* UnpackUnboundCMethod_impl.export */ +static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target); + +/* UnpackUnboundCMethod.proto (used by CallUnboundCMethod0) */ +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +static CYTHON_INLINE int __Pyx_CachedCFunction_GetAndSetInitializing(__Pyx_CachedCFunction *cfunc) { +#if !CYTHON_ATOMICS + return 1; +#else + __pyx_nonatomic_int_type expected = 0; + if (__pyx_atomic_int_cmp_exchange(&cfunc->initialized, &expected, 1)) { + return 0; + } + return expected; +#endif +} +static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_CachedCFunction *cfunc) { +#if CYTHON_ATOMICS + __pyx_atomic_store(&cfunc->initialized, 2); +#endif +} +#else +#define __Pyx_CachedCFunction_GetAndSetInitializing(cfunc) 2 +#define __Pyx_CachedCFunction_SetFinishedInitializing(cfunc) +#endif + +/* CallUnboundCMethod0.proto */ +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); +#else +#define __Pyx_CallUnboundCMethod0(cfunc, self) __Pyx__CallUnboundCMethod0(cfunc, self) +#endif + +/* py_dict_values.proto (used by OwnedDictNext) */ +#define __Pyx_PyDict_values_TypePtr (&PyDictKeys_Type) +#define __Pyx_PyDict_values_Check(obj) PyObject_TypeCheck((obj), __Pyx_PyDictValues_TypePtr) +#define __Pyx_PyDict_values_CheckExact(obj) Py_IS_TYPE((obj), __Pyx_PyDictValues_TypePtr) +static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d); + +/* OwnedDictNext.proto (used by ParseKeywordsImpl) */ +#if CYTHON_AVOID_BORROWED_REFS +static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, PyObject **pvalue); +#else +CYTHON_INLINE +static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue); +#endif + +/* RaiseDoubleKeywords.proto (used by ParseKeywordsImpl) */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywordsImpl.export */ +static int __Pyx_ParseKeywordsTuple( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); +static int __Pyx_ParseKeywordDictToDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name +); +static int __Pyx_ParseKeywordDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); + +/* CallUnboundCMethod2.proto */ +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2); +#else +#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2) +#endif + +/* ParseKeywords.proto */ +static CYTHON_INLINE int __Pyx_ParseKeywords( + PyObject *kwds, PyObject *const *kwvalues, PyObject ** const argnames[], + PyObject *kwds2, PyObject *values[], + Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); + +/* RaiseArgTupleInvalid.export */ +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); + +/* RaiseKeywordRequired.proto */ +static void __Pyx_RaiseKeywordRequired(const char* func_name, PyObject* kw_name); + +/* FormatTypeName.proto (used by pybuiltin_invalid) */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%N" +#define __Pyx_PyType_GetFullyQualifiedName(tp) Py_NewRef((PyObject*)tp) +#define __Pyx_DECREF_TypeName(obj) Py_DECREF(obj) +#elif CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp); +#else // !LIMITED_API +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetFullyQualifiedName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + +/* pybuiltin_invalid.export */ +static void __Pyx_PyBuiltin_Invalid(PyObject *obj, const char *builtin_type_name, const char *argname); + +/* pyint_simplify.proto */ +static CYTHON_INLINE int __Pyx_PyInt_FromNumber(PyObject **number_var, const char *argname, int accept_none); + +/* ArgTypeTestError.export */ +static void __Pyx_ArgTypeError(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* ArgTypeTest.proto */ +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, const char *name, int exact); + +/* PyLongBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static CYTHON_INLINE PyObject* __Pyx_PyLong_MultiplyObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyLong_MultiplyObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceMultiply(op1, op2) : PyNumber_Multiply(op1, op2)) +#endif + +/* PyThreadStateGet.proto (used by PyErrFetchRestore) */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto (used by GivenExceptionMatches) */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#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); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, 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 + +/* GivenExceptionMatches.proto (used by PyErrExceptionMatches) */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2) { + return PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2); +} +#endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) + +/* PyErrExceptionMatches.proto (used by PyObjectGetAttrStrNoError) */ +#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 + +/* PyObjectGetAttrStrNoError.proto (used by GetBuiltinName) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* GetBuiltinName.proto (used by GetModuleGlobalName) */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* PyDictVersioning.proto (used by GetModuleGlobalName) */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __Pyx_XNewRef(__pyx_dict_cached_value);\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + +/* GetModuleGlobalName.proto */ +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) do {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_mstate_global->__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif + +/* RejectKeywords.export */ +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds); + +/* PyObjectFastCallMethod.proto */ +#if CYTHON_VECTORCALL +#define __Pyx_PyObject_FastCallMethod(name, args, nargsf) PyObject_VectorcallMethod(name, args, nargsf, NULL) +#else +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf); +#endif + +/* AssertionsEnabled.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000 + static int __pyx_assertions_enabled_flag; + #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag) + #if __clang__ || __GNUC__ + __attribute__((no_sanitize("thread"))) + #endif + static int __Pyx_init_assertions_enabled(void) { + PyObject *builtins, *debug, *debug_str; + int flag; + builtins = PyEval_GetBuiltins(); + if (!builtins) goto bad; + debug_str = PyUnicode_FromStringAndSize("__debug__", 9); + if (!debug_str) goto bad; + debug = PyObject_GetItem(builtins, debug_str); + Py_DECREF(debug_str); + if (!debug) goto bad; + flag = PyObject_IsTrue(debug); + Py_DECREF(debug); + if (flag == -1) goto bad; + __pyx_assertions_enabled_flag = flag; + return 0; + bad: + __pyx_assertions_enabled_flag = 1; + return -1; + } +#else + #define __Pyx_init_assertions_enabled() (0) + #define __pyx_assertions_enabled() (!Py_OptimizeFlag) +#endif + +/* PyAssertionError_Check.proto */ +#define __Pyx_PyExc_AssertionError_Check(obj) __Pyx_TypeCheck(obj, PyExc_AssertionError) + +/* RaiseException.export */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* dict_setdefault.proto (used by FetchCommonType) */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value); + +/* AddModuleRef.proto (used by FetchSharedCythonModule) */ +#if ((CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && PY_VERSION_HEX < 0x030F00a3) ||\ + __PYX_LIMITED_VERSION_HEX < 0x030d0000) + static PyObject *__Pyx_PyImport_AddModuleRef(const char *name); +#else + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#endif + +/* FetchSharedCythonModule.proto (used by FetchCommonType) */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* VerifyCachedType.proto (used by FetchCommonType) */ +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t expected_basicsize); + +/* FetchCommonType.proto (used by CommonTypesMetaclass) */ +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases); + +/* CommonTypesMetaclass.proto (used by CoroutineBase) */ +static int __pyx_CommonTypesMetaclass_init(PyObject *module); +#define __Pyx_CommonTypesMetaclass_USED + +/* GetTopmostException.proto (used by SaveResetException) */ +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* SaveResetException.proto (used by CoroutineBase) */ +#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 + +/* SwapException.proto (used by CoroutineBase) */ +#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 + +/* CallTypeTraverse.proto (used by CoroutineBase) */ +#if !CYTHON_USE_TYPE_SPECS +#define __Pyx_call_type_traverse(o, always_call, visit, arg) 0 +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); +#endif + +/* IterNextPlain.proto (used by CoroutineBase) */ +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next_Plain(PyObject *iterator); +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject *__Pyx_GetBuiltinNext_LimitedAPI(void); +#endif + +/* PyObjectCallMethod1.proto (used by CoroutineBase) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); + +/* PyObjectCallNoArg.proto (used by CoroutineBase) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + +/* RaiseErrorWithObjectType.proto (used by CoroutineBase) */ +#define __Pyx_RaiseTypeErrorWithObjectType(message, obj) __Pyx_RaiseErrorWithObjectType(PyExc_TypeError, message, obj) +#define __Pyx_RaiseErrorWithObjectType(exc_type, message, obj) __Pyx_RaiseErrorWithType(exc_type, message, Py_TYPE(obj)) +CYTHON_UNUSED +static void __Pyx_RaiseErrorWithType(PyObject* exc_type, const char* message, PyTypeObject *type_obj); + +/* ReturnWithStopIteration.proto (used by CoroutineBase) */ +static CYTHON_INLINE void __Pyx_ReturnWithStopIteration(PyObject* value, int async, int iternext); + +/* CoroutineBase.proto (used by Coroutine) */ +struct __pyx_CoroutineObject; +typedef PyObject *(*__pyx_coroutine_body_t)(struct __pyx_CoroutineObject *, PyThreadState *, PyObject *); +#if CYTHON_USE_EXC_INFO_STACK +#define __Pyx_ExcInfoStruct _PyErr_StackItem +#else +typedef struct { + PyObject *exc_type; + PyObject *exc_value; + PyObject *exc_traceback; +} __Pyx_ExcInfoStruct; +#endif +typedef struct __pyx_CoroutineObject { + PyObject_HEAD + __pyx_coroutine_body_t body; + PyObject *closure; + __Pyx_ExcInfoStruct gi_exc_state; +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *gi_weakreflist; +#endif + PyObject *classobj; + PyObject *yieldfrom; + __Pyx_pyiter_sendfunc yieldfrom_am_send; + PyObject *gi_name; + PyObject *gi_qualname; + PyObject *gi_modulename; + PyObject *gi_code; + PyObject *gi_frame; +#if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE) + PyMonitoringState __pyx_pymonitoring_state[__Pyx_MonitoringEventTypes_CyGen_count]; + uint64_t __pyx_pymonitoring_version; +#endif + int resume_label; + char is_running; +} __pyx_CoroutineObject; +static __pyx_CoroutineObject *__Pyx__Coroutine_New( + PyTypeObject *type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name); +static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( + __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name); +static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *self); +static int __Pyx_Coroutine_clear(PyObject *self); +static __Pyx_PySendResult __Pyx_Coroutine_AmSend(PyObject *self, PyObject *value, PyObject **retval); +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); +static __Pyx_PySendResult __Pyx_Coroutine_Close(PyObject *self, PyObject **retval); +static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + PyObject *args +#else + PyObject *const *args, Py_ssize_t nargs +#endif + ); +#if CYTHON_USE_EXC_INFO_STACK +#define __Pyx_Coroutine_SwapException(self) +#define __Pyx_Coroutine_ResetAndClearException(self) __Pyx_Coroutine_ExceptionClear(&(self)->gi_exc_state) +#else +#define __Pyx_Coroutine_SwapException(self) {\ + __Pyx_ExceptionSwap(&(self)->gi_exc_state.exc_type, &(self)->gi_exc_state.exc_value, &(self)->gi_exc_state.exc_traceback);\ + __Pyx_Coroutine_ResetFrameBackpointer(&(self)->gi_exc_state);\ + } +#define __Pyx_Coroutine_ResetAndClearException(self) {\ + __Pyx_ExceptionReset((self)->gi_exc_state.exc_type, (self)->gi_exc_state.exc_value, (self)->gi_exc_state.exc_traceback);\ + (self)->gi_exc_state.exc_type = (self)->gi_exc_state.exc_value = (self)->gi_exc_state.exc_traceback = NULL;\ + } +#endif +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ + __Pyx_PyGen__FetchStopIterationValue(__pyx_tstate, pvalue) +#else +#define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ + __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, pvalue) +#endif +static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *tstate, PyObject **pvalue); +static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state); +static char __Pyx_Coroutine_test_and_set_is_running(__pyx_CoroutineObject *gen); +static void __Pyx_Coroutine_unset_is_running(__pyx_CoroutineObject *gen); +static char __Pyx_Coroutine_get_is_running(__pyx_CoroutineObject *gen); +static PyObject *__Pyx_Coroutine_get_is_running_getter(PyObject *gen, void *closure); +#if __PYX_HAS_PY_AM_SEND == 2 +static void __Pyx_SetBackportTypeAmSend(PyTypeObject *type, __Pyx_PyAsyncMethodsStruct *static_amsend_methods, __Pyx_pyiter_sendfunc am_send); +#endif +static PyObject *__Pyx_Coroutine_fail_reduce_ex(PyObject *self, PyObject *arg); + +/* Coroutine.proto (used by CoroutineYieldFrom) */ +#define __Pyx_Coroutine_USED +#define __Pyx_Coroutine_CheckExact(obj) Py_IS_TYPE(obj, __pyx_mstate_global->__pyx_CoroutineType) +#define __Pyx_Coroutine_Check(obj) __Pyx_Coroutine_CheckExact(obj) +#define __Pyx_CoroutineAwait_CheckExact(obj) Py_IS_TYPE(obj, __pyx_mstate_global->__pyx_CoroutineAwaitType) +#define __Pyx_Coroutine_New(body, code, closure, name, qualname, module_name)\ + __Pyx__Coroutine_New(__pyx_mstate_global->__pyx_CoroutineType, body, code, closure, name, qualname, module_name) +static int __pyx_Coroutine_init(PyObject *module); +static PyObject *__Pyx__Coroutine_await(PyObject *coroutine); +typedef struct { + PyObject_HEAD + PyObject *coroutine; +} __pyx_CoroutineAwaitObject; +static __Pyx_PySendResult __Pyx_CoroutineAwait_Close(__pyx_CoroutineAwaitObject *self); + +/* Coro_CheckExact.proto (used by GetAwaitIter) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_PyCoro_CheckExact(PyObject *o); +#else +#define __Pyx_PyCoro_CheckExact PyCoro_CheckExact +#endif + +/* PyObjectGetMethod.proto (used by GetAwaitIter) */ +#if !CYTHON_VECTORCALL +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); +#endif + +/* GetAwaitIter.proto (used by CoroutineYieldFrom) */ +static CYTHON_INLINE PyObject *__Pyx_Coroutine_GetAwaitableIter(PyObject *o); +static PyObject *__Pyx__Coroutine_GetAwaitableIter(PyObject *o); + +/* CoroutineYieldFrom.proto */ +static CYTHON_INLINE __Pyx_PySendResult __Pyx_Coroutine_Yield_From(__pyx_CoroutineObject *gen, PyObject *source, PyObject **retval); + +/* 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 + +/* pep479.proto */ +static void __Pyx_Generator_Replace_StopIteration(int in_async_gen); + +/* DivInt[long].proto */ +static CYTHON_INLINE long __Pyx_div_long(long, long, int b_is_constant); + +/* PyRuntimeError_Check.proto */ +#define __Pyx_PyExc_RuntimeError_Check(obj) __Pyx_TypeCheck(obj, PyExc_RuntimeError) + +/* GetAttr3.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); + +/* RaiseErrorWithObjectType1.proto (used by RaiseUnexpectedTypeError) */ +#define __Pyx_RaiseTypeErrorWithObjectType1(message, arg, obj) __Pyx_RaiseErrorWithObjectType1(PyExc_TypeError, message, arg, obj) +#define __Pyx_RaiseErrorWithObjectType1(exc_type, message, arg, obj) __Pyx_RaiseErrorWithType1(exc_type, message, arg, Py_TYPE(obj)) +CYTHON_UNUSED +static void __Pyx_RaiseErrorWithType1(PyObject* exc_type, const char* message, const char *arg, PyTypeObject *type_obj); + +/* RaiseUnexpectedTypeError.proto */ +CYTHON_UNUSED +static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); + +/* PyLongBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static CYTHON_INLINE PyObject* __Pyx_PyLong_FloorDivideObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyLong_FloorDivideObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceFloorDivide(op1, op2) : PyNumber_FloorDivide(op1, op2)) +#endif + +/* PyObjectCompare.proto */ +static CYTHON_INLINE int __Pyx_PyObject_CompareBoolGt_int_int(PyObject *op1, PyObject *op2, int pyop); + +/* PyException_Check.proto */ +#define __Pyx_PyExc_Exception_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) + +/* PyBaseException_Check.proto */ +#define __Pyx_PyExc_BaseException_Check(obj) PyExceptionInstance_Check(obj) + +/* BuildPyUnicode.proto (used by COrdinalToPyUnicode) */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength, + int prepend_sign, char padding_char); + +/* COrdinalToPyUnicode.proto (used by CIntToPyUnicode) */ +static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value); +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t width, char padding_char); + +/* GCCDiagnostics.proto (used by CIntToPyUnicode) */ +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +/* IncludeStdlibH.proto (used by CIntToPyUnicode) */ +#include + +/* CIntToPyUnicode.proto */ +#define __Pyx_PyUnicode_From_int(value, width, padding_char, format_char) (\ + ((format_char) == ('c')) ?\ + __Pyx_uchar___Pyx_PyUnicode_From_int(value, width, padding_char) :\ + __Pyx____Pyx_PyUnicode_From_int(value, width, padding_char, format_char)\ + ) +static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char); +static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char); + +/* PyObjectVectorcallKwds.proto */ +#if CYTHON_VECTORCALL +#define __Pyx_Object_VectorcallKwds PyObject_Vectorcall +CYTHON_UNUSED static int __Pyx_CheckVectorcallKwarg(PyObject *kwnames, Py_ssize_t i); +#else +#define __Pyx_Object_VectorcallKwds __Pyx_PyObject_FastCallDict +CYTHON_UNUSED static PyObject *__Pyx_MakeKwargDict(PyObject **keys, PyObject **values, Py_ssize_t n); +CYTHON_UNUSED static int __Pyx_CheckVectorcallKwarg(PyObject **kwnames, Py_ssize_t i); +#endif + +/* RaiseErrorWithObjectTypes.proto (used by PyNumberBinop) */ +#define __Pyx_RaiseErrorWithObjectTypes1(exc_type, message, arg, obj1, obj2) __Pyx_RaiseErrorWithTypes1(exc_type, message, arg, Py_TYPE(obj1), Py_TYPE(obj2)) +#define __Pyx_RaiseTypeErrorWithObjectTypes(message, obj1, obj2) __Pyx_RaiseTypeErrorWithTypes(message, Py_TYPE(obj1), Py_TYPE(obj2)) +#define __Pyx_RaiseTypeErrorWithTypes(message, type_obj1, type_obj2) __Pyx_RaiseErrorWithTypes1(PyExc_TypeError, "%.1s" message, "", type_obj1, type_obj2) +CYTHON_UNUSED +static void __Pyx_RaiseErrorWithTypes1(PyObject* exc_type, const char *message, const char *arg, PyTypeObject *type_obj1, PyTypeObject *type_obj2); + +/* PyNumberBinop.proto */ +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_PyNumber_Add_object_object(op1, op2) PyNumber_Add(op1, op2) +#define __Pyx_PyNumber_InPlaceAdd_object_object(op1, op2) PyNumber_InPlaceAdd(op1, op2) +#else +#define __Pyx_PyNumber_Add_object_object(op1, op2) __Pyx__PyNumber_Add_object_object(op1, op2, 0) +#define __Pyx_PyNumber_InPlaceAdd_object_object(op1, op2) __Pyx__PyNumber_Add_object_object(op1, op2, 1) +static CYTHON_INLINE PyObject* __Pyx__PyNumber_Add_object_object(PyObject *op1, PyObject *op2, int inplace); +#endif + +/* CIntToPyUnicode.proto */ +#define __Pyx_PyUnicode_From_unsigned_int(value, width, padding_char, format_char) (\ + ((format_char) == ('c')) ?\ + __Pyx_uchar___Pyx_PyUnicode_From_unsigned_int(value, width, padding_char) :\ + __Pyx____Pyx_PyUnicode_From_unsigned_int(value, width, padding_char, format_char)\ + ) +static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_unsigned_int(unsigned int value, Py_ssize_t width, char padding_char); +static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_unsigned_int(unsigned int value, Py_ssize_t width, char padding_char, char format_char); + +/* decode_c_string_utf16.proto (used by decode_c_bytes) */ +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 0; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = -1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} + +/* decode_c_bytes.proto (used by decode_bytes) */ +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)) { + char* as_c_string; + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + as_c_string = PyBytes_AS_STRING(string); + size = PyBytes_GET_SIZE(string); +#else + if (PyBytes_AsStringAndSize(string, &as_c_string, &size) < 0) { + return NULL; + } +#endif + return __Pyx_decode_c_bytes( + as_c_string, size, + start, stop, encoding, errors, decode_func); +} + +/* PyUnicodeDecodeError_Check.proto */ +#define __Pyx_PyExc_UnicodeDecodeError_Check(obj) __Pyx_TypeCheck(obj, PyExc_UnicodeDecodeError) + +/* 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); + +/* PyFrozenDict.proto (used by GetItemInt) */ +#if CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_PyFrozenDict_TypePtr ((PyTypeObject*) __pyx_mstate_global->__Pyx_PyFrozenDictType) +#define __Pyx_PyFrozenDict_New(it) __Pyx__PyFrozenDict_New(__pyx_mstate_global->__Pyx_PyFrozenDictType, it) +static CYTHON_INLINE PyObject* __Pyx__PyFrozenDict_New(PyObject* frozendict_type, PyObject* it); +#define __Pyx_PyFrozenDict_NewEmpty() __Pyx_PyFrozenDict_New(NULL) +#define __Pyx_PyFrozenDict_Check(obj) PyObject_TypeCheck((obj), __Pyx_PyFrozenDict_TypePtr) +#define __Pyx_PyFrozenDict_CheckExact(obj) Py_IS_TYPE((obj), __Pyx_PyFrozenDict_TypePtr) +#define __Pyx_PyAnyDict_Check(obj) __Pyx__PyAnyDict_Check(obj, __Pyx_PyFrozenDict_TypePtr) +static CYTHON_INLINE int __Pyx__PyAnyDict_Check(PyObject *obj, PyTypeObject* frozendict_type) { + return PyObject_TypeCheck(obj, &PyDict_Type) || PyObject_TypeCheck(obj, frozendict_type); +} +#define __Pyx_PyAnyDict_CheckExact(obj) __Pyx__PyAnyDict_CheckExact(obj, __Pyx_PyFrozenDict_TypePtr) +static CYTHON_INLINE int __Pyx__PyAnyDict_CheckExact(PyObject *obj, PyTypeObject* frozendict_type) { + return Py_IS_TYPE(obj, &PyDict_Type) || Py_IS_TYPE(obj, frozendict_type); +} +#elif PY_VERSION_HEX >= 0x030f00a6 ||\ + (defined(PyFrozenDict_Check) && defined(PyAnyDict_Check) && defined(PyFrozenDict_New)) +#define __Pyx_PyFrozenDict_TypePtr (&PyFrozenDict_Type) +#define __Pyx_PyFrozenDict_New(it) PyFrozenDict_New(it) +#define __Pyx_PyFrozenDict_NewEmpty() PyFrozenDict_New(NULL) +#define __Pyx_PyFrozenDict_Check(obj) PyFrozenDict_Check(obj) +#define __Pyx_PyFrozenDict_CheckExact(obj) PyFrozenDict_CheckExact(obj) +#define __Pyx_PyAnyDict_Check(obj) PyAnyDict_Check(obj) +#define __Pyx_PyAnyDict_CheckExact(obj) PyAnyDict_CheckExact(obj) +#else +#define __Pyx_PyFrozenDict_TypePtr (&PyDict_Type) +static CYTHON_INLINE PyObject* __Pyx_PyFrozenDict_New(PyObject* it) { + if (!it) { + return PyDict_New(); + } else if (PyDict_Check(it)) { + return PyDict_Copy(it); + } else { + PyObject *dict = PyDict_New(); + if (!dict) return NULL; + PyObject *result = PyNumber_InPlaceOr(dict, it); + Py_DECREF(dict); + return result; + } +} +#define __Pyx_PyFrozenDict_NewEmpty() PyDict_New() +#define __Pyx_PyFrozenDict_Check(obj) PyDict_Check(obj) +#define __Pyx_PyFrozenDict_CheckExact(obj) PyDict_CheckExact(obj) +#define __Pyx_PyAnyDict_Check(obj) PyDict_Check(obj) +#define __Pyx_PyAnyDict_CheckExact(obj) PyDict_CheckExact(obj) +#endif + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, wraparound, boundscheck, has_gil, unsafe_shared)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, unsafe_shared) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, wraparound, boundscheck, has_gil, unsafe_shared)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, unsafe_shared) :\ + (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, int unsafe_shared); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, wraparound, boundscheck, has_gil, unsafe_shared)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, unsafe_shared) :\ + (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, int unsafe_shared); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck, int unsafe_shared); + +/* PyObjectCompare.proto */ +static CYTHON_INLINE int __Pyx_PyObject_CompareBoolGt_object_int(PyObject *op1, PyObject *op2, int pyop); + +/* PyObjectCompare.proto */ +static CYTHON_INLINE int __Pyx_PyObject_CompareBoolLt_object_int(PyObject *op1, PyObject *op2, int pyop); + +/* pyfrozenset_new.proto (used by PySetContains) */ +static PyObject* __Pyx_PyFrozenSet_New(PyObject* it); + +/* PySetContains.proto */ +static CYTHON_INLINE int __Pyx_PySet_ContainsTF(PyObject* key, PyObject* set, int eq); + +/* PyObjectFormatSimple.proto */ +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#elif CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\ + likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\ + PyObject_Format(s, f)) +#else + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#endif + +/* CBIntToPyUnicode.proto */ +#define __Pyx_PyUnicode_FromBInt_bint(value)\ + ((value) ? __Pyx_NewRef(__pyx_mstate_global->__pyx_n_u_True) : __Pyx_NewRef(__pyx_mstate_global->__pyx_n_u_False)) + +/* PyObjectFormatAndDecref.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f); +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f); + +/* JoinPyUnicode.proto */ +#define __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH\ + (!CYTHON_COMPILING_IN_GRAAL && !CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) + +/* JoinPyUnicode.export */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, int kind); + +/* CIntToPyUnicode.proto */ +#define __Pyx_PyUnicode_From_long(value, width, padding_char, format_char) (\ + ((format_char) == ('c')) ?\ + __Pyx_uchar___Pyx_PyUnicode_From_long(value, width, padding_char) :\ + __Pyx____Pyx_PyUnicode_From_long(value, width, padding_char, format_char)\ + ) +static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_long(long value, Py_ssize_t width, char padding_char); +static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_long(long value, Py_ssize_t width, char padding_char, char format_char); + +/* PyNumberBinop.proto */ +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_PyNumber_Add_int_int(op1, op2) PyNumber_Add(op1, op2) +#define __Pyx_PyNumber_InPlaceAdd_int_int(op1, op2) PyNumber_InPlaceAdd(op1, op2) +#else +#define __Pyx_PyNumber_Add_int_int(op1, op2) __Pyx__PyNumber_Add_int_int(op1, op2, 0) +#define __Pyx_PyNumber_InPlaceAdd_int_int(op1, op2) __Pyx__PyNumber_Add_int_int(op1, op2, 1) +static CYTHON_INLINE PyObject* __Pyx__PyNumber_Add_int_int(PyObject *op1, PyObject *op2, int inplace); +#endif + +/* CIntToPyUnicode.proto */ +#define __Pyx_PyUnicode_From_unsigned_PY_LONG_LONG(value, width, padding_char, format_char) (\ + ((format_char) == ('c')) ?\ + __Pyx_uchar___Pyx_PyUnicode_From_unsigned_PY_LONG_LONG(value, width, padding_char) :\ + __Pyx____Pyx_PyUnicode_From_unsigned_PY_LONG_LONG(value, width, padding_char, format_char)\ + ) +static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_unsigned_PY_LONG_LONG(unsigned PY_LONG_LONG value, Py_ssize_t width, char padding_char); +static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_unsigned_PY_LONG_LONG(unsigned PY_LONG_LONG value, Py_ssize_t width, char padding_char, char format_char); + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x); +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* StringJoin.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values); + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* AllocateExtensionType.proto */ +static PyObject *__Pyx_AllocateExtensionType(PyTypeObject *t, int is_final); + +/* CallSlotAsVectorcall.proto */ +#if CYTHON_VECTORCALL_TPNEW +typedef PyObject * (*__Pyx_tpnewvectorcallfunc)(PyTypeObject* o, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); +static PyObject * __Pyx_CallTpnewAsVectorcall(__Pyx_tpnewvectorcallfunc f, PyTypeObject* o, PyObject *a, PyObject *k); +#endif + +/* CallNewInitFromVectorcall.proto */ +#if CYTHON_VECTORCALL_TPNEW +static PyObject *__Pyx_CallNewInitFromVectorcall(PyTypeObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#endif + +/* CallSlotAsVectorcall.proto */ +#if CYTHON_VECTORCALL_TPNEW +typedef int (*__Pyx_tpinitvectorcallfunc)(PyObject* o, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); +static int __Pyx_CallTpinitAsVectorcall(__Pyx_tpinitvectorcallfunc f, PyObject* o, PyObject *a, PyObject *k); +#endif + +/* CheckTypeForFreelists.proto */ +#if CYTHON_USE_FREELISTS +#if CYTHON_USE_TYPE_SPECS +#define __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, expected_tp, expected_size) ((int) ((t) == (expected_tp))) +#define __PYX_CHECK_TYPE_FOR_FREELIST_FLAGS Py_TPFLAGS_IS_ABSTRACT +#else +#define __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, expected_tp, expected_size) ((int) ((t)->tp_basicsize == (expected_size))) +#define __PYX_CHECK_TYPE_FOR_FREELIST_FLAGS (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE) +#endif +#define __PYX_CHECK_TYPE_FOR_FREELISTS(t, expected_tp, expected_size)\ + (__PYX_CHECK_FINAL_TYPE_FOR_FREELISTS((t), (expected_tp), (expected_size)) &\ + (int) (!__Pyx_PyType_HasFeature((t), __PYX_CHECK_TYPE_FOR_FREELIST_FLAGS))) +#endif + +/* VoidPtrExport.proto */ +static int __Pyx_ExportVoidPtr(PyObject *api_dict, const char *name, void *p, const char *sig); + +/* GetApiDict.proto */ +static PyObject *__Pyx_ApiExport_GetApiDict(void); + +/* PyObjectCallMethod0.proto (used by PyType_Ready) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* GetTypeDictOffset.proto (used by ValidateBasesTuple) */ +#if !CYTHON_USE_TYPE_SLOTS +CYTHON_UNUSED static Py_ssize_t __Pyx_GetTypeDictOffset(PyObject *tp, int require_cython_valid_result); +#endif + +/* ValidateBasesTuple.proto (used by PyType_Ready) */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, int has_dictoffset, PyObject *bases); +#endif + +/* PyType_Ready.export */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); + +/* GetVTable.proto (used by MergeVTables) */ +static int __Pyx_GetVtable(PyTypeObject *type, void** table); + +/* MergeVTables.proto (used by SetVTable) */ +static int __Pyx_MergeVtables(PyTypeObject *type); + +/* SetVTable.export */ +static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); + +/* LimitedApiGetTypeTypeDict.proto (used by DelItemOnTypeDict) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_GetTypeTypeDict(PyTypeObject *tp); +#endif + +/* DelItemOnTypeDict.proto (used by SetupReduce) */ +#define __Pyx_DelItemOnTypeDict(tp, k) __Pyx__DelItemOnTypeDict((PyTypeObject*)tp, k) + +/* DelItemOnTypeDict.export */ +static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k); + +/* SetItemOnTypeDict.proto (used by SetupReduce) */ +#define __Pyx_SetItemOnTypeDict(tp, k, v) __Pyx__SetItemOnTypeDict((PyTypeObject*)tp, k, v) + +/* SetItemOnTypeDict.export */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v); + +/* SetupReduce.export */ +static int __Pyx_setup_reduce(PyObject* type_obj); + +/* FunctionImport.proto */ +static int __Pyx_ImportFunction_3_3_0(PyObject *module, const char *funcname, void (**f)(void), const char *sig); + +/* HasAttr.proto (used by ImportImpl) */ +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) +#else +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); +#endif + +/* TupleOrListFromArrayImpl.proto (used by ListFromArray) */ +CYTHON_UNUSED static PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); + +/* ListFromArray.proto (used by ImportImpl) */ + + +/* ImportImpl.export */ +static PyObject *__Pyx__Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, PyObject *moddict, int level); + +/* Import.proto */ +static CYTHON_INLINE PyObject *__Pyx_Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, int level); + +/* ImportFrom.export */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* CythonFunctionPerModule.proto (used by CythonFunctionShared) */ +#define __Pyx_CyFunction_USED +#if CYTHON_OPAQUE_SHARED_TYPES +#define __Pyx_as_CyFunctionObject(o) ((__pyx_CyFunctionObject *)PyObject_GetTypeData((o), __pyx_mstate_global->__pyx_CyFunctionType)) +#else +#define __Pyx_as_CyFunctionObject(o) ((__pyx_CyFunctionObject *)o) +#endif +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + ((__Pyx_as_CyFunctionObject(f))->func_closure) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx__CyFunction_GetClassObj(f)\ + ((f)->func_classobj) +#else + #define __Pyx__CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_GetClassObj(f)\ + __Pyx__CyFunction_GetClassObj(__Pyx_as_CyFunctionObject(f)) +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj(__Pyx_as_CyFunctionObject(f), (classobj)) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)((__Pyx_as_CyFunctionObject(f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + (__Pyx_as_CyFunctionObject(f))->defaults_getter = (g) +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API +#if !CYTHON_OPAQUE_OBJECTS + PyObject_HEAD +#endif + PyMethodDef *func_methoddef; + PyObject *func_module; +#else + PyCMethodObject func; +#endif +#if (CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY) && CYTHON_VECTORCALL + __pyx_vectorcallfunc func_vectorcall; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_weakreflist; +#endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_dict; +#endif + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + PyObject *defaults; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; +#if __PYX_LIMITED_VERSION_HEX < 0x030B0000 + PyObject *func_is_coroutine; +#endif +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_mstate_global->__pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_mstate_global->__pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) Py_IS_TYPE(obj, __pyx_mstate_global->__pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, + PyTypeObject *defaults_type); +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(PyObject *module); +#if CYTHON_VECTORCALL +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY +#define __Pyx_CyFunction_func_vectorcall(f) ((f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif +#endif + +/* PyMethodNew.proto (used by CythonFunctionShared) */ +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ); + +/* PyVectorcallFastCallDict.proto (used by CythonFunctionShared) */ +#if CYTHON_VECTORCALL +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto (used by CythonFunction) */ +static PyObject *__Pyx_CyFunction_Init(PyObject *op_in, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +#if CYTHON_VECTORCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#endif + +/* CythonFunction.export */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static PyTypeObject *__Pyx_Get_CyFunction_Type(void); + +/* CLineInTraceback.proto (used by AddTraceback) */ +#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#else +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#endif + +/* CodeObjectCache.proto (used by AddTraceback) */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject __Pyx_CachedCodeObjectType; +#else +typedef PyCodeObject __Pyx_CachedCodeObjectType; +#endif +typedef struct { + __Pyx_CachedCodeObjectType* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_int_type accessor_count; + #endif +}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* CheckUnpickleChecksumError.export */ +static void __Pyx_RaiseUnpickleChecksumError(long checksum, long checksum1, long checksum2, long checksum3, const char *members); + +/* PyObjectVectorcallMethodKwds.proto (used by CIntToPy) */ +#if CYTHON_VECTORCALL +#define __Pyx_Object_VectorcallMethodKwds PyObject_VectorcallMethod +#else +static PyObject *__Pyx_Object_VectorcallMethodKwds(PyObject *name, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#endif + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_unsigned_int(unsigned int value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE unsigned int __Pyx_PyLong_As_unsigned_int(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE unsigned PY_LONG_LONG __Pyx_PyLong_As_unsigned_PY_LONG_LONG(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value); + +/* UpdateUnpickledDict.export */ +static int __Pyx_UpdateUnpickledDict(PyObject *obj, PyObject *state, Py_ssize_t index); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_unsigned_PY_LONG_LONG(unsigned PY_LONG_LONG value); + +/* CheckUnpickleChecksum.proto */ +static CYTHON_INLINE int __Pyx_CheckUnpickleChecksum(long checksum, long checksum1, long checksum2, long checksum3, const char *members); + +/* GetRuntimeVersion.proto */ +#if __PYX_LIMITED_VERSION_HEX < 0x030b0000 +static unsigned long __Pyx_cached_runtime_version = 0; +static void __Pyx_init_runtime_version(void); +#else +#define __Pyx_init_runtime_version() +#endif +static unsigned long __Pyx_get_runtime_version(void); + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); + +/* DecompressString.proto */ +static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo); + +/* DecompressString_LZSS.proto */ +static PyObject *__Pyx_DecompressString_LZSS(const char *s, size_t compressed_length, size_t uncompressed_length); + +/* MultiPhaseInitModuleState.proto */ +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +#include +static PyObject *__Pyx_State_FindModule(void*); +static int __Pyx_State_AddModule(PyObject* module, void*); +static int __Pyx_State_RemoveModule(void*); +#elif CYTHON_USE_MODULE_STATE +#define __Pyx_State_FindModule PyState_FindModule +#define __Pyx_State_AddModule PyState_AddModule +#define __Pyx_State_RemoveModule PyState_RemoveModule +#endif + +/* #### Code section: module_declarations ### */ +/* CythonABIVersion.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API + #if CYTHON_VECTORCALL + #define __PYX_VECTORCALL_ABI_SUFFIX "_vectorcall" + #else + #define __PYX_VECTORCALL_ABI_SUFFIX + #endif + #define __PYX_LIMITED_ABI_SUFFIX "limited" __PYX_VECTORCALL_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#else + #define __PYX_LIMITED_ABI_SUFFIX +#endif +#if __PYX_HAS_PY_AM_SEND == 1 + #define __PYX_AM_SEND_ABI_SUFFIX +#elif __PYX_HAS_PY_AM_SEND == 2 + #define __PYX_AM_SEND_ABI_SUFFIX "amsendbackport" +#else + #define __PYX_AM_SEND_ABI_SUFFIX "noamsend" +#endif +#ifndef __PYX_MONITORING_ABI_SUFFIX + #define __PYX_MONITORING_ABI_SUFFIX +#endif +#if CYTHON_USE_TP_FINALIZE + #define __PYX_TP_FINALIZE_ABI_SUFFIX +#else + #define __PYX_TP_FINALIZE_ABI_SUFFIX "nofinalize" +#endif +#if CYTHON_USE_FREELISTS || !defined(__Pyx_AsyncGen_USED) + #define __PYX_FREELISTS_ABI_SUFFIX +#else + #define __PYX_FREELISTS_ABI_SUFFIX "nofreelists" +#endif +#if CYTHON_OPAQUE_OBJECTS && CYTHON_COMPILING_IN_LIMITED_API + #define __PYX_OPAQUE_OBJECTS_ABI_SUFFIX "opaque" +#else + #define __PYX_OPAQUE_OBJECTS_ABI_SUFFIX +#endif +#define CYTHON_ABI __PYX_ABI_VERSION __PYX_LIMITED_ABI_SUFFIX __PYX_MONITORING_ABI_SUFFIX __PYX_TP_FINALIZE_ABI_SUFFIX __PYX_FREELISTS_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX __PYX_OPAQUE_OBJECTS_ABI_SUFFIX +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." + +static void __pyx_f_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__release_waiter(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self); /* proto*/ +static void __pyx_f_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_feed_data(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self, PyObject *__pyx_v_data, int __pyx_skip_dispatch); /* proto*/ +static PyObject *__pyx_f_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__read_from_buffer(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_7aiohttp_10_websocket_8reader_c_15WebSocketReader_feed_data(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self, PyObject *__pyx_v_data, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_7aiohttp_10_websocket_8reader_c_15WebSocketReader__handle_frame(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self, int __pyx_v_fin, int __pyx_v_opcode, PyObject *__pyx_v_payload, int __pyx_v_compressed, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_7aiohttp_10_websocket_8reader_c_15WebSocketReader__feed_data(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self, PyObject *__pyx_v_data, int __pyx_skip_dispatch); /* proto*/ + +/* Module declarations from "cython" */ + +/* Module declarations from "aiohttp._websocket.mask" */ +static void (*__pyx_f_7aiohttp_10_websocket_4mask__websocket_mask_cython)(PyObject *, PyObject *, int __pyx_skip_dispatch); /*proto*/ + +/* Module declarations from "aiohttp._websocket.reader_c" */ +static unsigned int __pyx_v_7aiohttp_10_websocket_8reader_c_READ_HEADER; +static unsigned int __pyx_v_7aiohttp_10_websocket_8reader_c_READ_PAYLOAD_LENGTH; +static unsigned int __pyx_v_7aiohttp_10_websocket_8reader_c_READ_PAYLOAD_MASK; +static unsigned int __pyx_v_7aiohttp_10_websocket_8reader_c_READ_PAYLOAD; +static unsigned PY_LONG_LONG __pyx_v_7aiohttp_10_websocket_8reader_c_MAX_PAYLOAD_LEN; +static int __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_NOT_SET; +static int __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_CONTINUATION; +static int __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_TEXT; +static int __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_BINARY; +static int __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_CLOSE; +static int __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_PING; +static int __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_PONG; +static int __pyx_v_7aiohttp_10_websocket_8reader_c_COMPRESSED_NOT_SET; +static int __pyx_v_7aiohttp_10_websocket_8reader_c_COMPRESSED_FALSE; +static int __pyx_v_7aiohttp_10_websocket_8reader_c_COMPRESSED_TRUE; +static PyObject *__pyx_v_7aiohttp_10_websocket_8reader_c_UNPACK_LEN3 = 0; +static PyObject *__pyx_v_7aiohttp_10_websocket_8reader_c_UNPACK_CLOSE_CODE = 0; +static PyObject *__pyx_v_7aiohttp_10_websocket_8reader_c_TUPLE_NEW = 0; +static PyObject *__pyx_v_7aiohttp_10_websocket_8reader_c_WSMsgType = 0; +static PyObject *__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageText = 0; +static PyObject *__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageTextBytes = 0; +static PyObject *__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageBinary = 0; +static PyObject *__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessagePing = 0; +static PyObject *__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessagePong = 0; +static PyObject *__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageClose = 0; +static PyObject *__pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_TEXT = 0; +static PyObject *__pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_BINARY = 0; +static PyObject *__pyx_v_7aiohttp_10_websocket_8reader_c_ALLOWED_CLOSE_CODES = 0; +static PyObject *__pyx_v_7aiohttp_10_websocket_8reader_c_MESSAGE_TYPES_WITH_CONTENT = 0; +static PyObject *__pyx_v_7aiohttp_10_websocket_8reader_c_EMPTY_FRAME = 0; +static PyObject *__pyx_v_7aiohttp_10_websocket_8reader_c_EMPTY_FRAME_ERROR = 0; +static unsigned int __pyx_v_7aiohttp_10_websocket_8reader_c_MSG_SIZE_OVERHEAD; +static PyObject *__pyx_7genexpr__pyx_v_7aiohttp_10_websocket_8reader_c_i; +static PyObject *__pyx_f_7aiohttp_10_websocket_8reader_c___pyx_unpickle_WebSocketDataQueue__set_state(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *, PyObject *); /*proto*/ +static PyObject *__pyx_f_7aiohttp_10_websocket_8reader_c___pyx_unpickle_WebSocketReader__set_state(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *, PyObject *); /*proto*/ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ +#define __Pyx_MODULE_NAME "aiohttp._websocket.reader_c" +extern int __pyx_module_is_main_aiohttp___websocket__reader_c; +int __pyx_module_is_main_aiohttp___websocket__reader_c = 0; + +/* Implementation of "aiohttp._websocket.reader_c" */ +/* #### Code section: global_var ### */ +/* #### Code section: string_decls ### */ +static const char __pyx_k_buffer__eof__exception__get_buf[] = "_buffer, _eof, _exception, _get_buffer, _limit, _loop, _protocol, _put_buffer, _size, _stalled_reader, _waiter"; +static const char __pyx_k_compress__compressed__decode_te[] = "_compress, _compressed, _decode_text, _decompressobj, _exc, _frame_fin, _frame_mask, _frame_opcode, _frame_payload_len, _has_mask, _max_fragments, _max_msg_size, _opcode, _partial, _payload_bytes_to_read, _payload_fragments, _payload_len_flag, _state, _tail, _weak_self, queue"; +static const char __pyx_k_Reader_for_WebSocket_protocol_ve[] = "Reader for WebSocket protocol versions 13 and 8."; +/* #### Code section: decls ### */ +static int __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue___init__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self, PyObject *__pyx_v_protocol, PyObject *__pyx_v_limit, PyObject *__pyx_v_loop); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_2is_eof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_4exception(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_6set_exception(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self, PyObject *__pyx_v_exc, PyObject *__pyx_v_exc_cause); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_8feed_eof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_10feed_data(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self, PyObject *__pyx_v_data); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_12read(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_5_size___get__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol___get__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self); /* proto */ +static int __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol_2__set__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol_4__del__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_6_limit___get__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer___get__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self); /* proto */ +static int __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer_2__set__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer_4__del__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_15_stalled_reader___get__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_15__reduce_cython__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_17__setstate_cython__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader___init__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self, struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_queue, PyObject *__pyx_v_max_msg_size, int __pyx_v_compress, int __pyx_v_decode_text); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_2feed_eof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_4feed_data(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self, PyObject *__pyx_v_data); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_6_handle_frame(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self, int __pyx_v_fin, int __pyx_v_opcode, PyObject *__pyx_v_payload, int __pyx_v_compressed); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_8_feed_data(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self, PyObject *__pyx_v_data); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_10__reduce_cython__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_12__setstate_cython__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c___pyx_unpickle_WebSocketDataQueue(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_2__pyx_unpickle_WebSocketReader(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_tp_new__initialisation_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(PyObject *o, +#if CYTHON_VECTORCALL_TPNEW + PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames +#else + PyObject *a, PyObject *k +#endif +); /*proto*/ +static PyObject *__pyx_tp_new_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(PyTypeObject *t, +#if CYTHON_VECTORCALL_TPNEW + PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames +#else + PyObject *a, PyObject *k +#endif +); /*proto*/ +#if CYTHON_VECTORCALL_TPNEW +static PyObject *__pyx_tp_new_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +#endif +#if !CYTHON_VECTORCALL_TPNEW +#define __pyx_tp_new_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue __pyx_tp_new_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue +#endif +#if CYTHON_VECTORCALL_TPNEW +static PyObject *__pyx_tp_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(PyObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames); /*proto*/ +#endif +#if CYTHON_VECTORCALL_TPNEW +static int __pyx_tp_init_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(PyObject *o, PyObject *args, PyObject *kwds); /*proto*/ +#endif +#if !CYTHON_VECTORCALL_TPNEW +#define __pyx_tp_init_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_1__init__ +#endif +static PyObject *__pyx_tp_new__initialisation_7aiohttp_10_websocket_8reader_c_WebSocketReader(PyObject *o, +#if CYTHON_VECTORCALL_TPNEW + PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames +#else + PyObject *a, PyObject *k +#endif +); /*proto*/ +static PyObject *__pyx_tp_new_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketReader(PyTypeObject *t, +#if CYTHON_VECTORCALL_TPNEW + PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames +#else + PyObject *a, PyObject *k +#endif +); /*proto*/ +#if CYTHON_VECTORCALL_TPNEW +static PyObject *__pyx_tp_new_7aiohttp_10_websocket_8reader_c_WebSocketReader(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +#endif +#if !CYTHON_VECTORCALL_TPNEW +#define __pyx_tp_new_7aiohttp_10_websocket_8reader_c_WebSocketReader __pyx_tp_new_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketReader +#endif +#if CYTHON_VECTORCALL_TPNEW +static PyObject *__pyx_tp_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketReader(PyObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames); /*proto*/ +#endif +#if CYTHON_VECTORCALL_TPNEW +static int __pyx_tp_init_7aiohttp_10_websocket_8reader_c_WebSocketReader(PyObject *o, PyObject *args, PyObject *kwds); /*proto*/ +#endif +#if !CYTHON_VECTORCALL_TPNEW +#define __pyx_tp_init_7aiohttp_10_websocket_8reader_c_WebSocketReader __pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_1__init__ +#endif +static PyObject *__pyx_tp_new__initialisation_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read(PyObject *o, +#if CYTHON_VECTORCALL_TPNEW + PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames +#else + PyObject *a, PyObject *k +#endif +); /*proto*/ +static PyObject *__pyx_tp_new_vectorcall_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read(PyTypeObject *t, +#if CYTHON_VECTORCALL_TPNEW + PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames +#else + PyObject *a, PyObject *k +#endif +); /*proto*/ +#if CYTHON_VECTORCALL_TPNEW +static PyObject *__pyx_tp_new_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +#endif +#if !CYTHON_VECTORCALL_TPNEW +#define __pyx_tp_new_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read __pyx_tp_new_vectorcall_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read +#endif +#if CYTHON_VECTORCALL_TPNEW +static PyObject *__pyx_tp_vectorcall_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read(PyObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames); /*proto*/ +#endif +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +/* SmallCodeConfig */ +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +#ifdef __cplusplus +namespace { + #endif + typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + PyObject *__pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue; + PyObject *__pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketReader; + PyObject *__pyx_type_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read; + PyTypeObject *__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue; + PyTypeObject *__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader; + PyTypeObject *__pyx_ptype_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_items; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_values; + PyObject *__pyx_k__2; + PyObject *__pyx_slice[2]; + PyObject *__pyx_tuple[4]; + PyObject *__pyx_codeobj_tab[16]; + PyObject *__pyx_string_tab[213]; + PyObject *__pyx_number_tab[7]; +/* #### Code section: module_state_contents ### */ +/* CommonTypesMetaclass.module_state_decls */ +PyTypeObject *__pyx_CommonTypesMetaclassType; + +/* IterNextPlain.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +PyObject *__Pyx_GetBuiltinNext_LimitedAPI_cache; +#endif + +/* Coroutine.module_state_decls */ +PyTypeObject *__pyx_CoroutineType; +PyTypeObject *__pyx_CoroutineAwaitType; + +/* Coro_CheckExact.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API +PyObject *__Pyx_CachedCoroType; +#endif + +/* PyFrozenDict.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API +PyObject *__Pyx_PyFrozenDictType; +#endif + + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read *__pyx_freelist_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read[8]; +int __pyx_freecount_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read; +#endif +/* CachedMethodType.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API +PyObject *__Pyx_CachedMethodType; +#endif + +/* CythonFunctionPerModule.module_state_decls */ +PyTypeObject *__pyx_CyFunctionType; + +/* CodeObjectCache.module_state_decls */ +struct __Pyx_CodeObjectCache __pyx_code_cache; + +/* #### Code section: module_state_end ### */ +} __pyx_mstatetype; +#ifdef __cplusplus +} /* anonymous namespace */ +#endif + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { +extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate_global (__Pyx_PyModule_GetState(__Pyx_State_FindModule(&__pyx_moduledef))) + +#define __pyx_m (__Pyx_State_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstatetype __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstatetype * const __pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: constant_name_defines ### */ +#define __pyx_kp_u__3 __pyx_string_tab[0] +#define __pyx_kp_u__4 __pyx_string_tab[1] +#define __pyx_kp_u_exceeds_limit __pyx_string_tab[2] +#define __pyx_kp_u_WSMessage_2 __pyx_string_tab[3] +#define __pyx_kp_u_tree_fragment __pyx_string_tab[4] +#define __pyx_kp_u__5 __pyx_string_tab[5] +#define __pyx_kp_u_ __pyx_string_tab[6] +#define __pyx_kp_u_Compressed_message_has_too_many __pyx_string_tab[7] +#define __pyx_kp_u_Continuation_frame_for_non_start __pyx_string_tab[8] +#define __pyx_kp_u_Control_frame_payload_cannot_be __pyx_string_tab[9] +#define __pyx_kp_u_Decompressed_message_exceeds_siz __pyx_string_tab[10] +#define __pyx_kp_u_Invalid_UTF_8_text_message __pyx_string_tab[11] +#define __pyx_kp_u_Invalid_close_code __pyx_string_tab[12] +#define __pyx_kp_u_Invalid_close_frame __pyx_string_tab[13] +#define __pyx_kp_u_Message_size __pyx_string_tab[14] +#define __pyx_kp_u_Note_that_Cython_is_deliberately __pyx_string_tab[15] +#define __pyx_kp_u_Received_fragmented_control_fram __pyx_string_tab[16] +#define __pyx_kp_u_Received_frame_with_non_zero_res __pyx_string_tab[17] +#define __pyx_kp_u_The_opcode_in_non_fin_frame_is_e __pyx_string_tab[18] +#define __pyx_kp_u_Unexpected_opcode __pyx_string_tab[19] +#define __pyx_kp_u_WebSocketReader_was_garbage_coll __pyx_string_tab[20] +#define __pyx_kp_u_add_note __pyx_string_tab[21] +#define __pyx_kp_u_aiohttp__websocket_helpers __pyx_string_tab[22] +#define __pyx_kp_u_aiohttp__websocket_models __pyx_string_tab[23] +#define __pyx_kp_u_aiohttp_base_protocol __pyx_string_tab[24] +#define __pyx_kp_u_aiohttp_compression_utils __pyx_string_tab[25] +#define __pyx_kp_u_aiohttp_helpers __pyx_string_tab[26] +#define __pyx_kp_u_aiohttp_log __pyx_string_tab[27] +#define __pyx_kp_u_aiohttp_streams __pyx_string_tab[28] +#define __pyx_kp_u_aiohttp__websocket_reader_py_py __pyx_string_tab[29] +#define __pyx_kp_u_builtins_BaseException __pyx_string_tab[30] +#define __pyx_kp_u_bytes_bytearray __pyx_string_tab[31] +#define __pyx_kp_u_bytes_bytearray_memoryview __pyx_string_tab[32] +#define __pyx_kp_u_disable __pyx_string_tab[33] +#define __pyx_kp_u_enable __pyx_string_tab[34] +#define __pyx_kp_u_gc __pyx_string_tab[35] +#define __pyx_kp_u_int_cython_int __pyx_string_tab[36] +#define __pyx_kp_u_isenabled __pyx_string_tab[37] +#define __pyx_kp_u_type_BaseException_BaseException_2 __pyx_string_tab[38] +#define __pyx_kp_u_type_BaseException_BaseException __pyx_string_tab[39] +#define __pyx_kp_u_utf_8 __pyx_string_tab[40] +#define __pyx_n_u_ABNORMAL_CLOSURE __pyx_string_tab[41] +#define __pyx_n_u_BINARY __pyx_string_tab[42] +#define __pyx_n_u_BaseProtocol __pyx_string_tab[43] +#define __pyx_n_u_CLOSE __pyx_string_tab[44] +#define __pyx_n_u_CONTINUATION __pyx_string_tab[45] +#define __pyx_n_u_CancelledError __pyx_string_tab[46] +#define __pyx_n_u_EofStream __pyx_string_tab[47] +#define __pyx_n_u_False __pyx_string_tab[48] +#define __pyx_n_u_INVALID_TEXT __pyx_string_tab[49] +#define __pyx_n_u_MESSAGE_TOO_BIG __pyx_string_tab[50] +#define __pyx_n_u_None __pyx_string_tab[51] +#define __pyx_n_u_PING __pyx_string_tab[52] +#define __pyx_n_u_PONG __pyx_string_tab[53] +#define __pyx_n_u_PROTOCOL_ERROR __pyx_string_tab[54] +#define __pyx_n_u_STALLED_READER_COLLECTED __pyx_string_tab[55] +#define __pyx_n_u_TEXT __pyx_string_tab[56] +#define __pyx_n_u_TimeoutError __pyx_string_tab[57] +#define __pyx_n_u_TooManyMembersError __pyx_string_tab[58] +#define __pyx_n_u_True __pyx_string_tab[59] +#define __pyx_n_u_UNPACK_CLOSE_CODE __pyx_string_tab[60] +#define __pyx_n_u_UNPACK_LEN3 __pyx_string_tab[61] +#define __pyx_n_u_WSCloseCode __pyx_string_tab[62] +#define __pyx_n_u_WSMessage __pyx_string_tab[63] +#define __pyx_n_u_WSMessageBinary __pyx_string_tab[64] +#define __pyx_n_u_WSMessageClose __pyx_string_tab[65] +#define __pyx_n_u_WSMessagePing __pyx_string_tab[66] +#define __pyx_n_u_WSMessagePong __pyx_string_tab[67] +#define __pyx_n_u_WSMessageText __pyx_string_tab[68] +#define __pyx_n_u_WSMessageTextBytes __pyx_string_tab[69] +#define __pyx_n_u_WSMsgType __pyx_string_tab[70] +#define __pyx_n_u_WS_DEFLATE_TRAILING __pyx_string_tab[71] +#define __pyx_n_u_WebSocketDataQueue __pyx_string_tab[72] +#define __pyx_n_u_WebSocketDataQueue___reduce_cyth __pyx_string_tab[73] +#define __pyx_n_u_WebSocketDataQueue___setstate_cy __pyx_string_tab[74] +#define __pyx_n_u_WebSocketDataQueue_exception __pyx_string_tab[75] +#define __pyx_n_u_WebSocketDataQueue_feed_data __pyx_string_tab[76] +#define __pyx_n_u_WebSocketDataQueue_feed_eof __pyx_string_tab[77] +#define __pyx_n_u_WebSocketDataQueue_is_eof __pyx_string_tab[78] +#define __pyx_n_u_WebSocketDataQueue_read __pyx_string_tab[79] +#define __pyx_n_u_WebSocketDataQueue_set_exception __pyx_string_tab[80] +#define __pyx_n_u_WebSocketError __pyx_string_tab[81] +#define __pyx_n_u_WebSocketReader __pyx_string_tab[82] +#define __pyx_n_u_WebSocketReader___reduce_cython __pyx_string_tab[83] +#define __pyx_n_u_WebSocketReader___setstate_cytho __pyx_string_tab[84] +#define __pyx_n_u_WebSocketReader__feed_data __pyx_string_tab[85] +#define __pyx_n_u_WebSocketReader__handle_frame __pyx_string_tab[86] +#define __pyx_n_u_WebSocketReader_feed_data __pyx_string_tab[87] +#define __pyx_n_u_WebSocketReader_feed_eof __pyx_string_tab[88] +#define __pyx_n_u_ZLibDecompressor __pyx_string_tab[89] +#define __pyx_n_u_EXC_SENTINEL __pyx_string_tab[90] +#define __pyx_n_u_Pyx_PyDict_NextRef __pyx_string_tab[91] +#define __pyx_n_u_annotate __pyx_string_tab[92] +#define __pyx_n_u_await __pyx_string_tab[93] +#define __pyx_n_u_dict __pyx_string_tab[94] +#define __pyx_n_u_func __pyx_string_tab[95] +#define __pyx_n_u_getstate __pyx_string_tab[96] +#define __pyx_n_u_main __pyx_string_tab[97] +#define __pyx_n_u_module __pyx_string_tab[98] +#define __pyx_n_u_name __pyx_string_tab[99] +#define __pyx_n_u_new __pyx_string_tab[100] +#define __pyx_n_u_pyx_capi __pyx_string_tab[101] +#define __pyx_n_u_pyx_checksum __pyx_string_tab[102] +#define __pyx_n_u_pyx_result __pyx_string_tab[103] +#define __pyx_n_u_pyx_state __pyx_string_tab[104] +#define __pyx_n_u_pyx_type __pyx_string_tab[105] +#define __pyx_n_u_pyx_unpickle_WebSocketDataQueu __pyx_string_tab[106] +#define __pyx_n_u_pyx_unpickle_WebSocketReader __pyx_string_tab[107] +#define __pyx_n_u_pyx_vtable __pyx_string_tab[108] +#define __pyx_n_u_qualname __pyx_string_tab[109] +#define __pyx_n_u_reduce __pyx_string_tab[110] +#define __pyx_n_u_reduce_cython __pyx_string_tab[111] +#define __pyx_n_u_reduce_ex __pyx_string_tab[112] +#define __pyx_n_u_set_name __pyx_string_tab[113] +#define __pyx_n_u_setstate __pyx_string_tab[114] +#define __pyx_n_u_setstate_cython __pyx_string_tab[115] +#define __pyx_n_u_test __pyx_string_tab[116] +#define __pyx_n_u_dict_2 __pyx_string_tab[117] +#define __pyx_n_u_feed_data_2 __pyx_string_tab[118] +#define __pyx_n_u_handle_frame __pyx_string_tab[119] +#define __pyx_n_u_is_coroutine __pyx_string_tab[120] +#define __pyx_n_u_reading_paused __pyx_string_tab[121] +#define __pyx_n_u_aiohttp__websocket_reader_c __pyx_string_tab[122] +#define __pyx_n_u_append __pyx_string_tab[123] +#define __pyx_n_u_asyncio __pyx_string_tab[124] +#define __pyx_n_u_asyncio_coroutines __pyx_string_tab[125] +#define __pyx_n_u_base_protocol __pyx_string_tab[126] +#define __pyx_n_u_bool __pyx_string_tab[127] +#define __pyx_n_u_builtins __pyx_string_tab[128] +#define __pyx_n_u_bytes __pyx_string_tab[129] +#define __pyx_n_u_clear __pyx_string_tab[130] +#define __pyx_n_u_cline_in_traceback __pyx_string_tab[131] +#define __pyx_n_u_close __pyx_string_tab[132] +#define __pyx_n_u_collections __pyx_string_tab[133] +#define __pyx_n_u_compress __pyx_string_tab[134] +#define __pyx_n_u_compressed __pyx_string_tab[135] +#define __pyx_n_u_compression_utils __pyx_string_tab[136] +#define __pyx_n_u_create_future __pyx_string_tab[137] +#define __pyx_n_u_cython_int __pyx_string_tab[138] +#define __pyx_n_u_data __pyx_string_tab[139] +#define __pyx_n_u_decode __pyx_string_tab[140] +#define __pyx_n_u_decode_text __pyx_string_tab[141] +#define __pyx_n_u_decompress_sync __pyx_string_tab[142] +#define __pyx_n_u_deque __pyx_string_tab[143] +#define __pyx_n_u_done __pyx_string_tab[144] +#define __pyx_n_u_exc __pyx_string_tab[145] +#define __pyx_n_u_exc_cause __pyx_string_tab[146] +#define __pyx_n_u_exception __pyx_string_tab[147] +#define __pyx_n_u_extra __pyx_string_tab[148] +#define __pyx_n_u_feed_data __pyx_string_tab[149] +#define __pyx_n_u_feed_eof __pyx_string_tab[150] +#define __pyx_n_u_fin __pyx_string_tab[151] +#define __pyx_n_u_helpers __pyx_string_tab[152] +#define __pyx_n_u_is_eof __pyx_string_tab[153] +#define __pyx_n_u_items __pyx_string_tab[154] +#define __pyx_n_u_join __pyx_string_tab[155] +#define __pyx_n_u_limit __pyx_string_tab[156] +#define __pyx_n_u_log __pyx_string_tab[157] +#define __pyx_n_u_loop __pyx_string_tab[158] +#define __pyx_n_u_max_msg_size __pyx_string_tab[159] +#define __pyx_n_u_maxsize __pyx_string_tab[160] +#define __pyx_n_u_models __pyx_string_tab[161] +#define __pyx_n_u_next __pyx_string_tab[162] +#define __pyx_n_u_opcode __pyx_string_tab[163] +#define __pyx_n_u_pause_reading __pyx_string_tab[164] +#define __pyx_n_u_payload __pyx_string_tab[165] +#define __pyx_n_u_pop __pyx_string_tab[166] +#define __pyx_n_u_popleft __pyx_string_tab[167] +#define __pyx_n_u_protocol __pyx_string_tab[168] +#define __pyx_n_u_queue __pyx_string_tab[169] +#define __pyx_n_u_read __pyx_string_tab[170] +#define __pyx_n_u_ref __pyx_string_tab[171] +#define __pyx_n_u_resume_reading __pyx_string_tab[172] +#define __pyx_n_u_return __pyx_string_tab[173] +#define __pyx_n_u_self __pyx_string_tab[174] +#define __pyx_n_u_send __pyx_string_tab[175] +#define __pyx_n_u_set_exception __pyx_string_tab[176] +#define __pyx_n_u_set_result __pyx_string_tab[177] +#define __pyx_n_u_setdefault __pyx_string_tab[178] +#define __pyx_n_u_size __pyx_string_tab[179] +#define __pyx_n_u_state __pyx_string_tab[180] +#define __pyx_n_u_streams __pyx_string_tab[181] +#define __pyx_n_u_suppress_deflate_header __pyx_string_tab[182] +#define __pyx_n_u_sys __pyx_string_tab[183] +#define __pyx_n_u_throw __pyx_string_tab[184] +#define __pyx_n_u_update __pyx_string_tab[185] +#define __pyx_n_u_use_setstate __pyx_string_tab[186] +#define __pyx_n_u_value __pyx_string_tab[187] +#define __pyx_n_u_values __pyx_string_tab[188] +#define __pyx_n_u_waiter __pyx_string_tab[189] +#define __pyx_n_u_warning __pyx_string_tab[190] +#define __pyx_n_u_weakref __pyx_string_tab[191] +#define __pyx_n_u_websocket_mask __pyx_string_tab[192] +#define __pyx_n_u_ws_logger __pyx_string_tab[193] +#define __pyx_kp_b__3 __pyx_string_tab[194] +#define __pyx_kp_b_PyObject_int_unsigned_PY_LONG_LO __pyx_string_tab[195] +#define __pyx_kp_b_void_PyObject_PyObject_int___pyx __pyx_string_tab[196] +#define __pyx_kp_b_iso88591_QfA __pyx_string_tab[197] +#define __pyx_kp_b_iso88591_0_q __pyx_string_tab[198] +#define __pyx_kp_b_iso88591_q_0_kQR_1_7_1_2DNRS_1 __pyx_string_tab[199] +#define __pyx_kp_b_iso88591_q_0_kQR_XQa_7_4A5J_XY_1 __pyx_string_tab[200] +#define __pyx_kp_b_iso88591_Zt7_m4_TQZZ_ffjjvvz_I_I_M_M_U_U __pyx_string_tab[201] +#define __pyx_kp_b_iso88591_4_dJ___ffjjww_J_J_N_N_b_b_w_w_G __pyx_string_tab[202] +#define __pyx_kp_b_iso88591_A_7_n_4A_wc_d_is_nA_q_t1_7_Q_1_M __pyx_string_tab[203] +#define __pyx_kp_b_iso88591_A_A_HA_N_G3d_G1_1_q __pyx_string_tab[204] +#define __pyx_kp_b_iso88591_t1 __pyx_string_tab[205] +#define __pyx_kp_b_iso88591_F_1 __pyx_string_tab[206] +#define __pyx_kp_b_iso88591_HA_A_N __pyx_string_tab[207] +#define __pyx_kp_b_iso88591_1_t1 __pyx_string_tab[208] +#define __pyx_kp_b_iso88591_a_4q_gQ_5_4vWA_6_1A_A_ha_1_q __pyx_string_tab[209] +#define __pyx_kp_b_iso88591_a_t1_Je2Q_L_A_4wb_HD_D __pyx_string_tab[210] +#define __pyx_kp_b_iso88591_q_F_Q_4q_it7_F_A_3aq_A_z_9D_F_4 __pyx_string_tab[211] +#define __pyx_kp_b_iso88591_A __pyx_string_tab[212] +#define __pyx_int_0 __pyx_number_tab[0] +#define __pyx_int_2 __pyx_number_tab[1] +#define __pyx_int_256 __pyx_number_tab[2] +#define __pyx_int_3000 __pyx_number_tab[3] +#define __pyx_int_4999 __pyx_number_tab[4] +#define __pyx_int_130792693 __pyx_number_tab[5] +#define __pyx_int_223677156 __pyx_number_tab[6] +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) { + __pyx_mstatetype *clear_module_state = __Pyx_PyModule_GetState(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #if CYTHON_PEP489_MULTI_PHASE_INIT + __Pyx_State_RemoveModule(NULL); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue); + Py_CLEAR(clear_module_state->__pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue); + Py_CLEAR(clear_module_state->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader); + Py_CLEAR(clear_module_state->__pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketReader); + Py_CLEAR(clear_module_state->__pyx_ptype_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read); + Py_CLEAR(clear_module_state->__pyx_type_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read); + Py_CLEAR(clear_module_state->__pyx_umethod_PyDict_Type_items.method); + Py_CLEAR(clear_module_state->__pyx_umethod_PyDict_Type_pop.method); + Py_CLEAR(clear_module_state->__pyx_umethod_PyDict_Type_values.method); + Py_CLEAR(clear_module_state->__pyx_k__2); + for (int i=0; i<2; ++i) { Py_CLEAR(clear_module_state->__pyx_slice[i]); } + for (int i=0; i<4; ++i) { Py_CLEAR(clear_module_state->__pyx_tuple[i]); } + for (int i=0; i<16; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<213; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); } + for (int i=0; i<7; ++i) { Py_CLEAR(clear_module_state->__pyx_number_tab[i]); } +/* #### Code section: module_state_clear_contents ### */ +/* CommonTypesMetaclass.module_state_clear */ +Py_CLEAR(clear_module_state->__pyx_CommonTypesMetaclassType); + +/* Coroutine.module_state_clear */ +Py_CLEAR(clear_module_state->__pyx_CoroutineType); +Py_CLEAR(clear_module_state->__pyx_CoroutineAwaitType); + +/* CythonFunctionPerModule.module_state_clear */ +Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + +/* #### Code section: module_state_clear_end ### */ +return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstatetype *traverse_module_state = __Pyx_PyModule_GetState(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_tuple); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_bytes); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_unicode); + Py_VISIT(traverse_module_state->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue); + Py_VISIT(traverse_module_state->__pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue); + Py_VISIT(traverse_module_state->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader); + Py_VISIT(traverse_module_state->__pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketReader); + Py_VISIT(traverse_module_state->__pyx_ptype_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read); + Py_VISIT(traverse_module_state->__pyx_type_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read); + Py_VISIT(traverse_module_state->__pyx_umethod_PyDict_Type_items.method); + Py_VISIT(traverse_module_state->__pyx_umethod_PyDict_Type_pop.method); + Py_VISIT(traverse_module_state->__pyx_umethod_PyDict_Type_values.method); + Py_VISIT(traverse_module_state->__pyx_k__2); + for (int i=0; i<2; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_slice[i]); } + for (int i=0; i<4; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_tuple[i]); } + for (int i=0; i<16; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<213; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); } + for (int i=0; i<7; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_number_tab[i]); } +/* #### Code section: module_state_traverse_contents ### */ +/* CommonTypesMetaclass.module_state_traverse */ +Py_VISIT(traverse_module_state->__pyx_CommonTypesMetaclassType); + +/* Coroutine.module_state_traverse */ +Py_VISIT(traverse_module_state->__pyx_CoroutineType); +Py_VISIT(traverse_module_state->__pyx_CoroutineAwaitType); + +/* CythonFunctionPerModule.module_state_traverse */ +Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + +/* #### Code section: module_state_traverse_end ### */ +return 0; +} +#endif +/* #### Code section: module_code ### */ + +/* "aiohttp/_websocket/reader_py.py":87 + * """ + * + * def __init__( # <<<<<<<<<<<<<< + * self, protocol: BaseProtocol, limit: int, *, loop: asyncio.AbstractEventLoop + * ) -> None: +*/ + +/* Python wrapper */ +static int __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_1__init__(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL_TPNEW +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static int __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_1__init__(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL_TPNEW +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_protocol = 0; + PyObject *__pyx_v_limit = 0; + PyObject *__pyx_v_loop = 0; + #if !CYTHON_VECTORCALL_TPNEW + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if !CYTHON_VECTORCALL_TPNEW + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL_TPNEW(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_protocol,&__pyx_mstate_global->__pyx_n_u_limit,&__pyx_mstate_global->__pyx_n_u_loop,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL_TPNEW(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 87, __pyx_L3_error) + if (likely(__pyx_kwds_len > 0)) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL_TPNEW(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 87, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL_TPNEW(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 87, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < (0)) __PYX_ERR(0, 87, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, i); __PYX_ERR(0, 87, __pyx_L3_error) } + } + for (Py_ssize_t i = 2; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseKeywordRequired("__init__", *(__pyx_pyargnames[i - 0])); __PYX_ERR(0, 87, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + __Pyx_RaiseKeywordRequired("__init__", __pyx_mstate_global->__pyx_n_u_loop); __PYX_ERR(0, 87, __pyx_L3_error) + } + __pyx_v_protocol = values[0]; + if (__Pyx_PyInt_FromNumber(&values[1], "limit", 0) < (0)) __PYX_ERR(0, 88, __pyx_L3_error) + __pyx_v_limit = ((PyObject*)values[1]); + __pyx_v_loop = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 87, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketDataQueue.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_limit), (&PyLong_Type), 0, "limit", 2))) __PYX_ERR(0, 88, __pyx_L1_error) + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue___init__(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self), __pyx_v_protocol, __pyx_v_limit, __pyx_v_loop); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue___init__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self, PyObject *__pyx_v_protocol, PyObject *__pyx_v_limit, PyObject *__pyx_v_loop) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + unsigned int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "aiohttp/_websocket/reader_py.py":90 + * self, protocol: BaseProtocol, limit: int, *, loop: asyncio.AbstractEventLoop + * ) -> None: + * self._size = 0 # <<<<<<<<<<<<<< + * self._protocol = protocol + * self._limit = limit * 2 +*/ + __pyx_v_self->_size = 0; + + /* "aiohttp/_websocket/reader_py.py":91 + * ) -> None: + * self._size = 0 + * self._protocol = protocol # <<<<<<<<<<<<<< + * self._limit = limit * 2 + * self._loop = loop +*/ + __Pyx_INCREF(__pyx_v_protocol); + __Pyx_GIVEREF(__pyx_v_protocol); + __Pyx_GOTREF(__pyx_v_self->_protocol); + __Pyx_DECREF(__pyx_v_self->_protocol); + __pyx_v_self->_protocol = __pyx_v_protocol; + + /* "aiohttp/_websocket/reader_py.py":92 + * self._size = 0 + * self._protocol = protocol + * self._limit = limit * 2 # <<<<<<<<<<<<<< + * self._loop = loop + * self._eof = False +*/ + __pyx_t_1 = __Pyx_PyLong_MultiplyObjC(__pyx_v_limit, __pyx_mstate_global->__pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_self->_limit = __pyx_t_2; + + /* "aiohttp/_websocket/reader_py.py":93 + * self._protocol = protocol + * self._limit = limit * 2 + * self._loop = loop # <<<<<<<<<<<<<< + * self._eof = False + * self._waiter: asyncio.Future[None] | None = None +*/ + __Pyx_INCREF(__pyx_v_loop); + __Pyx_GIVEREF(__pyx_v_loop); + __Pyx_GOTREF(__pyx_v_self->_loop); + __Pyx_DECREF(__pyx_v_self->_loop); + __pyx_v_self->_loop = __pyx_v_loop; + + /* "aiohttp/_websocket/reader_py.py":94 + * self._limit = limit * 2 + * self._loop = loop + * self._eof = False # <<<<<<<<<<<<<< + * self._waiter: asyncio.Future[None] | None = None + * self._exception: type[BaseException] | BaseException | None = None +*/ + __pyx_v_self->_eof = 0; + + /* "aiohttp/_websocket/reader_py.py":95 + * self._loop = loop + * self._eof = False + * self._waiter: asyncio.Future[None] | None = None # <<<<<<<<<<<<<< + * self._exception: type[BaseException] | BaseException | None = None + * self._buffer: deque[WSMessage] = deque() +*/ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_waiter); + __Pyx_DECREF(__pyx_v_self->_waiter); + __pyx_v_self->_waiter = Py_None; + + /* "aiohttp/_websocket/reader_py.py":96 + * self._eof = False + * self._waiter: asyncio.Future[None] | None = None + * self._exception: type[BaseException] | BaseException | None = None # <<<<<<<<<<<<<< + * self._buffer: deque[WSMessage] = deque() + * self._get_buffer = self._buffer.popleft +*/ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_exception); + __Pyx_DECREF(__pyx_v_self->_exception); + __pyx_v_self->_exception = Py_None; + + /* "aiohttp/_websocket/reader_py.py":97 + * self._waiter: asyncio.Future[None] | None = None + * self._exception: type[BaseException] | BaseException | None = None + * self._buffer: deque[WSMessage] = deque() # <<<<<<<<<<<<<< + * self._get_buffer = self._buffer.popleft + * self._put_buffer = self._buffer.append +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_deque); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_buffer); + __Pyx_DECREF(__pyx_v_self->_buffer); + __pyx_v_self->_buffer = __pyx_t_1; + __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":98 + * self._exception: type[BaseException] | BaseException | None = None + * self._buffer: deque[WSMessage] = deque() + * self._get_buffer = self._buffer.popleft # <<<<<<<<<<<<<< + * self._put_buffer = self._buffer.append + * self._stalled_reader: "weakref.ref[WebSocketReader] | None" = None +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_buffer, __pyx_mstate_global->__pyx_n_u_popleft); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_get_buffer); + __Pyx_DECREF(__pyx_v_self->_get_buffer); + __pyx_v_self->_get_buffer = __pyx_t_1; + __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":99 + * self._buffer: deque[WSMessage] = deque() + * self._get_buffer = self._buffer.popleft + * self._put_buffer = self._buffer.append # <<<<<<<<<<<<<< + * self._stalled_reader: "weakref.ref[WebSocketReader] | None" = None + * +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_buffer, __pyx_mstate_global->__pyx_n_u_append); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_put_buffer); + __Pyx_DECREF(__pyx_v_self->_put_buffer); + __pyx_v_self->_put_buffer = __pyx_t_1; + __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":100 + * self._get_buffer = self._buffer.popleft + * self._put_buffer = self._buffer.append + * self._stalled_reader: "weakref.ref[WebSocketReader] | None" = None # <<<<<<<<<<<<<< + * + * def is_eof(self) -> bool: +*/ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_stalled_reader); + __Pyx_DECREF(__pyx_v_self->_stalled_reader); + __pyx_v_self->_stalled_reader = Py_None; + + /* "aiohttp/_websocket/reader_py.py":87 + * """ + * + * def __init__( # <<<<<<<<<<<<<< + * self, protocol: BaseProtocol, limit: int, *, loop: asyncio.AbstractEventLoop + * ) -> None: +*/ + + /* 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("aiohttp._websocket.reader_c.WebSocketDataQueue.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "aiohttp/_websocket/reader_py.py":102 + * self._stalled_reader: "weakref.ref[WebSocketReader] | None" = None + * + * def is_eof(self) -> bool: # <<<<<<<<<<<<<< + * return self._eof + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_3is_eof(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_3is_eof = {"is_eof", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_3is_eof, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_3is_eof(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_VECTORCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_eof (wrapper)", 0); + #if !CYTHON_VECTORCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("is_eof", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("is_eof", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_2is_eof(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_2is_eof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_eof", 0); + + /* "aiohttp/_websocket/reader_py.py":103 + * + * def is_eof(self) -> bool: + * return self._eof # <<<<<<<<<<<<<< + * + * def exception(self) -> type[BaseException] | BaseException | None: +*/ + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_eof); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __pyx_r = __pyx_t_1; + } + __Pyx_XDECREF(__pyx_temp); + } + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "aiohttp/_websocket/reader_py.py":102 + * self._stalled_reader: "weakref.ref[WebSocketReader] | None" = None + * + * def is_eof(self) -> bool: # <<<<<<<<<<<<<< + * return self._eof + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketDataQueue.is_eof", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "aiohttp/_websocket/reader_py.py":105 + * return self._eof + * + * def exception(self) -> type[BaseException] | BaseException | None: # <<<<<<<<<<<<<< + * return self._exception + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_5exception(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_5exception = {"exception", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_5exception, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_5exception(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_VECTORCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("exception (wrapper)", 0); + #if !CYTHON_VECTORCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("exception", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("exception", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_4exception(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_4exception(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("exception", 0); + + /* "aiohttp/_websocket/reader_py.py":106 + * + * def exception(self) -> type[BaseException] | BaseException | None: + * return self._exception # <<<<<<<<<<<<<< + * + * def set_exception( +*/ + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __Pyx_INCREF(__pyx_v_self->_exception); + __pyx_r = __pyx_v_self->_exception; + } + __Pyx_XDECREF(__pyx_temp); + } + goto __pyx_L0; + + /* "aiohttp/_websocket/reader_py.py":105 + * return self._eof + * + * def exception(self) -> type[BaseException] | BaseException | None: # <<<<<<<<<<<<<< + * return self._exception + * +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "aiohttp/_websocket/reader_py.py":108 + * return self._exception + * + * def set_exception( # <<<<<<<<<<<<<< + * self, + * exc: type[BaseException] | BaseException, +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7set_exception(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7set_exception = {"set_exception", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7set_exception, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7set_exception(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_exc = 0; + PyObject *__pyx_v_exc_cause = 0; + #if !CYTHON_VECTORCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_exception (wrapper)", 0); + #if !CYTHON_VECTORCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_exc,&__pyx_mstate_global->__pyx_n_u_exc_cause,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 108, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 108, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 108, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "set_exception", 0) < (0)) __PYX_ERR(0, 108, __pyx_L3_error) + if (!values[1]) values[1] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__2); + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("set_exception", 0, 1, 2, i); __PYX_ERR(0, 108, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 108, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 108, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[1]) values[1] = __Pyx_NewRef(__pyx_mstate_global->__pyx_k__2); + } + __pyx_v_exc = values[0]; + __pyx_v_exc_cause = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_exception", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 108, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketDataQueue.set_exception", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_6set_exception(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self), __pyx_v_exc, __pyx_v_exc_cause); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_6set_exception(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self, PyObject *__pyx_v_exc, PyObject *__pyx_v_exc_cause) { + PyObject *__pyx_v_waiter = 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; + size_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("set_exception", 0); + + /* "aiohttp/_websocket/reader_py.py":113 + * exc_cause: builtins.BaseException = _EXC_SENTINEL, + * ) -> None: + * self._eof = True # <<<<<<<<<<<<<< + * self._exception = exc + * if (waiter := self._waiter) is not None: +*/ + __pyx_v_self->_eof = 1; + + /* "aiohttp/_websocket/reader_py.py":114 + * ) -> None: + * self._eof = True + * self._exception = exc # <<<<<<<<<<<<<< + * if (waiter := self._waiter) is not None: + * self._waiter = None +*/ + __Pyx_INCREF(__pyx_v_exc); + __Pyx_GIVEREF(__pyx_v_exc); + __Pyx_GOTREF(__pyx_v_self->_exception); + __Pyx_DECREF(__pyx_v_self->_exception); + __pyx_v_self->_exception = __pyx_v_exc; + + /* "aiohttp/_websocket/reader_py.py":115 + * self._eof = True + * self._exception = exc + * if (waiter := self._waiter) is not None: # <<<<<<<<<<<<<< + * self._waiter = None + * set_exception(waiter, exc, exc_cause) +*/ + __pyx_t_1 = __pyx_v_self->_waiter; + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_waiter = __pyx_t_1; + __pyx_t_2 = (__pyx_t_1 != Py_None); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + + /* "aiohttp/_websocket/reader_py.py":116 + * self._exception = exc + * if (waiter := self._waiter) is not None: + * self._waiter = None # <<<<<<<<<<<<<< + * set_exception(waiter, exc, exc_cause) + * +*/ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_waiter); + __Pyx_DECREF(__pyx_v_self->_waiter); + __pyx_v_self->_waiter = Py_None; + + /* "aiohttp/_websocket/reader_py.py":117 + * if (waiter := self._waiter) is not None: + * self._waiter = None + * set_exception(waiter, exc, exc_cause) # <<<<<<<<<<<<<< + * + * def _release_waiter(self) -> None: +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_set_exception); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_3, __pyx_v_waiter, __pyx_v_exc, __pyx_v_exc_cause}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (4-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":115 + * self._eof = True + * self._exception = exc + * if (waiter := self._waiter) is not None: # <<<<<<<<<<<<<< + * self._waiter = None + * set_exception(waiter, exc, exc_cause) +*/ + } + + /* "aiohttp/_websocket/reader_py.py":108 + * return self._exception + * + * def set_exception( # <<<<<<<<<<<<<< + * self, + * exc: type[BaseException] | BaseException, +*/ + + /* 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("aiohttp._websocket.reader_c.WebSocketDataQueue.set_exception", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_waiter); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "aiohttp/_websocket/reader_py.py":119 + * set_exception(waiter, exc, exc_cause) + * + * def _release_waiter(self) -> None: # <<<<<<<<<<<<<< + * if (waiter := self._waiter) is None: + * return +*/ + +static void __pyx_f_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__release_waiter(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self) { + PyObject *__pyx_v_waiter = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_release_waiter", 0); + + /* "aiohttp/_websocket/reader_py.py":120 + * + * def _release_waiter(self) -> None: + * if (waiter := self._waiter) is None: # <<<<<<<<<<<<<< + * return + * self._waiter = None +*/ + __pyx_t_1 = __pyx_v_self->_waiter; + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_waiter = __pyx_t_1; + __pyx_t_2 = (__pyx_t_1 == Py_None); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + + /* "aiohttp/_websocket/reader_py.py":121 + * def _release_waiter(self) -> None: + * if (waiter := self._waiter) is None: + * return # <<<<<<<<<<<<<< + * self._waiter = None + * if not waiter.done(): +*/ + { + } + goto __pyx_L0; + + /* "aiohttp/_websocket/reader_py.py":120 + * + * def _release_waiter(self) -> None: + * if (waiter := self._waiter) is None: # <<<<<<<<<<<<<< + * return + * self._waiter = None +*/ + } + + /* "aiohttp/_websocket/reader_py.py":122 + * if (waiter := self._waiter) is None: + * return + * self._waiter = None # <<<<<<<<<<<<<< + * if not waiter.done(): + * waiter.set_result(None) +*/ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_waiter); + __Pyx_DECREF(__pyx_v_self->_waiter); + __pyx_v_self->_waiter = Py_None; + + /* "aiohttp/_websocket/reader_py.py":123 + * return + * self._waiter = None + * if not waiter.done(): # <<<<<<<<<<<<<< + * waiter.set_result(None) + * +*/ + __pyx_t_3 = __pyx_v_waiter; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_done, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __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(0, 123, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = (!__pyx_t_2); + + + if (__pyx_t_5) { + + + /* "aiohttp/_websocket/reader_py.py":124 + * self._waiter = None + * if not waiter.done(): + * waiter.set_result(None) # <<<<<<<<<<<<<< + * + * def feed_eof(self) -> None: +*/ + __pyx_t_3 = __pyx_v_waiter; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, Py_None}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_set_result, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":123 + * return + * self._waiter = None + * if not waiter.done(): # <<<<<<<<<<<<<< + * waiter.set_result(None) + * +*/ + } + + /* "aiohttp/_websocket/reader_py.py":119 + * set_exception(waiter, exc, exc_cause) + * + * def _release_waiter(self) -> None: # <<<<<<<<<<<<<< + * if (waiter := self._waiter) is None: + * return +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketDataQueue._release_waiter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_waiter); + + __Pyx_RefNannyFinishContext(); +} + +/* "aiohttp/_websocket/reader_py.py":126 + * waiter.set_result(None) + * + * def feed_eof(self) -> None: # <<<<<<<<<<<<<< + * self._eof = True + * self._release_waiter() +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9feed_eof(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9feed_eof = {"feed_eof", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9feed_eof, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9feed_eof(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_VECTORCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("feed_eof (wrapper)", 0); + #if !CYTHON_VECTORCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("feed_eof", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("feed_eof", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_8feed_eof(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_8feed_eof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("feed_eof", 0); + + /* "aiohttp/_websocket/reader_py.py":127 + * + * def feed_eof(self) -> None: + * self._eof = True # <<<<<<<<<<<<<< + * self._release_waiter() + * self._exception = None # Break cyclic references +*/ + __pyx_v_self->_eof = 1; + + /* "aiohttp/_websocket/reader_py.py":128 + * def feed_eof(self) -> None: + * self._eof = True + * self._release_waiter() # <<<<<<<<<<<<<< + * self._exception = None # Break cyclic references + * +*/ + ((struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self->__pyx_vtab)->_release_waiter(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 128, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":129 + * self._eof = True + * self._release_waiter() + * self._exception = None # Break cyclic references # <<<<<<<<<<<<<< + * + * def feed_data(self, data: "WSMessage") -> None: +*/ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_exception); + __Pyx_DECREF(__pyx_v_self->_exception); + __pyx_v_self->_exception = Py_None; + + /* "aiohttp/_websocket/reader_py.py":126 + * waiter.set_result(None) + * + * def feed_eof(self) -> None: # <<<<<<<<<<<<<< + * self._eof = True + * self._release_waiter() +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketDataQueue.feed_eof", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "aiohttp/_websocket/reader_py.py":131 + * self._exception = None # Break cyclic references + * + * def feed_data(self, data: "WSMessage") -> None: # <<<<<<<<<<<<<< + * # Unbox into the typed local before adding, so Cython keeps the sum in + * # C instead of boxing MSG_SIZE_OVERHEAD for a Python-level add. +*/ + +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_11feed_data(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static void __pyx_f_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_feed_data(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self, PyObject *__pyx_v_data, int __pyx_skip_dispatch) { + unsigned int __pyx_v_size; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + unsigned int __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("feed_data", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if ( + #if !CYTHON_USE_TYPE_SLOTS + unlikely(Py_TYPE(((PyObject *)__pyx_v_self)) != __pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue && + __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), Py_TPFLAGS_HAVE_GC)) + #else + unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0 || __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE))) + #endif + ) { + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; + if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { + PY_UINT64_T __pyx_typedict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); + #endif + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_feed_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!__Pyx_IsSameCFunction(__pyx_t_1, (void(*)(void)) __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_11feed_data)) { + __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_data}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + { + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); + __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); + if (unlikely(__pyx_typedict_guard != __pyx_tp_dict_version)) { + __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; + } + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + } + #endif + } + + /* "aiohttp/_websocket/reader_py.py":134 + * # Unbox into the typed local before adding, so Cython keeps the sum in + * # C instead of boxing MSG_SIZE_OVERHEAD for a Python-level add. + * size = data.size # <<<<<<<<<<<<<< + * self._size += size + MSG_SIZE_OVERHEAD + * self._put_buffer(data) +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyLong_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_size = __pyx_t_6; + + /* "aiohttp/_websocket/reader_py.py":135 + * # C instead of boxing MSG_SIZE_OVERHEAD for a Python-level add. + * size = data.size + * self._size += size + MSG_SIZE_OVERHEAD # <<<<<<<<<<<<<< + * self._put_buffer(data) + * self._release_waiter() +*/ + __pyx_v_self->_size = (__pyx_v_self->_size + (__pyx_v_size + __pyx_v_7aiohttp_10_websocket_8reader_c_MSG_SIZE_OVERHEAD)); + + /* "aiohttp/_websocket/reader_py.py":136 + * size = data.size + * self._size += size + MSG_SIZE_OVERHEAD + * self._put_buffer(data) # <<<<<<<<<<<<<< + * self._release_waiter() + * if self._size > self._limit and not self._protocol._reading_paused: +*/ + __pyx_t_2 = NULL; + __Pyx_INCREF(__pyx_v_self->_put_buffer); + __pyx_t_4 = __pyx_v_self->_put_buffer; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_data}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":137 + * self._size += size + MSG_SIZE_OVERHEAD + * self._put_buffer(data) + * self._release_waiter() # <<<<<<<<<<<<<< + * if self._size > self._limit and not self._protocol._reading_paused: + * self._protocol.pause_reading() +*/ + ((struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self->__pyx_vtab)->_release_waiter(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 137, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":138 + * self._put_buffer(data) + * self._release_waiter() + * if self._size > self._limit and not self._protocol._reading_paused: # <<<<<<<<<<<<<< + * self._protocol.pause_reading() + * +*/ + __pyx_t_8 = (__pyx_v_self->_size > __pyx_v_self->_limit); + + if (__pyx_t_8) { + + } else { + + __pyx_t_7 = __pyx_t_8; + + goto __pyx_L4_bool_binop_done; + } + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_protocol, __pyx_mstate_global->__pyx_n_u_reading_paused); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_9 = (!__pyx_t_8); + + + + __pyx_t_7 = __pyx_t_9; + + __pyx_L4_bool_binop_done:; + if (__pyx_t_7) { + + + /* "aiohttp/_websocket/reader_py.py":139 + * self._release_waiter() + * if self._size > self._limit and not self._protocol._reading_paused: + * self._protocol.pause_reading() # <<<<<<<<<<<<<< + * + * async def read(self) -> WSMessage: +*/ + __pyx_t_4 = __pyx_v_self->_protocol; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_pause_reading, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":138 + * self._put_buffer(data) + * self._release_waiter() + * if self._size > self._limit and not self._protocol._reading_paused: # <<<<<<<<<<<<<< + * self._protocol.pause_reading() + * +*/ + } + + /* "aiohttp/_websocket/reader_py.py":131 + * self._exception = None # Break cyclic references + * + * def feed_data(self, data: "WSMessage") -> None: # <<<<<<<<<<<<<< + * # Unbox into the typed local before adding, so Cython keeps the sum in + * # C instead of boxing MSG_SIZE_OVERHEAD for a Python-level add. +*/ + + /* function exit code */ + 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_AddTraceback("aiohttp._websocket.reader_c.WebSocketDataQueue.feed_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + + + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_11feed_data(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_11feed_data = {"feed_data", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_11feed_data, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_11feed_data(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_data = 0; + #if !CYTHON_VECTORCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("feed_data (wrapper)", 0); + #if !CYTHON_VECTORCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_data,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 131, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 131, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "feed_data", 0) < (0)) __PYX_ERR(0, 131, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("feed_data", 1, 1, 1, i); __PYX_ERR(0, 131, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 131, __pyx_L3_error) + } + __pyx_v_data = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("feed_data", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 131, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketDataQueue.feed_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_10feed_data(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self), __pyx_v_data); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_10feed_data(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self, PyObject *__pyx_v_data) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("feed_data", 0); + __pyx_f_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_feed_data(__pyx_v_self, __pyx_v_data, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error) + __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __pyx_r = __pyx_t_1; + } + __Pyx_XDECREF(__pyx_temp); + } + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketDataQueue.feed_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_14generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "aiohttp/_websocket/reader_py.py":141 + * self._protocol.pause_reading() + * + * async def read(self) -> WSMessage: # <<<<<<<<<<<<<< + * if not self._buffer and not self._eof: + * assert not self._waiter +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_13read(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_13read = {"read", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_13read, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_13read(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_VECTORCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("read (wrapper)", 0); + #if !CYTHON_VECTORCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("read", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("read", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_12read(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_12read(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self) { + struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("read", 0); + __pyx_cur_scope = (struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read *)__pyx_tp_new_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read(__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 141, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__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_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_14generator, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_read, __pyx_mstate_global->__pyx_n_u_WebSocketDataQueue_read, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c); if (unlikely(!gen)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketDataQueue.read", __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_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_14generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read *__pyx_cur_scope = ((struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read *)__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; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + __Pyx_PySendResult __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + int __pyx_t_15; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("read", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L13_resume_from_await; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(__pyx_sent_value != Py_None)) { + if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started coroutine"); + __PYX_ERR(0, 141, __pyx_L1_error) + } + + /* "aiohttp/_websocket/reader_py.py":142 + * + * async def read(self) -> WSMessage: + * if not self._buffer and not self._eof: # <<<<<<<<<<<<<< + * assert not self._waiter + * self._waiter = self._loop.create_future() +*/ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_self->_buffer); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 142, __pyx_L1_error) + __pyx_t_3 = (!__pyx_t_2); + + + if (__pyx_t_3) { + + } else { + + __pyx_t_1 = __pyx_t_3; + + goto __pyx_L5_bool_binop_done; + } + __pyx_t_3 = (!__pyx_cur_scope->__pyx_v_self->_eof); + + + __pyx_t_1 = __pyx_t_3; + + __pyx_L5_bool_binop_done:; + if (__pyx_t_1) { + + + /* "aiohttp/_websocket/reader_py.py":143 + * async def read(self) -> WSMessage: + * if not self._buffer and not self._eof: + * assert not self._waiter # <<<<<<<<<<<<<< + * self._waiter = self._loop.create_future() + * try: +*/ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_self->_waiter); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 143, __pyx_L1_error) + __pyx_t_3 = (!__pyx_t_1); + + + if (unlikely(!__pyx_t_3)) { + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_AssertionError))), 0, 0, 0); + __PYX_ERR(0, 143, __pyx_L1_error) + } + + } + #else + if ((1)); else __PYX_ERR(0, 143, __pyx_L1_error) + #endif + + /* "aiohttp/_websocket/reader_py.py":144 + * if not self._buffer and not self._eof: + * assert not self._waiter + * self._waiter = self._loop.create_future() # <<<<<<<<<<<<<< + * try: + * await self._waiter +*/ + __pyx_t_5 = __pyx_cur_scope->__pyx_v_self->_loop; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_create_future, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->_waiter); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->_waiter); + __pyx_cur_scope->__pyx_v_self->_waiter = __pyx_t_4; + __pyx_t_4 = 0; + + /* "aiohttp/_websocket/reader_py.py":145 + * assert not self._waiter + * self._waiter = self._loop.create_future() + * try: # <<<<<<<<<<<<<< + * await self._waiter + * except (asyncio.CancelledError, asyncio.TimeoutError): +*/ + { + __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:*/ { + + /* "aiohttp/_websocket/reader_py.py":146 + * self._waiter = self._loop.create_future() + * try: + * await self._waiter # <<<<<<<<<<<<<< + * except (asyncio.CancelledError, asyncio.TimeoutError): + * self._waiter = None +*/ + __pyx_t_10 = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_self->_waiter, &__pyx_r); + if (likely(__pyx_t_10 == PYGEN_NEXT)) { + __Pyx_GOTREF(__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(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, awaiting value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L13_resume_from_await:; + __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(0, 146, __pyx_L7_error) + } else if (likely(__pyx_t_10 == PYGEN_RETURN)) { + __Pyx_GOTREF(__pyx_r); + __Pyx_DECREF(__pyx_r); __pyx_r = 0; + } else { + __Pyx_XGOTREF(__pyx_r); + __PYX_ERR(0, 146, __pyx_L7_error) + } + + /* "aiohttp/_websocket/reader_py.py":145 + * assert not self._waiter + * self._waiter = self._loop.create_future() + * try: # <<<<<<<<<<<<<< + * await self._waiter + * except (asyncio.CancelledError, asyncio.TimeoutError): +*/ + } + __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_L12_try_end; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "aiohttp/_websocket/reader_py.py":147 + * try: + * await self._waiter + * except (asyncio.CancelledError, asyncio.TimeoutError): # <<<<<<<<<<<<<< + * self._waiter = None + * raise +*/ + __Pyx_ErrFetch(&__pyx_t_4, &__pyx_t_5, &__pyx_t_11); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_asyncio); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 147, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_CancelledError); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 147, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_asyncio); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 147, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_TimeoutError); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 147, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_15 = __Pyx_PyErr_GivenExceptionMatches2(__pyx_t_4, __pyx_t_13, __pyx_t_14); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_ErrRestore(__pyx_t_4, __pyx_t_5, __pyx_t_11); + __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_11 = 0; + if (__pyx_t_15) { + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketDataQueue.read", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_11, &__pyx_t_5, &__pyx_t_4) < 0) __PYX_ERR(0, 147, __pyx_L9_except_error) + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_4); + + /* "aiohttp/_websocket/reader_py.py":148 + * await self._waiter + * except (asyncio.CancelledError, asyncio.TimeoutError): + * self._waiter = None # <<<<<<<<<<<<<< + * raise + * return self._read_from_buffer() +*/ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_self->_waiter); + __Pyx_DECREF(__pyx_cur_scope->__pyx_v_self->_waiter); + __pyx_cur_scope->__pyx_v_self->_waiter = Py_None; + + /* "aiohttp/_websocket/reader_py.py":149 + * except (asyncio.CancelledError, asyncio.TimeoutError): + * self._waiter = None + * raise # <<<<<<<<<<<<<< + * return self._read_from_buffer() + * +*/ + __Pyx_GIVEREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ErrRestoreWithState(__pyx_t_11, __pyx_t_5, __pyx_t_4); + __pyx_t_11 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; + __PYX_ERR(0, 149, __pyx_L9_except_error) + } + goto __pyx_L9_except_error; + + /* "aiohttp/_websocket/reader_py.py":145 + * assert not self._waiter + * self._waiter = self._loop.create_future() + * try: # <<<<<<<<<<<<<< + * await self._waiter + * except (asyncio.CancelledError, asyncio.TimeoutError): +*/ + __pyx_L9_except_error:; + __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_L12_try_end:; + } + + /* "aiohttp/_websocket/reader_py.py":142 + * + * async def read(self) -> WSMessage: + * if not self._buffer and not self._eof: # <<<<<<<<<<<<<< + * assert not self._waiter + * self._waiter = self._loop.create_future() +*/ + } + + /* "aiohttp/_websocket/reader_py.py":150 + * self._waiter = None + * raise + * return self._read_from_buffer() # <<<<<<<<<<<<<< + * + * def _read_from_buffer(self) -> WSMessage: +*/ + __pyx_t_4 = ((struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_read_from_buffer(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __pyx_r = __pyx_t_4; + } + __Pyx_XDECREF(__pyx_temp); + } + __pyx_t_4 = 0; + goto __pyx_L0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* "aiohttp/_websocket/reader_py.py":141 + * self._protocol.pause_reading() + * + * async def read(self) -> WSMessage: # <<<<<<<<<<<<<< + * if not self._buffer and not self._eof: + * assert not self._waiter +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + if (__Pyx_PyErr_Occurred()) { + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_AddTraceback("read", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "aiohttp/_websocket/reader_py.py":152 + * return self._read_from_buffer() + * + * def _read_from_buffer(self) -> WSMessage: # <<<<<<<<<<<<<< + * if self._buffer: + * data = self._get_buffer() +*/ + +static PyObject *__pyx_f_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__read_from_buffer(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self) { + unsigned int __pyx_v_size; + PyObject *__pyx_v_data = NULL; + PyObject *__pyx_v_reader = 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; + size_t __pyx_t_5; + unsigned int __pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_read_from_buffer", 0); + + /* "aiohttp/_websocket/reader_py.py":153 + * + * def _read_from_buffer(self) -> WSMessage: + * if self._buffer: # <<<<<<<<<<<<<< + * data = self._get_buffer() + * size = data.size +*/ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_buffer); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 153, __pyx_L1_error) + if (__pyx_t_1) { + + + /* "aiohttp/_websocket/reader_py.py":154 + * def _read_from_buffer(self) -> WSMessage: + * if self._buffer: + * data = self._get_buffer() # <<<<<<<<<<<<<< + * size = data.size + * self._size -= size + MSG_SIZE_OVERHEAD +*/ + __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_self->_get_buffer); + __pyx_t_4 = __pyx_v_self->_get_buffer; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v_data = __pyx_t_2; + __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":155 + * if self._buffer: + * data = self._get_buffer() + * size = data.size # <<<<<<<<<<<<<< + * self._size -= size + MSG_SIZE_OVERHEAD + * if self._stalled_reader is not None and self._size <= self._limit // 2: +*/ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyLong_As_unsigned_int(__pyx_t_2); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_size = __pyx_t_6; + + /* "aiohttp/_websocket/reader_py.py":156 + * data = self._get_buffer() + * size = data.size + * self._size -= size + MSG_SIZE_OVERHEAD # <<<<<<<<<<<<<< + * if self._stalled_reader is not None and self._size <= self._limit // 2: + * # Resume parsing once the queue drains to the low-water mark. +*/ + __pyx_v_self->_size = (__pyx_v_self->_size - (__pyx_v_size + __pyx_v_7aiohttp_10_websocket_8reader_c_MSG_SIZE_OVERHEAD)); + + /* "aiohttp/_websocket/reader_py.py":157 + * size = data.size + * self._size -= size + MSG_SIZE_OVERHEAD + * if self._stalled_reader is not None and self._size <= self._limit // 2: # <<<<<<<<<<<<<< + * # Resume parsing once the queue drains to the low-water mark. + * # Each resume re-slices the parser's unparsed tail, so waiting +*/ + __pyx_t_7 = (__pyx_v_self->_stalled_reader != Py_None); + if (__pyx_t_7) { + + } else { + + __pyx_t_1 = __pyx_t_7; + + goto __pyx_L5_bool_binop_done; + } + __pyx_t_7 = (__pyx_v_self->_size <= __Pyx_div_long(__pyx_v_self->_limit, 2, 1)); + + + __pyx_t_1 = __pyx_t_7; + + __pyx_L5_bool_binop_done:; + if (__pyx_t_1) { + + + /* "aiohttp/_websocket/reader_py.py":162 + * # for headroom makes a drain cost one copy per batch of + * # messages instead of one per message. + * if (reader := self._stalled_reader()) is not None: # <<<<<<<<<<<<<< + * reader.feed_data(b"") + * else: +*/ + __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_self->_stalled_reader); + __pyx_t_3 = __pyx_v_self->_stalled_reader; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_INCREF(__pyx_t_2); + __pyx_v_reader = __pyx_t_2; + __pyx_t_1 = (__pyx_t_2 != Py_None); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + + /* "aiohttp/_websocket/reader_py.py":163 + * # messages instead of one per message. + * if (reader := self._stalled_reader()) is not None: + * reader.feed_data(b"") # <<<<<<<<<<<<<< + * else: + * # The stash died with the reader. Deliver what was already +*/ + __pyx_t_3 = __pyx_v_reader; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_b__3}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_feed_data, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":162 + * # for headroom makes a drain cost one copy per batch of + * # messages instead of one per message. + * if (reader := self._stalled_reader()) is not None: # <<<<<<<<<<<<<< + * reader.feed_data(b"") + * else: +*/ + goto __pyx_L7; + } + + /* "aiohttp/_websocket/reader_py.py":171 + * # real failure that was already recorded stays the reported + * # cause. + * self._stalled_reader = None # <<<<<<<<<<<<<< + * ws_logger.warning(STALLED_READER_COLLECTED) + * if self._exception is None: +*/ + /*else*/ { + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_stalled_reader); + __Pyx_DECREF(__pyx_v_self->_stalled_reader); + __pyx_v_self->_stalled_reader = Py_None; + + /* "aiohttp/_websocket/reader_py.py":172 + * # cause. + * self._stalled_reader = None + * ws_logger.warning(STALLED_READER_COLLECTED) # <<<<<<<<<<<<<< + * if self._exception is None: + * self.set_exception(RuntimeError(STALLED_READER_COLLECTED)) +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ws_logger); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_warning); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_STALLED_READER_COLLECTED); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":173 + * self._stalled_reader = None + * ws_logger.warning(STALLED_READER_COLLECTED) + * if self._exception is None: # <<<<<<<<<<<<<< + * self.set_exception(RuntimeError(STALLED_READER_COLLECTED)) + * # Resuming the transport while a stash remains would admit +*/ + __pyx_t_1 = (__pyx_v_self->_exception == Py_None); + if (__pyx_t_1) { + + + /* "aiohttp/_websocket/reader_py.py":174 + * ws_logger.warning(STALLED_READER_COLLECTED) + * if self._exception is None: + * self.set_exception(RuntimeError(STALLED_READER_COLLECTED)) # <<<<<<<<<<<<<< + * # Resuming the transport while a stash remains would admit + * # another socket read into the tail for every couple of messages +*/ + __pyx_t_8 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_8); + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_STALLED_READER_COLLECTED); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_9}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_set_exception, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":173 + * self._stalled_reader = None + * ws_logger.warning(STALLED_READER_COLLECTED) + * if self._exception is None: # <<<<<<<<<<<<<< + * self.set_exception(RuntimeError(STALLED_READER_COLLECTED)) + * # Resuming the transport while a stash remains would admit +*/ + } + } + __pyx_L7:; + + /* "aiohttp/_websocket/reader_py.py":157 + * size = data.size + * self._size -= size + MSG_SIZE_OVERHEAD + * if self._stalled_reader is not None and self._size <= self._limit // 2: # <<<<<<<<<<<<<< + * # Resume parsing once the queue drains to the low-water mark. + * # Each resume re-slices the parser's unparsed tail, so waiting +*/ + } + + /* "aiohttp/_websocket/reader_py.py":179 + * # drained, moving the memory bound from the queue into the tail. + * if ( + * self._stalled_reader is None # <<<<<<<<<<<<<< + * and self._size < self._limit + * and self._protocol._reading_paused +*/ + __pyx_t_7 = (__pyx_v_self->_stalled_reader == Py_None); + if (__pyx_t_7) { + + } else { + + __pyx_t_1 = __pyx_t_7; + + goto __pyx_L10_bool_binop_done; + } + + /* "aiohttp/_websocket/reader_py.py":180 + * if ( + * self._stalled_reader is None + * and self._size < self._limit # <<<<<<<<<<<<<< + * and self._protocol._reading_paused + * ): +*/ + __pyx_t_7 = (__pyx_v_self->_size < __pyx_v_self->_limit); + + if (__pyx_t_7) { + + } else { + + __pyx_t_1 = __pyx_t_7; + + goto __pyx_L10_bool_binop_done; + } + + /* "aiohttp/_websocket/reader_py.py":181 + * self._stalled_reader is None + * and self._size < self._limit + * and self._protocol._reading_paused # <<<<<<<<<<<<<< + * ): + * self._protocol.resume_reading() +*/ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_protocol, __pyx_mstate_global->__pyx_n_u_reading_paused); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + __pyx_t_1 = __pyx_t_7; + + __pyx_L10_bool_binop_done:; + + /* "aiohttp/_websocket/reader_py.py":178 + * # another socket read into the tail for every couple of messages + * # drained, moving the memory bound from the queue into the tail. + * if ( # <<<<<<<<<<<<<< + * self._stalled_reader is None + * and self._size < self._limit +*/ + if (__pyx_t_1) { + + + /* "aiohttp/_websocket/reader_py.py":183 + * and self._protocol._reading_paused + * ): + * self._protocol.resume_reading() # <<<<<<<<<<<<<< + * return data + * if self._exception is not None: +*/ + __pyx_t_4 = __pyx_v_self->_protocol; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_resume_reading, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":178 + * # another socket read into the tail for every couple of messages + * # drained, moving the memory bound from the queue into the tail. + * if ( # <<<<<<<<<<<<<< + * self._stalled_reader is None + * and self._size < self._limit +*/ + } + + /* "aiohttp/_websocket/reader_py.py":184 + * ): + * self._protocol.resume_reading() + * return data # <<<<<<<<<<<<<< + * if self._exception is not None: + * raise self._exception +*/ + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __Pyx_INCREF(__pyx_v_data); + __pyx_r = __pyx_v_data; + } + __Pyx_XDECREF(__pyx_temp); + } + goto __pyx_L0; + + /* "aiohttp/_websocket/reader_py.py":153 + * + * def _read_from_buffer(self) -> WSMessage: + * if self._buffer: # <<<<<<<<<<<<<< + * data = self._get_buffer() + * size = data.size +*/ + } + + /* "aiohttp/_websocket/reader_py.py":185 + * self._protocol.resume_reading() + * return data + * if self._exception is not None: # <<<<<<<<<<<<<< + * raise self._exception + * raise EofStream +*/ + __pyx_t_1 = (__pyx_v_self->_exception != Py_None); + if (unlikely(__pyx_t_1)) { + + + /* "aiohttp/_websocket/reader_py.py":186 + * return data + * if self._exception is not None: + * raise self._exception # <<<<<<<<<<<<<< + * raise EofStream + * +*/ + __Pyx_Raise(__pyx_v_self->_exception, 0, 0, 0); + __PYX_ERR(0, 186, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":185 + * self._protocol.resume_reading() + * return data + * if self._exception is not None: # <<<<<<<<<<<<<< + * raise self._exception + * raise EofStream +*/ + } + + /* "aiohttp/_websocket/reader_py.py":187 + * if self._exception is not None: + * raise self._exception + * raise EofStream # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_EofStream); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 187, __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(0, 187, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":152 + * return self._read_from_buffer() + * + * def _read_from_buffer(self) -> WSMessage: # <<<<<<<<<<<<<< + * if self._buffer: + * data = self._get_buffer() +*/ + + /* 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_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketDataQueue._read_from_buffer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + + __Pyx_XDECREF(__pyx_v_data); + __Pyx_XDECREF(__pyx_v_reader); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "aiohttp/_websocket/reader_c.pxd":51 + * cdef class WebSocketDataQueue: + * + * cdef readonly unsigned int _size # <<<<<<<<<<<<<< + * cdef public object _protocol + * cdef readonly unsigned int _limit +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_5_size_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_5_size_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_5_size___get__(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_5_size___get__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + { + __Pyx_PyCriticalSection __pyx_cs; + __pyx_t_1 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_1); + __Pyx_PyCriticalSection_Begin(&__pyx_cs, (PyObject*)__pyx_t_1); + /*try:*/ { + __pyx_t_2 = __Pyx_PyLong_From_unsigned_int(__pyx_v_self->_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 51, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __pyx_r = __pyx_t_2; + } + __Pyx_XDECREF(__pyx_temp); + } + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L3_return; + } + /*finally:*/ { + __pyx_L3_return: { + __pyx_t_3 = __pyx_r; + __pyx_r = 0; + __Pyx_PyCriticalSection_End(&__pyx_cs); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + __pyx_L4_error: { + __Pyx_PyCriticalSection_End(&__pyx_cs); + goto __pyx_L1_error; + } + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketDataQueue._size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "aiohttp/_websocket/reader_c.pxd":52 + * + * cdef readonly unsigned int _size + * cdef public object _protocol # <<<<<<<<<<<<<< + * cdef readonly unsigned int _limit + * cdef object _loop +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol___get__(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol___get__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + { + __Pyx_PyCriticalSection __pyx_cs; + __pyx_t_1 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_1); + __Pyx_PyCriticalSection_Begin(&__pyx_cs, (PyObject*)__pyx_t_1); + /*try:*/ { + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __Pyx_INCREF(__pyx_v_self->_protocol); + __pyx_r = __pyx_v_self->_protocol; + } + __Pyx_XDECREF(__pyx_temp); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L3_return; + } + /*finally:*/ { + __pyx_L3_return: { + __pyx_t_2 = __pyx_r; + __pyx_r = 0; + __Pyx_PyCriticalSection_End(&__pyx_cs); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol_2__set__(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol_2__set__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + { + __Pyx_PyCriticalSection __pyx_cs; + __pyx_t_1 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_1); + __Pyx_PyCriticalSection_Begin(&__pyx_cs, (PyObject*)__pyx_t_1); + /*try:*/ { + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->_protocol); + __Pyx_DECREF(__pyx_v_self->_protocol); + __pyx_v_self->_protocol = __pyx_v_value; + } + /*finally:*/ { + /*normal exit:*/{ + __Pyx_PyCriticalSection_End(&__pyx_cs); + goto __pyx_L5; + } + __pyx_L5:; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* function exit code */ + __pyx_r = 0; + + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol_4__del__(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol_4__del__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__del__", 0); + { + __Pyx_PyCriticalSection __pyx_cs; + __pyx_t_1 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_1); + __Pyx_PyCriticalSection_Begin(&__pyx_cs, (PyObject*)__pyx_t_1); + /*try:*/ { + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_protocol); + __Pyx_DECREF(__pyx_v_self->_protocol); + __pyx_v_self->_protocol = Py_None; + } + /*finally:*/ { + /*normal exit:*/{ + __Pyx_PyCriticalSection_End(&__pyx_cs); + goto __pyx_L5; + } + __pyx_L5:; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* function exit code */ + __pyx_r = 0; + + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "aiohttp/_websocket/reader_c.pxd":53 + * cdef readonly unsigned int _size + * cdef public object _protocol + * cdef readonly unsigned int _limit # <<<<<<<<<<<<<< + * cdef object _loop + * cdef bint _eof +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_6_limit_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_6_limit_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_6_limit___get__(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_6_limit___get__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + { + __Pyx_PyCriticalSection __pyx_cs; + __pyx_t_1 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_1); + __Pyx_PyCriticalSection_Begin(&__pyx_cs, (PyObject*)__pyx_t_1); + /*try:*/ { + __pyx_t_2 = __Pyx_PyLong_From_unsigned_int(__pyx_v_self->_limit); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 53, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __pyx_r = __pyx_t_2; + } + __Pyx_XDECREF(__pyx_temp); + } + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L3_return; + } + /*finally:*/ { + __pyx_L3_return: { + __pyx_t_3 = __pyx_r; + __pyx_r = 0; + __Pyx_PyCriticalSection_End(&__pyx_cs); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + __pyx_L4_error: { + __Pyx_PyCriticalSection_End(&__pyx_cs); + goto __pyx_L1_error; + } + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketDataQueue._limit.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "aiohttp/_websocket/reader_c.pxd":58 + * cdef object _waiter + * cdef object _exception + * cdef public object _buffer # <<<<<<<<<<<<<< + * cdef object _get_buffer + * cdef object _put_buffer +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer___get__(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer___get__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + { + __Pyx_PyCriticalSection __pyx_cs; + __pyx_t_1 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_1); + __Pyx_PyCriticalSection_Begin(&__pyx_cs, (PyObject*)__pyx_t_1); + /*try:*/ { + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __Pyx_INCREF(__pyx_v_self->_buffer); + __pyx_r = __pyx_v_self->_buffer; + } + __Pyx_XDECREF(__pyx_temp); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L3_return; + } + /*finally:*/ { + __pyx_L3_return: { + __pyx_t_2 = __pyx_r; + __pyx_r = 0; + __Pyx_PyCriticalSection_End(&__pyx_cs); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer_2__set__(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer_2__set__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__set__", 0); + { + __Pyx_PyCriticalSection __pyx_cs; + __pyx_t_1 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_1); + __Pyx_PyCriticalSection_Begin(&__pyx_cs, (PyObject*)__pyx_t_1); + /*try:*/ { + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->_buffer); + __Pyx_DECREF(__pyx_v_self->_buffer); + __pyx_v_self->_buffer = __pyx_v_value; + } + /*finally:*/ { + /*normal exit:*/{ + __Pyx_PyCriticalSection_End(&__pyx_cs); + goto __pyx_L5; + } + __pyx_L5:; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* function exit code */ + __pyx_r = 0; + + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer_4__del__(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer_4__del__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__del__", 0); + { + __Pyx_PyCriticalSection __pyx_cs; + __pyx_t_1 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_1); + __Pyx_PyCriticalSection_Begin(&__pyx_cs, (PyObject*)__pyx_t_1); + /*try:*/ { + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_buffer); + __Pyx_DECREF(__pyx_v_self->_buffer); + __pyx_v_self->_buffer = Py_None; + } + /*finally:*/ { + /*normal exit:*/{ + __Pyx_PyCriticalSection_End(&__pyx_cs); + goto __pyx_L5; + } + __pyx_L5:; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* function exit code */ + __pyx_r = 0; + + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "aiohttp/_websocket/reader_c.pxd":61 + * cdef object _get_buffer + * cdef object _put_buffer + * cdef readonly object _stalled_reader # <<<<<<<<<<<<<< + * + * cdef void _release_waiter(self) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_15_stalled_reader_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_15_stalled_reader_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_15_stalled_reader___get__(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_15_stalled_reader___get__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + { + __Pyx_PyCriticalSection __pyx_cs; + __pyx_t_1 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_1); + __Pyx_PyCriticalSection_Begin(&__pyx_cs, (PyObject*)__pyx_t_1); + /*try:*/ { + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __Pyx_INCREF(__pyx_v_self->_stalled_reader); + __pyx_r = __pyx_v_self->_stalled_reader; + } + __Pyx_XDECREF(__pyx_temp); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L3_return; + } + /*finally:*/ { + __pyx_L3_return: { + __pyx_t_2 = __pyx_r; + __pyx_r = 0; + __Pyx_PyCriticalSection_End(&__pyx_cs); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_16__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_16__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_16__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_16__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_VECTORCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_VECTORCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_15__reduce_cython__(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_15__reduce_cython__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + 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_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * with CRITICAL_SECTION(self): # <<<<<<<<<<<<<< + * state = (self._buffer, self._eof, self._exception, self._get_buffer, self._limit, self._loop, self._protocol, self._put_buffer, self._size, self._stalled_reader, self._waiter) + * _dict = getattr(self, '__dict__', None) +*/ + { + __Pyx_PyCriticalSection __pyx_cs; + __pyx_t_1 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_1); + __Pyx_PyCriticalSection_Begin(&__pyx_cs, (PyObject*)__pyx_t_1); + /*try:*/ { + + /* "(tree fragment)":6 + * cdef bint use_setstate + * with CRITICAL_SECTION(self): + * state = (self._buffer, self._eof, self._exception, self._get_buffer, self._limit, self._loop, self._protocol, self._put_buffer, self._size, self._stalled_reader, self._waiter) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: +*/ + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->_eof); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_unsigned_int(__pyx_v_self->_limit); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyLong_From_unsigned_int(__pyx_v_self->_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(11); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_self->_buffer); + __Pyx_GIVEREF(__pyx_v_self->_buffer); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_self->_buffer) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_INCREF(__pyx_v_self->_exception); + __Pyx_GIVEREF(__pyx_v_self->_exception); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_self->_exception) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_INCREF(__pyx_v_self->_get_buffer); + __Pyx_GIVEREF(__pyx_v_self->_get_buffer); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_v_self->_get_buffer) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_t_3) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_INCREF(__pyx_v_self->_loop); + __Pyx_GIVEREF(__pyx_v_self->_loop); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, __pyx_v_self->_loop) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_INCREF(__pyx_v_self->_protocol); + __Pyx_GIVEREF(__pyx_v_self->_protocol); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, __pyx_v_self->_protocol) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_INCREF(__pyx_v_self->_put_buffer); + __Pyx_GIVEREF(__pyx_v_self->_put_buffer); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, __pyx_v_self->_put_buffer) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, __pyx_t_4) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_INCREF(__pyx_v_self->_stalled_reader); + __Pyx_GIVEREF(__pyx_v_self->_stalled_reader); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, __pyx_v_self->_stalled_reader) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_INCREF(__pyx_v_self->_waiter); + __Pyx_GIVEREF(__pyx_v_self->_waiter); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 10, __pyx_v_self->_waiter) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_v_state = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; + + /* "(tree fragment)":7 + * with CRITICAL_SECTION(self): + * state = (self._buffer, self._eof, self._exception, self._get_buffer, self._limit, self._loop, self._protocol, self._put_buffer, self._size, self._stalled_reader, self._waiter) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None and _dict: + * state += (_dict,) +*/ + __pyx_t_5 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 7, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_v__dict = __pyx_t_5; + __pyx_t_5 = 0; + } + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * with CRITICAL_SECTION(self): # <<<<<<<<<<<<<< + * state = (self._buffer, self._eof, self._exception, self._get_buffer, self._limit, self._loop, self._protocol, self._put_buffer, self._size, self._stalled_reader, self._waiter) + * _dict = getattr(self, '__dict__', None) +*/ + /*finally:*/ { + /*normal exit:*/{ + __Pyx_PyCriticalSection_End(&__pyx_cs); + goto __pyx_L5; + } + __pyx_L4_error: { + __Pyx_PyCriticalSection_End(&__pyx_cs); + goto __pyx_L1_error; + } + __pyx_L5:; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "(tree fragment)":8 + * state = (self._buffer, self._eof, self._exception, self._get_buffer, self._limit, self._loop, self._protocol, self._put_buffer, self._size, self._stalled_reader, self._waiter) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __pyx_t_7 = (__pyx_v__dict != Py_None); + if (__pyx_t_7) { + + } else { + + __pyx_t_6 = __pyx_t_7; + + goto __pyx_L7_bool_binop_done; + } + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v__dict); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 8, __pyx_L1_error) + + __pyx_t_6 = __pyx_t_7; + + __pyx_L7_bool_binop_done:; + if (__pyx_t_6) { + + + /* "(tree fragment)":9 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: +*/ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict) != (0)) __PYX_ERR(2, 9, __pyx_L1_error); + __pyx_t_5 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_5)); + __pyx_t_5 = 0; + + /* "(tree fragment)":10 + * if _dict is not None and _dict: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self._buffer is not None or self._exception is not None or self._get_buffer is not None or self._loop is not None or self._protocol is not None or self._put_buffer is not None or self._stalled_reader is not None or self._waiter is not None +*/ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":8 + * state = (self._buffer, self._eof, self._exception, self._get_buffer, self._limit, self._loop, self._protocol, self._put_buffer, self._size, self._stalled_reader, self._waiter) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L6; + } + + /* "(tree fragment)":12 + * use_setstate = True + * else: + * use_setstate = self._buffer is not None or self._exception is not None or self._get_buffer is not None or self._loop is not None or self._protocol is not None or self._put_buffer is not None or self._stalled_reader is not None or self._waiter is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_WebSocketDataQueue, (type(self), 0x7cbbcf5, None), state +*/ + /*else*/ { + __pyx_t_7 = (__pyx_v_self->_buffer != Py_None); + if (!__pyx_t_7) { + + } else { + + __pyx_t_6 = __pyx_t_7; + + goto __pyx_L9_bool_binop_done; + } + __pyx_t_7 = (__pyx_v_self->_exception != Py_None); + if (!__pyx_t_7) { + + } else { + + __pyx_t_6 = __pyx_t_7; + + goto __pyx_L9_bool_binop_done; + } + __pyx_t_7 = (__pyx_v_self->_get_buffer != Py_None); + if (!__pyx_t_7) { + + } else { + + __pyx_t_6 = __pyx_t_7; + + goto __pyx_L9_bool_binop_done; + } + __pyx_t_7 = (__pyx_v_self->_loop != Py_None); + if (!__pyx_t_7) { + + } else { + + __pyx_t_6 = __pyx_t_7; + + goto __pyx_L9_bool_binop_done; + } + __pyx_t_7 = (__pyx_v_self->_protocol != Py_None); + if (!__pyx_t_7) { + + } else { + + __pyx_t_6 = __pyx_t_7; + + goto __pyx_L9_bool_binop_done; + } + __pyx_t_7 = (__pyx_v_self->_put_buffer != Py_None); + if (!__pyx_t_7) { + + } else { + + __pyx_t_6 = __pyx_t_7; + + goto __pyx_L9_bool_binop_done; + } + __pyx_t_7 = (__pyx_v_self->_stalled_reader != Py_None); + if (!__pyx_t_7) { + + } else { + + __pyx_t_6 = __pyx_t_7; + + goto __pyx_L9_bool_binop_done; + } + __pyx_t_7 = (__pyx_v_self->_waiter != Py_None); + + __pyx_t_6 = __pyx_t_7; + + __pyx_L9_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_6; + } + __pyx_L6:; + + /* "(tree fragment)":13 + * else: + * use_setstate = self._buffer is not None or self._exception is not None or self._get_buffer is not None or self._loop is not None or self._protocol is not None or self._put_buffer is not None or self._stalled_reader is not None or self._waiter is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_WebSocketDataQueue, (type(self), 0x7cbbcf5, None), state + * else: +*/ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":14 + * use_setstate = self._buffer is not None or self._exception is not None or self._get_buffer is not None or self._loop is not None or self._protocol is not None or self._put_buffer is not None or self._stalled_reader is not None or self._waiter is not None + * if use_setstate: + * return __pyx_unpickle_WebSocketDataQueue, (type(self), 0x7cbbcf5, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_WebSocketDataQueue, (type(self), 0x7cbbcf5, state) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_WebSocketDataQueu); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(2, 14, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_130792693); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_130792693); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_130792693) != (0)) __PYX_ERR(2, 14, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None) != (0)) __PYX_ERR(2, 14, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(2, 14, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1) != (0)) __PYX_ERR(2, 14, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state) != (0)) __PYX_ERR(2, 14, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __pyx_r = __pyx_t_4; + } + __Pyx_XDECREF(__pyx_temp); + } + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":13 + * else: + * use_setstate = self._buffer is not None or self._exception is not None or self._get_buffer is not None or self._loop is not None or self._protocol is not None or self._put_buffer is not None or self._stalled_reader is not None or self._waiter is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_WebSocketDataQueue, (type(self), 0x7cbbcf5, None), state + * else: +*/ + } + + /* "(tree fragment)":16 + * return __pyx_unpickle_WebSocketDataQueue, (type(self), 0x7cbbcf5, None), state + * else: + * return __pyx_unpickle_WebSocketDataQueue, (type(self), 0x7cbbcf5, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_WebSocketDataQueue__set_state(self, __pyx_state) +*/ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_WebSocketDataQueu); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(2, 16, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_130792693); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_130792693); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_130792693) != (0)) __PYX_ERR(2, 16, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state) != (0)) __PYX_ERR(2, 16, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4) != (0)) __PYX_ERR(2, 16, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1) != (0)) __PYX_ERR(2, 16, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __pyx_r = __pyx_t_5; + } + __Pyx_XDECREF(__pyx_temp); + } + __pyx_t_5 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + + /* 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("aiohttp._websocket.reader_c.WebSocketDataQueue.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":17 + * else: + * return __pyx_unpickle_WebSocketDataQueue, (type(self), 0x7cbbcf5, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_WebSocketDataQueue__set_state(self, __pyx_state) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_18__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_18__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_18__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_18__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_VECTORCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_VECTORCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 17, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 17, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(2, 17, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(2, 17, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 17, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 17, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketDataQueue.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_17__setstate_cython__(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_17__setstate_cython__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":18 + * return __pyx_unpickle_WebSocketDataQueue, (type(self), 0x7cbbcf5, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_WebSocketDataQueue__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __pyx_t_1 = __pyx_v___pyx_state; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(2, 18, __pyx_L1_error) + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared \047not None\047"); + __PYX_ERR(2, 18, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_7aiohttp_10_websocket_8reader_c___pyx_unpickle_WebSocketDataQueue__set_state(__pyx_v_self, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 18, __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; + + /* "(tree fragment)":17 + * else: + * return __pyx_unpickle_WebSocketDataQueue, (type(self), 0x7cbbcf5, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_WebSocketDataQueue__set_state(self, __pyx_state) +*/ + + /* 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("aiohttp._websocket.reader_c.WebSocketDataQueue.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "aiohttp/_websocket/reader_py.py":191 + * + * class WebSocketReader: + * def __init__( # <<<<<<<<<<<<<< + * self, + * queue: WebSocketDataQueue, +*/ + +/* Python wrapper */ +static int __pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_1__init__(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL_TPNEW +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static int __pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_1__init__(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL_TPNEW +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_queue = 0; + PyObject *__pyx_v_max_msg_size = 0; + int __pyx_v_compress; + int __pyx_v_decode_text; + #if !CYTHON_VECTORCALL_TPNEW + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if !CYTHON_VECTORCALL_TPNEW + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL_TPNEW(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_queue,&__pyx_mstate_global->__pyx_n_u_max_msg_size,&__pyx_mstate_global->__pyx_n_u_compress,&__pyx_mstate_global->__pyx_n_u_decode_text,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL_TPNEW(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 191, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_FASTCALL_TPNEW(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 191, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL_TPNEW(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 191, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL_TPNEW(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 191, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL_TPNEW(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 191, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < (0)) __PYX_ERR(0, 191, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, i); __PYX_ERR(0, 191, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL_TPNEW(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 191, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL_TPNEW(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 191, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL_TPNEW(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 191, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL_TPNEW(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 191, __pyx_L3_error) + } + __pyx_v_queue = ((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)values[0]); + if (__Pyx_PyInt_FromNumber(&values[1], "max_msg_size", 0) < (0)) __PYX_ERR(0, 194, __pyx_L3_error) + __pyx_v_max_msg_size = ((PyObject*)values[1]); + __pyx_v_compress = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_compress == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 195, __pyx_L3_error) + __pyx_v_decode_text = __Pyx_PyObject_IsTrue(values[3]); if (unlikely((__pyx_v_decode_text == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 196, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 191, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketReader.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_queue), __pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, 0, "queue", 0))) __PYX_ERR(0, 193, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_max_msg_size), (&PyLong_Type), 0, "max_msg_size", 2))) __PYX_ERR(0, 194, __pyx_L1_error) + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader___init__(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *)__pyx_v_self), __pyx_v_queue, __pyx_v_max_msg_size, __pyx_v_compress, __pyx_v_decode_text); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + + + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader___init__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self, struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v_queue, PyObject *__pyx_v_max_msg_size, int __pyx_v_compress, int __pyx_v_decode_text) { + int __pyx_r; + __Pyx_RefNannyDeclarations + unsigned int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + Py_ssize_t __pyx_t_7; + int __pyx_t_8; + long __pyx_t_9; + int __pyx_t_10; + Py_ssize_t __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "aiohttp/_websocket/reader_py.py":198 + * decode_text: bool, + * ) -> None: + * self.queue = queue # <<<<<<<<<<<<<< + * self._max_msg_size = max_msg_size + * self._decode_text = decode_text +*/ + __Pyx_INCREF((PyObject *)__pyx_v_queue); + __Pyx_GIVEREF((PyObject *)__pyx_v_queue); + __Pyx_GOTREF((PyObject *)__pyx_v_self->queue); + __Pyx_DECREF((PyObject *)__pyx_v_self->queue); + __pyx_v_self->queue = __pyx_v_queue; + + /* "aiohttp/_websocket/reader_py.py":199 + * ) -> None: + * self.queue = queue + * self._max_msg_size = max_msg_size # <<<<<<<<<<<<<< + * self._decode_text = decode_text + * # Parked on the queue while parsing is stalled; created once so +*/ + __pyx_t_1 = __Pyx_PyLong_As_unsigned_int(__pyx_v_max_msg_size); if (unlikely((__pyx_t_1 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 199, __pyx_L1_error) + __pyx_v_self->_max_msg_size = __pyx_t_1; + + /* "aiohttp/_websocket/reader_py.py":200 + * self.queue = queue + * self._max_msg_size = max_msg_size + * self._decode_text = decode_text # <<<<<<<<<<<<<< + * # Parked on the queue while parsing is stalled; created once so + * # stalling does not allocate. +*/ + __pyx_v_self->_decode_text = __pyx_v_decode_text; + + /* "aiohttp/_websocket/reader_py.py":203 + * # Parked on the queue while parsing is stalled; created once so + * # stalling does not allocate. + * self._weak_self = weakref.ref(self) # <<<<<<<<<<<<<< + * + * self._exc: Exception | None = None +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_weakref); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ref); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->_weak_self); + __Pyx_DECREF(__pyx_v_self->_weak_self); + __pyx_v_self->_weak_self = __pyx_t_2; + __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":205 + * self._weak_self = weakref.ref(self) + * + * self._exc: Exception | None = None # <<<<<<<<<<<<<< + * self._partial = bytearray() + * self._state = READ_HEADER +*/ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_exc); + __Pyx_DECREF(__pyx_v_self->_exc); + __pyx_v_self->_exc = ((PyObject*)Py_None); + + /* "aiohttp/_websocket/reader_py.py":206 + * + * self._exc: Exception | None = None + * self._partial = bytearray() # <<<<<<<<<<<<<< + * self._state = READ_HEADER + * +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(&PyByteArray_Type), __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->_partial); + __Pyx_DECREF(__pyx_v_self->_partial); + __pyx_v_self->_partial = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":207 + * self._exc: Exception | None = None + * self._partial = bytearray() + * self._state = READ_HEADER # <<<<<<<<<<<<<< + * + * self._opcode: int = OP_CODE_NOT_SET +*/ + __pyx_v_self->_state = __pyx_v_7aiohttp_10_websocket_8reader_c_READ_HEADER; + + /* "aiohttp/_websocket/reader_py.py":209 + * self._state = READ_HEADER + * + * self._opcode: int = OP_CODE_NOT_SET # <<<<<<<<<<<<<< + * self._frame_fin = False + * self._frame_opcode: int = OP_CODE_NOT_SET +*/ + __pyx_v_self->_opcode = __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_NOT_SET; + + /* "aiohttp/_websocket/reader_py.py":210 + * + * self._opcode: int = OP_CODE_NOT_SET + * self._frame_fin = False # <<<<<<<<<<<<<< + * self._frame_opcode: int = OP_CODE_NOT_SET + * self._payload_fragments: list[bytes] = [] +*/ + __pyx_v_self->_frame_fin = 0; + + /* "aiohttp/_websocket/reader_py.py":211 + * self._opcode: int = OP_CODE_NOT_SET + * self._frame_fin = False + * self._frame_opcode: int = OP_CODE_NOT_SET # <<<<<<<<<<<<<< + * self._payload_fragments: list[bytes] = [] + * # Limit number of fragments, so a large number of tiny fragments +*/ + __pyx_v_self->_frame_opcode = __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_NOT_SET; + + /* "aiohttp/_websocket/reader_py.py":212 + * self._frame_fin = False + * self._frame_opcode: int = OP_CODE_NOT_SET + * self._payload_fragments: list[bytes] = [] # <<<<<<<<<<<<<< + * # Limit number of fragments, so a large number of tiny fragments + * # doesn't exceed reasonable memory usage. +*/ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->_payload_fragments); + __Pyx_DECREF(__pyx_v_self->_payload_fragments); + __pyx_v_self->_payload_fragments = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":215 + * # Limit number of fragments, so a large number of tiny fragments + * # doesn't exceed reasonable memory usage. + * self._max_fragments = max(1024, max_msg_size // 256) if max_msg_size else 0 # <<<<<<<<<<<<<< + * self._frame_payload_len = 0 + * +*/ + { + Py_ssize_t __pyx_temp = __Pyx_PyLong_IsNonZero(__pyx_v_max_msg_size); + if (unlikely(((!CYTHON_USE_PYLONG_INTERNALS) && __pyx_temp < 0))) __PYX_ERR(0, 215, __pyx_L1_error) + __pyx_t_8 = (__pyx_temp != 0); + } + + if (__pyx_t_8) { + __pyx_t_2 = __Pyx_PyLong_FloorDivideObjC(__pyx_v_max_msg_size, __pyx_mstate_global->__pyx_int_256, 0x100, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + __pyx_t_9 = 0x400; + __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = __Pyx_PyObject_CompareBoolGt_int_int(__pyx_t_2, __pyx_t_3, Py_GT); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_10) { + __Pyx_INCREF(__pyx_t_2); + __pyx_t_5 = __pyx_t_2; + } else { + __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_PyInt_FromNumber(&__pyx_t_3, NULL, 0) < (0)) __PYX_ERR(0, 215, __pyx_L1_error) + __pyx_t_5 = __pyx_t_3; + __pyx_t_3 = 0; + } + + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = __pyx_t_11; + } else { + + __pyx_t_7 = 0; + } + + __pyx_v_self->_max_fragments = __pyx_t_7; + + /* "aiohttp/_websocket/reader_py.py":216 + * # doesn't exceed reasonable memory usage. + * self._max_fragments = max(1024, max_msg_size // 256) if max_msg_size else 0 + * self._frame_payload_len = 0 # <<<<<<<<<<<<<< + * + * self._tail: bytes = b"" +*/ + __pyx_v_self->_frame_payload_len = 0; + + /* "aiohttp/_websocket/reader_py.py":218 + * self._frame_payload_len = 0 + * + * self._tail: bytes = b"" # <<<<<<<<<<<<<< + * self._has_mask = False + * self._frame_mask: bytes | None = None +*/ + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_b__3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_b__3); + __Pyx_GOTREF(__pyx_v_self->_tail); + __Pyx_DECREF(__pyx_v_self->_tail); + __pyx_v_self->_tail = __pyx_mstate_global->__pyx_kp_b__3; + + /* "aiohttp/_websocket/reader_py.py":219 + * + * self._tail: bytes = b"" + * self._has_mask = False # <<<<<<<<<<<<<< + * self._frame_mask: bytes | None = None + * self._payload_bytes_to_read = 0 +*/ + __pyx_v_self->_has_mask = 0; + + /* "aiohttp/_websocket/reader_py.py":220 + * self._tail: bytes = b"" + * self._has_mask = False + * self._frame_mask: bytes | None = None # <<<<<<<<<<<<<< + * self._payload_bytes_to_read = 0 + * self._payload_len_flag = 0 +*/ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_frame_mask); + __Pyx_DECREF(__pyx_v_self->_frame_mask); + __pyx_v_self->_frame_mask = ((PyObject*)Py_None); + + /* "aiohttp/_websocket/reader_py.py":221 + * self._has_mask = False + * self._frame_mask: bytes | None = None + * self._payload_bytes_to_read = 0 # <<<<<<<<<<<<<< + * self._payload_len_flag = 0 + * self._compressed: int = COMPRESSED_NOT_SET +*/ + __pyx_v_self->_payload_bytes_to_read = 0; + + /* "aiohttp/_websocket/reader_py.py":222 + * self._frame_mask: bytes | None = None + * self._payload_bytes_to_read = 0 + * self._payload_len_flag = 0 # <<<<<<<<<<<<<< + * self._compressed: int = COMPRESSED_NOT_SET + * self._decompressobj: ZLibDecompressor | None = None +*/ + __pyx_v_self->_payload_len_flag = 0; + + /* "aiohttp/_websocket/reader_py.py":223 + * self._payload_bytes_to_read = 0 + * self._payload_len_flag = 0 + * self._compressed: int = COMPRESSED_NOT_SET # <<<<<<<<<<<<<< + * self._decompressobj: ZLibDecompressor | None = None + * self._compress = compress +*/ + __pyx_v_self->_compressed = __pyx_v_7aiohttp_10_websocket_8reader_c_COMPRESSED_NOT_SET; + + /* "aiohttp/_websocket/reader_py.py":224 + * self._payload_len_flag = 0 + * self._compressed: int = COMPRESSED_NOT_SET + * self._decompressobj: ZLibDecompressor | None = None # <<<<<<<<<<<<<< + * self._compress = compress + * +*/ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_decompressobj); + __Pyx_DECREF(__pyx_v_self->_decompressobj); + __pyx_v_self->_decompressobj = Py_None; + + /* "aiohttp/_websocket/reader_py.py":225 + * self._compressed: int = COMPRESSED_NOT_SET + * self._decompressobj: ZLibDecompressor | None = None + * self._compress = compress # <<<<<<<<<<<<<< + * + * def feed_eof(self) -> None: +*/ + __pyx_v_self->_compress = __pyx_v_compress; + + /* "aiohttp/_websocket/reader_py.py":191 + * + * class WebSocketReader: + * def __init__( # <<<<<<<<<<<<<< + * self, + * queue: WebSocketDataQueue, +*/ + + /* function exit code */ + __pyx_r = 0; + 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("aiohttp._websocket.reader_c.WebSocketReader.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "aiohttp/_websocket/reader_py.py":227 + * self._compress = compress + * + * def feed_eof(self) -> None: # <<<<<<<<<<<<<< + * self.queue.feed_eof() + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_3feed_eof(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_8reader_c_15WebSocketReader_3feed_eof = {"feed_eof", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_3feed_eof, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_3feed_eof(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_VECTORCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("feed_eof (wrapper)", 0); + #if !CYTHON_VECTORCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("feed_eof", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("feed_eof", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_2feed_eof(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_2feed_eof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + size_t __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("feed_eof", 0); + + /* "aiohttp/_websocket/reader_py.py":228 + * + * def feed_eof(self) -> None: + * self.queue.feed_eof() # <<<<<<<<<<<<<< + * + * # data can be bytearray on Windows because proactor event loop uses bytearray +*/ + __pyx_t_2 = ((PyObject *)__pyx_v_self->queue); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_feed_eof, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":227 + * self._compress = compress + * + * def feed_eof(self) -> None: # <<<<<<<<<<<<<< + * self.queue.feed_eof() + * +*/ + + /* 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("aiohttp._websocket.reader_c.WebSocketReader.feed_eof", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "aiohttp/_websocket/reader_py.py":233 + * # and asyncio types this to Union[bytes, bytearray, memoryview] so we need + * # coerce data to bytes if it is not + * def feed_data(self, data: bytes | bytearray | memoryview) -> tuple[bool, bytes]: # <<<<<<<<<<<<<< + * if type(data) is not bytes: + * data = bytes(data) +*/ + +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_5feed_data(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_f_7aiohttp_10_websocket_8reader_c_15WebSocketReader_feed_data(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self, PyObject *__pyx_v_data, int __pyx_skip_dispatch) { + 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; + size_t __pyx_t_5; + int __pyx_t_6; + 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; + PyObject *__pyx_t_21 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("feed_data", 0); + __Pyx_INCREF(__pyx_v_data); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if ( + #if !CYTHON_USE_TYPE_SLOTS + unlikely(Py_TYPE(((PyObject *)__pyx_v_self)) != __pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader && + __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), Py_TPFLAGS_HAVE_GC)) + #else + unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0 || __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE))) + #endif + ) { + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; + if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { + PY_UINT64_T __pyx_typedict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); + #endif + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_feed_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!__Pyx_IsSameCFunction(__pyx_t_1, (void(*)(void)) __pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_5feed_data)) { + __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_data}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + if (!(likely(PyTuple_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_2))) __PYX_ERR(0, 233, __pyx_L1_error) + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __pyx_r = ((PyObject*)__pyx_t_2); + } + __Pyx_XDECREF(__pyx_temp); + } + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); + __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); + if (unlikely(__pyx_typedict_guard != __pyx_tp_dict_version)) { + __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; + } + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + } + #endif + } + + /* "aiohttp/_websocket/reader_py.py":234 + * # coerce data to bytes if it is not + * def feed_data(self, data: bytes | bytearray | memoryview) -> tuple[bool, bytes]: + * if type(data) is not bytes: # <<<<<<<<<<<<<< + * data = bytes(data) + * +*/ + __pyx_t_6 = (((PyObject *)Py_TYPE(__pyx_v_data)) != ((PyObject *)(&PyBytes_Type))); + if (__pyx_t_6) { + + + /* "aiohttp/_websocket/reader_py.py":235 + * def feed_data(self, data: bytes | bytearray | memoryview) -> tuple[bool, bytes]: + * if type(data) is not bytes: + * data = bytes(data) # <<<<<<<<<<<<<< + * + * if self._exc is not None: +*/ + __pyx_t_2 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_data}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(&PyBytes_Type), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF_SET(__pyx_v_data, __pyx_t_1); + __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":234 + * # coerce data to bytes if it is not + * def feed_data(self, data: bytes | bytearray | memoryview) -> tuple[bool, bytes]: + * if type(data) is not bytes: # <<<<<<<<<<<<<< + * data = bytes(data) + * +*/ + } + + /* "aiohttp/_websocket/reader_py.py":237 + * data = bytes(data) + * + * if self._exc is not None: # <<<<<<<<<<<<<< + * return True, data + * +*/ + __pyx_t_6 = (__pyx_v_self->_exc != ((PyObject*)Py_None)); + if (__pyx_t_6) { + + + /* "aiohttp/_websocket/reader_py.py":238 + * + * if self._exc is not None: + * return True, data # <<<<<<<<<<<<<< + * + * try: +*/ + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(Py_True); + __Pyx_GIVEREF(Py_True); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, Py_True) != (0)) __PYX_ERR(0, 238, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_data); + __Pyx_GIVEREF(__pyx_v_data); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_data) != (0)) __PYX_ERR(0, 238, __pyx_L1_error); + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __pyx_r = ((PyObject*)__pyx_t_1); + } + __Pyx_XDECREF(__pyx_temp); + } + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "aiohttp/_websocket/reader_py.py":237 + * data = bytes(data) + * + * if self._exc is not None: # <<<<<<<<<<<<<< + * return True, data + * +*/ + } + + /* "aiohttp/_websocket/reader_py.py":240 + * return True, data + * + * try: # <<<<<<<<<<<<<< + * self._feed_data(data) + * except Exception as exc: +*/ + { + __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:*/ { + + /* "aiohttp/_websocket/reader_py.py":241 + * + * try: + * self._feed_data(data) # <<<<<<<<<<<<<< + * except Exception as exc: + * self._exc = exc +*/ + __pyx_t_1 = __pyx_v_data; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyBytes_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_1))) __PYX_ERR(0, 241, __pyx_L5_error) + ((struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketReader *)__pyx_v_self->__pyx_vtab)->_feed_data(__pyx_v_self, ((PyObject*)__pyx_t_1), 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 241, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":240 + * return True, data + * + * try: # <<<<<<<<<<<<<< + * self._feed_data(data) + * except Exception as exc: +*/ + } + __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_L10_try_end; + __pyx_L5_error:; + __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; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "aiohttp/_websocket/reader_py.py":242 + * try: + * self._feed_data(data) + * except Exception as exc: # <<<<<<<<<<<<<< + * self._exc = exc + * set_exception(self.queue, exc) +*/ + __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_10) { + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketReader.feed_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_4) < 0) __PYX_ERR(0, 242, __pyx_L7_except_error) + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __pyx_v_exc = __pyx_t_2; + /*try:*/ { + + /* "aiohttp/_websocket/reader_py.py":243 + * self._feed_data(data) + * except Exception as exc: + * self._exc = exc # <<<<<<<<<<<<<< + * set_exception(self.queue, exc) + * return EMPTY_FRAME_ERROR +*/ + __Pyx_INCREF(__pyx_v_exc); + __Pyx_GIVEREF(__pyx_v_exc); + __Pyx_GOTREF(__pyx_v_self->_exc); + __Pyx_DECREF(__pyx_v_self->_exc); + __pyx_v_self->_exc = __pyx_v_exc; + + /* "aiohttp/_websocket/reader_py.py":244 + * except Exception as exc: + * self._exc = exc + * set_exception(self.queue, exc) # <<<<<<<<<<<<<< + * return EMPTY_FRAME_ERROR + * +*/ + __pyx_t_11 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_set_exception); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 244, __pyx_L16_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_11); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_11, ((PyObject *)__pyx_v_self->queue), __pyx_v_exc}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 244, __pyx_L16_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "aiohttp/_websocket/reader_py.py":245 + * self._exc = exc + * set_exception(self.queue, exc) + * return EMPTY_FRAME_ERROR # <<<<<<<<<<<<<< + * + * return EMPTY_FRAME +*/ + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __Pyx_INCREF(__pyx_v_7aiohttp_10_websocket_8reader_c_EMPTY_FRAME_ERROR); + __pyx_r = __pyx_v_7aiohttp_10_websocket_8reader_c_EMPTY_FRAME_ERROR; + } + __Pyx_XDECREF(__pyx_temp); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L15_return; + } + + /* "aiohttp/_websocket/reader_py.py":242 + * try: + * self._feed_data(data) + * except Exception as exc: # <<<<<<<<<<<<<< + * self._exc = exc + * set_exception(self.queue, exc) +*/ + /*finally:*/ { + __pyx_L16_error:; + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __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_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_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20); + if ( 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 = 0; + } + __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_L7_except_error; + } + __pyx_L15_return: { + __pyx_t_21 = __pyx_r; + __pyx_r = 0; + __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0; + __pyx_r = __pyx_t_21; + __pyx_t_21 = 0; + goto __pyx_L8_except_return; + } + } + } + goto __pyx_L7_except_error; + + /* "aiohttp/_websocket/reader_py.py":240 + * return True, data + * + * try: # <<<<<<<<<<<<<< + * self._feed_data(data) + * except Exception as exc: +*/ + __pyx_L7_except_error:; + __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_L8_except_return:; + __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_L10_try_end:; + } + + /* "aiohttp/_websocket/reader_py.py":247 + * return EMPTY_FRAME_ERROR + * + * return EMPTY_FRAME # <<<<<<<<<<<<<< + * + * def _handle_frame( +*/ + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __Pyx_INCREF(__pyx_v_7aiohttp_10_websocket_8reader_c_EMPTY_FRAME); + __pyx_r = __pyx_v_7aiohttp_10_websocket_8reader_c_EMPTY_FRAME; + } + __Pyx_XDECREF(__pyx_temp); + } + goto __pyx_L0; + + /* "aiohttp/_websocket/reader_py.py":233 + * # and asyncio types this to Union[bytes, bytearray, memoryview] so we need + * # coerce data to bytes if it is not + * def feed_data(self, data: bytes | bytearray | memoryview) -> tuple[bool, bytes]: # <<<<<<<<<<<<<< + * if type(data) is not bytes: + * data = bytes(data) +*/ + + /* 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_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketReader.feed_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_exc); + __Pyx_XDECREF(__pyx_v_data); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_5feed_data(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_8reader_c_15WebSocketReader_5feed_data = {"feed_data", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_5feed_data, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_5feed_data(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_data = 0; + #if !CYTHON_VECTORCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("feed_data (wrapper)", 0); + #if !CYTHON_VECTORCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_data,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 233, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "feed_data", 0) < (0)) __PYX_ERR(0, 233, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("feed_data", 1, 1, 1, i); __PYX_ERR(0, 233, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 233, __pyx_L3_error) + } + __pyx_v_data = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("feed_data", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 233, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketReader.feed_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_4feed_data(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *)__pyx_v_self), __pyx_v_data); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_4feed_data(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self, PyObject *__pyx_v_data) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("feed_data", 0); + __pyx_t_1 = __pyx_f_7aiohttp_10_websocket_8reader_c_15WebSocketReader_feed_data(__pyx_v_self, __pyx_v_data, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __pyx_r = __pyx_t_1; + } + __Pyx_XDECREF(__pyx_temp); + } + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketReader.feed_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "aiohttp/_websocket/reader_py.py":249 + * return EMPTY_FRAME + * + * def _handle_frame( # <<<<<<<<<<<<<< + * self, + * fin: bool, +*/ + +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_7_handle_frame(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static void __pyx_f_7aiohttp_10_websocket_8reader_c_15WebSocketReader__handle_frame(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self, int __pyx_v_fin, int __pyx_v_opcode, PyObject *__pyx_v_payload, int __pyx_v_compressed, int __pyx_skip_dispatch) { + int __pyx_v_has_partial; + PyObject *__pyx_v_payload_merged = 0; + PyObject *__pyx_v_msg = 0; + PyObject *__pyx_v_assembled_payload = 0; + PyObject *__pyx_v_exc = NULL; + Py_ssize_t __pyx_v_size; + PyObject *__pyx_v_text = NULL; + Py_ssize_t __pyx_v_payload_len; + PyObject *__pyx_v_close_code = NULL; + PyObject *__pyx_v_close_message = 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; + size_t __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + int __pyx_t_11; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + int __pyx_t_16; + char const *__pyx_t_17; + 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; + PyObject *__pyx_t_23 = NULL; + Py_ssize_t __pyx_t_24; + PyObject *__pyx_t_25[6]; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_handle_frame", 0); + + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if ( + #if !CYTHON_USE_TYPE_SLOTS + unlikely(Py_TYPE(((PyObject *)__pyx_v_self)) != __pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader && + __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), Py_TPFLAGS_HAVE_GC)) + #else + unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0 || __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE))) + #endif + ) { + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; + if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { + PY_UINT64_T __pyx_typedict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); + #endif + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_handle_frame); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!__Pyx_IsSameCFunction(__pyx_t_1, (void(*)(void)) __pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_7_handle_frame)) { + __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; + __pyx_t_5 = __Pyx_PyBool_FromLong(__pyx_v_fin); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_opcode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_compressed); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[5] = {__pyx_t_3, __pyx_t_5, __pyx_t_6, __pyx_v_payload, __pyx_t_7}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_8, (5-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + { + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); + __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); + if (unlikely(__pyx_typedict_guard != __pyx_tp_dict_version)) { + __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; + } + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + } + #endif + } + + /* "aiohttp/_websocket/reader_py.py":257 + * ) -> None: + * msg: WSMessage + * if opcode in {OP_CODE_TEXT, OP_CODE_BINARY, OP_CODE_CONTINUATION}: # <<<<<<<<<<<<<< + * # Validate continuation frames before processing + * if opcode == OP_CODE_CONTINUATION and self._opcode == OP_CODE_NOT_SET: +*/ + + __pyx_t_9 = __pyx_v_opcode; + __pyx_t_11 = (__pyx_t_9 == __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_TEXT); + + if (!__pyx_t_11) { + + } else { + + __pyx_t_10 = __pyx_t_11; + + goto __pyx_L4_bool_binop_done; + } + __pyx_t_11 = (__pyx_t_9 == __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_BINARY); + + if (!__pyx_t_11) { + + } else { + + __pyx_t_10 = __pyx_t_11; + + goto __pyx_L4_bool_binop_done; + } + __pyx_t_11 = (__pyx_t_9 == __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_CONTINUATION); + + + __pyx_t_10 = __pyx_t_11; + + __pyx_L4_bool_binop_done:; + __pyx_t_11 = __pyx_t_10; + + + if (__pyx_t_11) { + + + /* "aiohttp/_websocket/reader_py.py":259 + * if opcode in {OP_CODE_TEXT, OP_CODE_BINARY, OP_CODE_CONTINUATION}: + * # Validate continuation frames before processing + * if opcode == OP_CODE_CONTINUATION and self._opcode == OP_CODE_NOT_SET: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, +*/ + __pyx_t_10 = (__pyx_v_opcode == __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_CONTINUATION); + + if (__pyx_t_10) { + + } else { + + __pyx_t_11 = __pyx_t_10; + + goto __pyx_L8_bool_binop_done; + } + __pyx_t_10 = (__pyx_v_self->_opcode == __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_NOT_SET); + + + __pyx_t_11 = __pyx_t_10; + + __pyx_L8_bool_binop_done:; + if (unlikely(__pyx_t_11)) { + + + /* "aiohttp/_websocket/reader_py.py":260 + * # Validate continuation frames before processing + * if opcode == OP_CODE_CONTINUATION and self._opcode == OP_CODE_NOT_SET: + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.PROTOCOL_ERROR, + * "Continuation frame for non started message", +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "aiohttp/_websocket/reader_py.py":261 + * if opcode == OP_CODE_CONTINUATION and self._opcode == OP_CODE_NOT_SET: + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, # <<<<<<<<<<<<<< + * "Continuation frame for non started message", + * ) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_PROTOCOL_ERROR); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_6, __pyx_mstate_global->__pyx_kp_u_Continuation_frame_for_non_start}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 260, __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(0, 260, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":259 + * if opcode in {OP_CODE_TEXT, OP_CODE_BINARY, OP_CODE_CONTINUATION}: + * # Validate continuation frames before processing + * if opcode == OP_CODE_CONTINUATION and self._opcode == OP_CODE_NOT_SET: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, +*/ + } + + /* "aiohttp/_websocket/reader_py.py":266 + * + * # load text/binary + * if not fin: # <<<<<<<<<<<<<< + * # got partial frame payload + * if opcode != OP_CODE_CONTINUATION: +*/ + __pyx_t_11 = (!__pyx_v_fin); + + if (__pyx_t_11) { + + + /* "aiohttp/_websocket/reader_py.py":268 + * if not fin: + * # got partial frame payload + * if opcode != OP_CODE_CONTINUATION: # <<<<<<<<<<<<<< + * self._opcode = opcode + * self._partial += payload +*/ + __pyx_t_11 = (__pyx_v_opcode != __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_CONTINUATION); + + if (__pyx_t_11) { + + + /* "aiohttp/_websocket/reader_py.py":269 + * # got partial frame payload + * if opcode != OP_CODE_CONTINUATION: + * self._opcode = opcode # <<<<<<<<<<<<<< + * self._partial += payload + * return +*/ + __pyx_v_self->_opcode = __pyx_v_opcode; + + /* "aiohttp/_websocket/reader_py.py":268 + * if not fin: + * # got partial frame payload + * if opcode != OP_CODE_CONTINUATION: # <<<<<<<<<<<<<< + * self._opcode = opcode + * self._partial += payload +*/ + } + + /* "aiohttp/_websocket/reader_py.py":270 + * if opcode != OP_CODE_CONTINUATION: + * self._opcode = opcode + * self._partial += payload # <<<<<<<<<<<<<< + * return + * +*/ + __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_self->_partial, __pyx_v_payload); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyByteArray_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytearray", __pyx_t_1))) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_partial); + __Pyx_DECREF(__pyx_v_self->_partial); + __pyx_v_self->_partial = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":271 + * self._opcode = opcode + * self._partial += payload + * return # <<<<<<<<<<<<<< + * + * has_partial = bool(self._partial) +*/ + { + } + goto __pyx_L0; + + /* "aiohttp/_websocket/reader_py.py":266 + * + * # load text/binary + * if not fin: # <<<<<<<<<<<<<< + * # got partial frame payload + * if opcode != OP_CODE_CONTINUATION: +*/ + } + + /* "aiohttp/_websocket/reader_py.py":273 + * return + * + * has_partial = bool(self._partial) # <<<<<<<<<<<<<< + * if opcode == OP_CODE_CONTINUATION: + * opcode = self._opcode +*/ + if (__pyx_v_self->_partial == Py_None) __pyx_t_11 = 0; + else + { + Py_ssize_t __pyx_temp = __Pyx_PyByteArray_GET_SIZE(__pyx_v_self->_partial); + if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 273, __pyx_L1_error) + __pyx_t_11 = (__pyx_temp != 0); + } + + __pyx_v_has_partial = (!(!__pyx_t_11)); + + + /* "aiohttp/_websocket/reader_py.py":274 + * + * has_partial = bool(self._partial) + * if opcode == OP_CODE_CONTINUATION: # <<<<<<<<<<<<<< + * opcode = self._opcode + * self._opcode = OP_CODE_NOT_SET +*/ + __pyx_t_11 = (__pyx_v_opcode == __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_CONTINUATION); + + if (__pyx_t_11) { + + + /* "aiohttp/_websocket/reader_py.py":275 + * has_partial = bool(self._partial) + * if opcode == OP_CODE_CONTINUATION: + * opcode = self._opcode # <<<<<<<<<<<<<< + * self._opcode = OP_CODE_NOT_SET + * # previous frame was non finished +*/ + __pyx_t_9 = __pyx_v_self->_opcode; + + __pyx_v_opcode = __pyx_t_9; + + /* "aiohttp/_websocket/reader_py.py":276 + * if opcode == OP_CODE_CONTINUATION: + * opcode = self._opcode + * self._opcode = OP_CODE_NOT_SET # <<<<<<<<<<<<<< + * # previous frame was non finished + * # we should get continuation opcode +*/ + __pyx_v_self->_opcode = __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_NOT_SET; + + /* "aiohttp/_websocket/reader_py.py":274 + * + * has_partial = bool(self._partial) + * if opcode == OP_CODE_CONTINUATION: # <<<<<<<<<<<<<< + * opcode = self._opcode + * self._opcode = OP_CODE_NOT_SET +*/ + goto __pyx_L12; + } + + /* "aiohttp/_websocket/reader_py.py":279 + * # previous frame was non finished + * # we should get continuation opcode + * elif has_partial: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, +*/ + if (unlikely(__pyx_v_has_partial)) { + + /* "aiohttp/_websocket/reader_py.py":280 + * # we should get continuation opcode + * elif has_partial: + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.PROTOCOL_ERROR, + * "The opcode in non-fin frame is expected " +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 280, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "aiohttp/_websocket/reader_py.py":281 + * elif has_partial: + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, # <<<<<<<<<<<<<< + * "The opcode in non-fin frame is expected " + * f"to be zero, got {opcode!r}", +*/ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_PROTOCOL_ERROR); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":283 + * WSCloseCode.PROTOCOL_ERROR, + * "The opcode in non-fin frame is expected " + * f"to be zero, got {opcode!r}", # <<<<<<<<<<<<<< + * ) + * +*/ + __pyx_t_2 = __Pyx_PyUnicode_From_int(__pyx_v_opcode, 0, ' ', 'd'); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "aiohttp/_websocket/reader_py.py":282 + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, + * "The opcode in non-fin frame is expected " # <<<<<<<<<<<<<< + * f"to be zero, got {opcode!r}", + * ) +*/ + __pyx_t_5 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_The_opcode_in_non_fin_frame_is_e, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 280, __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(0, 280, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":279 + * # previous frame was non finished + * # we should get continuation opcode + * elif has_partial: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, +*/ + } + __pyx_L12:; + + /* "aiohttp/_websocket/reader_py.py":287 + * + * assembled_payload: bytes | bytearray + * if has_partial: # <<<<<<<<<<<<<< + * assembled_payload = self._partial + payload + * self._partial.clear() +*/ + if (__pyx_v_has_partial) { + + /* "aiohttp/_websocket/reader_py.py":288 + * assembled_payload: bytes | bytearray + * if has_partial: + * assembled_payload = self._partial + payload # <<<<<<<<<<<<<< + * self._partial.clear() + * else: +*/ + __pyx_t_1 = PyNumber_Add(__pyx_v_self->_partial, __pyx_v_payload); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_assembled_payload = __pyx_t_1; + __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":289 + * if has_partial: + * assembled_payload = self._partial + payload + * self._partial.clear() # <<<<<<<<<<<<<< + * else: + * assembled_payload = payload +*/ + __pyx_t_6 = __pyx_v_self->_partial; + __Pyx_INCREF(__pyx_t_6); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_clear, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":287 + * + * assembled_payload: bytes | bytearray + * if has_partial: # <<<<<<<<<<<<<< + * assembled_payload = self._partial + payload + * self._partial.clear() +*/ + goto __pyx_L13; + } + + /* "aiohttp/_websocket/reader_py.py":291 + * self._partial.clear() + * else: + * assembled_payload = payload # <<<<<<<<<<<<<< + * + * # Decompress process must to be done after all packets +*/ + /*else*/ { + __Pyx_INCREF(__pyx_v_payload); + __pyx_v_assembled_payload = __pyx_v_payload; + } + __pyx_L13:; + + /* "aiohttp/_websocket/reader_py.py":295 + * # Decompress process must to be done after all packets + * # received. + * if compressed: # <<<<<<<<<<<<<< + * if not self._decompressobj: + * self._decompressobj = ZLibDecompressor(suppress_deflate_header=True) +*/ + __pyx_t_11 = (__pyx_v_compressed != 0); + + if (__pyx_t_11) { + + + /* "aiohttp/_websocket/reader_py.py":296 + * # received. + * if compressed: + * if not self._decompressobj: # <<<<<<<<<<<<<< + * self._decompressobj = ZLibDecompressor(suppress_deflate_header=True) + * # XXX: It's possible that the zlib backend (isal is known to +*/ + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_self->_decompressobj); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 296, __pyx_L1_error) + __pyx_t_10 = (!__pyx_t_11); + + + if (__pyx_t_10) { + + + /* "aiohttp/_websocket/reader_py.py":297 + * if compressed: + * if not self._decompressobj: + * self._decompressobj = ZLibDecompressor(suppress_deflate_header=True) # <<<<<<<<<<<<<< + * # XXX: It's possible that the zlib backend (isal is known to + * # do this, maybe others too?) will return max_length bytes, +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ZLibDecompressor); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, Py_True}; + #if CYTHON_VECTORCALL + __pyx_t_7 = __pyx_mstate_global->__pyx_tuple[0]; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_INCREF(__pyx_t_7); + #else + { + PyObject *__pyx_temp[1] = {__pyx_mstate_global->__pyx_n_u_suppress_deflate_header}; + __pyx_t_7 = __Pyx_MakeKwargDict(__pyx_temp, __pyx_callargs+1, 1); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + #endif + __pyx_t_1 = __Pyx_Object_VectorcallKwds((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_decompressobj); + __Pyx_DECREF(__pyx_v_self->_decompressobj); + __pyx_v_self->_decompressobj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":296 + * # received. + * if compressed: + * if not self._decompressobj: # <<<<<<<<<<<<<< + * self._decompressobj = ZLibDecompressor(suppress_deflate_header=True) + * # XXX: It's possible that the zlib backend (isal is known to +*/ + } + + /* "aiohttp/_websocket/reader_py.py":303 + * # >max_length, so we return one extra byte and if we're able + * # to do that, then the message is too big. + * try: # <<<<<<<<<<<<<< + * payload_merged = self._decompressobj.decompress_sync( + * assembled_payload + WS_DEFLATE_TRAILING, +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_14); + /*try:*/ { + + /* "aiohttp/_websocket/reader_py.py":304 + * # to do that, then the message is too big. + * try: + * payload_merged = self._decompressobj.decompress_sync( # <<<<<<<<<<<<<< + * assembled_payload + WS_DEFLATE_TRAILING, + * ( +*/ + __pyx_t_5 = __pyx_v_self->_decompressobj; + __Pyx_INCREF(__pyx_t_5); + + /* "aiohttp/_websocket/reader_py.py":305 + * try: + * payload_merged = self._decompressobj.decompress_sync( + * assembled_payload + WS_DEFLATE_TRAILING, # <<<<<<<<<<<<<< + * ( + * self._max_msg_size + 1 +*/ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_WS_DEFLATE_TRAILING); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 305, __pyx_L16_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyNumber_Add_object_object(__pyx_v_assembled_payload, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 305, __pyx_L16_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "aiohttp/_websocket/reader_py.py":308 + * ( + * self._max_msg_size + 1 + * if self._max_msg_size # <<<<<<<<<<<<<< + * else self._max_msg_size + * ), +*/ + __pyx_t_10 = (__pyx_v_self->_max_msg_size != 0); + + if (__pyx_t_10) { + + /* "aiohttp/_websocket/reader_py.py":307 + * assembled_payload + WS_DEFLATE_TRAILING, + * ( + * self._max_msg_size + 1 # <<<<<<<<<<<<<< + * if self._max_msg_size + * else self._max_msg_size +*/ + __pyx_t_4 = __Pyx_PyLong_From_long((__pyx_v_self->_max_msg_size + 1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 307, __pyx_L16_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __pyx_t_4; + __pyx_t_4 = 0; + } else { + + /* "aiohttp/_websocket/reader_py.py":309 + * self._max_msg_size + 1 + * if self._max_msg_size + * else self._max_msg_size # <<<<<<<<<<<<<< + * ), + * ) +*/ + __pyx_t_4 = __Pyx_PyLong_From_unsigned_int(__pyx_v_self->_max_msg_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 309, __pyx_L16_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __pyx_t_4; + __pyx_t_4 = 0; + } + + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_6, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_decompress_sync, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 304, __pyx_L16_error) + __Pyx_GOTREF(__pyx_t_1); + } + + /* "aiohttp/_websocket/reader_py.py":304 + * # to do that, then the message is too big. + * try: + * payload_merged = self._decompressobj.decompress_sync( # <<<<<<<<<<<<<< + * assembled_payload + WS_DEFLATE_TRAILING, + * ( +*/ + if (!(likely(PyBytes_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_1))) __PYX_ERR(0, 304, __pyx_L16_error) + __pyx_v_payload_merged = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":303 + * # >max_length, so we return one extra byte and if we're able + * # to do that, then the message is too big. + * try: # <<<<<<<<<<<<<< + * payload_merged = self._decompressobj.decompress_sync( + * assembled_payload + WS_DEFLATE_TRAILING, +*/ + } + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + goto __pyx_L21_try_end; + __pyx_L16_error:; + __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; + __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; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "aiohttp/_websocket/reader_py.py":312 + * ), + * ) + * except TooManyMembersError as exc: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, +*/ + __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_7, &__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_TooManyMembersError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 312, __pyx_L18_except_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_ErrRestore(__pyx_t_1, __pyx_t_7, __pyx_t_6); + __pyx_t_1 = 0; __pyx_t_7 = 0; __pyx_t_6 = 0; + if (__pyx_t_9) { + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketReader._handle_frame", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_1) < 0) __PYX_ERR(0, 312, __pyx_L18_except_error) + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_7); + __pyx_v_exc = __pyx_t_7; + /*try:*/ { + + /* "aiohttp/_websocket/reader_py.py":313 + * ) + * except TooManyMembersError as exc: + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.MESSAGE_TOO_BIG, + * "Compressed message has too many deflate members", +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 313, __pyx_L27_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "aiohttp/_websocket/reader_py.py":314 + * except TooManyMembersError as exc: + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, # <<<<<<<<<<<<<< + * "Compressed message has too many deflate members", + * ) from exc +*/ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 314, __pyx_L27_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MESSAGE_TOO_BIG); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 314, __pyx_L27_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_15, __pyx_mstate_global->__pyx_kp_u_Compressed_message_has_too_many}; + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_2, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 313, __pyx_L27_error) + __Pyx_GOTREF(__pyx_t_5); + } + + /* "aiohttp/_websocket/reader_py.py":316 + * WSCloseCode.MESSAGE_TOO_BIG, + * "Compressed message has too many deflate members", + * ) from exc # <<<<<<<<<<<<<< + * if self._max_msg_size and len(payload_merged) > self._max_msg_size: + * raise WebSocketError( +*/ + __Pyx_Raise(__pyx_t_5, 0, 0, __pyx_v_exc); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 313, __pyx_L27_error) + } + + /* "aiohttp/_websocket/reader_py.py":312 + * ), + * ) + * except TooManyMembersError as exc: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, +*/ + /*finally:*/ { + __pyx_L27_error:; + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __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; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_ExceptionSwap(&__pyx_t_21, &__pyx_t_22, &__pyx_t_23); + if ( unlikely(__Pyx_GetException(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20) < 0)) __Pyx_ErrFetch(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20); + __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_XGOTREF(__pyx_t_23); + __pyx_t_9 = __pyx_lineno; __pyx_t_16 = __pyx_clineno; __pyx_t_17 = __pyx_filename; + { + __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0; + } + __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_18); + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_ErrRestore(__pyx_t_18, __pyx_t_19, __pyx_t_20); + __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; + __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_16; __pyx_filename = __pyx_t_17; + goto __pyx_L18_except_error; + } + } + } + goto __pyx_L18_except_error; + + /* "aiohttp/_websocket/reader_py.py":303 + * # >max_length, so we return one extra byte and if we're able + * # to do that, then the message is too big. + * try: # <<<<<<<<<<<<<< + * payload_merged = self._decompressobj.decompress_sync( + * assembled_payload + WS_DEFLATE_TRAILING, +*/ + __pyx_L18_except_error:; + __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); + goto __pyx_L1_error; + __pyx_L21_try_end:; + } + + /* "aiohttp/_websocket/reader_py.py":317 + * "Compressed message has too many deflate members", + * ) from exc + * if self._max_msg_size and len(payload_merged) > self._max_msg_size: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, +*/ + __pyx_t_11 = (__pyx_v_self->_max_msg_size != 0); + + if (__pyx_t_11) { + + } else { + + __pyx_t_10 = __pyx_t_11; + + goto __pyx_L34_bool_binop_done; + } + if (unlikely(__pyx_v_payload_merged == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type \047NoneType\047 has no len()"); + __PYX_ERR(0, 317, __pyx_L1_error) + } + __pyx_t_24 = __Pyx_PyBytes_GET_SIZE(__pyx_v_payload_merged); if (unlikely(__pyx_t_24 == ((Py_ssize_t)-1))) __PYX_ERR(0, 317, __pyx_L1_error) + __pyx_t_11 = (__pyx_t_24 > __pyx_v_self->_max_msg_size); + + + + __pyx_t_10 = __pyx_t_11; + + __pyx_L34_bool_binop_done:; + if (unlikely(__pyx_t_10)) { + + + /* "aiohttp/_websocket/reader_py.py":318 + * ) from exc + * if self._max_msg_size and len(payload_merged) > self._max_msg_size: + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.MESSAGE_TOO_BIG, + * f"Decompressed message exceeds size limit {self._max_msg_size}", +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "aiohttp/_websocket/reader_py.py":319 + * if self._max_msg_size and len(payload_merged) > self._max_msg_size: + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, # <<<<<<<<<<<<<< + * f"Decompressed message exceeds size limit {self._max_msg_size}", + * ) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_MESSAGE_TOO_BIG); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "aiohttp/_websocket/reader_py.py":320 + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, + * f"Decompressed message exceeds size limit {self._max_msg_size}", # <<<<<<<<<<<<<< + * ) + * elif type(assembled_payload) is bytes: +*/ + __pyx_t_5 = __Pyx_PyUnicode_From_unsigned_int(__pyx_v_self->_max_msg_size, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 320, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_15 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Decompressed_message_exceeds_siz, __pyx_t_5); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 320, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_2, __pyx_t_15}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 318, __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(0, 318, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":317 + * "Compressed message has too many deflate members", + * ) from exc + * if self._max_msg_size and len(payload_merged) > self._max_msg_size: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, +*/ + } + + /* "aiohttp/_websocket/reader_py.py":295 + * # Decompress process must to be done after all packets + * # received. + * if compressed: # <<<<<<<<<<<<<< + * if not self._decompressobj: + * self._decompressobj = ZLibDecompressor(suppress_deflate_header=True) +*/ + goto __pyx_L14; + } + + /* "aiohttp/_websocket/reader_py.py":322 + * f"Decompressed message exceeds size limit {self._max_msg_size}", + * ) + * elif type(assembled_payload) is bytes: # <<<<<<<<<<<<<< + * payload_merged = assembled_payload + * else: +*/ + __pyx_t_10 = (((PyObject *)Py_TYPE(__pyx_v_assembled_payload)) == ((PyObject *)(&PyBytes_Type))); + if (__pyx_t_10) { + + + /* "aiohttp/_websocket/reader_py.py":323 + * ) + * elif type(assembled_payload) is bytes: + * payload_merged = assembled_payload # <<<<<<<<<<<<<< + * else: + * payload_merged = bytes(assembled_payload) +*/ + __pyx_t_1 = __pyx_v_assembled_payload; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyBytes_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_1))) __PYX_ERR(0, 323, __pyx_L1_error) + __pyx_v_payload_merged = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":322 + * f"Decompressed message exceeds size limit {self._max_msg_size}", + * ) + * elif type(assembled_payload) is bytes: # <<<<<<<<<<<<<< + * payload_merged = assembled_payload + * else: +*/ + goto __pyx_L14; + } + + /* "aiohttp/_websocket/reader_py.py":325 + * payload_merged = assembled_payload + * else: + * payload_merged = bytes(assembled_payload) # <<<<<<<<<<<<<< + * + * size = len(payload_merged) +*/ + /*else*/ { + __pyx_t_6 = NULL; + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_assembled_payload}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(&PyBytes_Type), __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_payload_merged = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + } + __pyx_L14:; + + /* "aiohttp/_websocket/reader_py.py":327 + * payload_merged = bytes(assembled_payload) + * + * size = len(payload_merged) # <<<<<<<<<<<<<< + * if opcode == OP_CODE_TEXT: + * if self._decode_text: +*/ + if (unlikely(__pyx_v_payload_merged == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type \047NoneType\047 has no len()"); + __PYX_ERR(0, 327, __pyx_L1_error) + } + __pyx_t_24 = __Pyx_PyBytes_GET_SIZE(__pyx_v_payload_merged); if (unlikely(__pyx_t_24 == ((Py_ssize_t)-1))) __PYX_ERR(0, 327, __pyx_L1_error) + __pyx_v_size = __pyx_t_24; + + /* "aiohttp/_websocket/reader_py.py":328 + * + * size = len(payload_merged) + * if opcode == OP_CODE_TEXT: # <<<<<<<<<<<<<< + * if self._decode_text: + * try: +*/ + __pyx_t_10 = (__pyx_v_opcode == __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_TEXT); + + if (__pyx_t_10) { + + + /* "aiohttp/_websocket/reader_py.py":329 + * size = len(payload_merged) + * if opcode == OP_CODE_TEXT: + * if self._decode_text: # <<<<<<<<<<<<<< + * try: + * text = payload_merged.decode("utf-8") +*/ + if (__pyx_v_self->_decode_text) { + + /* "aiohttp/_websocket/reader_py.py":330 + * if opcode == OP_CODE_TEXT: + * if self._decode_text: + * try: # <<<<<<<<<<<<<< + * text = payload_merged.decode("utf-8") + * except UnicodeDecodeError as exc: +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_14, &__pyx_t_13, &__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_12); + /*try:*/ { + + /* "aiohttp/_websocket/reader_py.py":331 + * if self._decode_text: + * try: + * text = payload_merged.decode("utf-8") # <<<<<<<<<<<<<< + * except UnicodeDecodeError as exc: + * raise WebSocketError( +*/ + if (unlikely(__pyx_v_payload_merged == Py_None)) { + PyErr_Format(PyExc_AttributeError, "\047NoneType\047 object has no attribute \047%.30s\047", "decode"); + __PYX_ERR(0, 331, __pyx_L38_error) + } + __pyx_t_1 = __Pyx_decode_bytes(__pyx_v_payload_merged, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 331, __pyx_L38_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_text = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":330 + * if opcode == OP_CODE_TEXT: + * if self._decode_text: + * try: # <<<<<<<<<<<<<< + * text = payload_merged.decode("utf-8") + * except UnicodeDecodeError as exc: +*/ + } + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + goto __pyx_L43_try_end; + __pyx_L38_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __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; + __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; + + /* "aiohttp/_websocket/reader_py.py":332 + * try: + * text = payload_merged.decode("utf-8") + * except UnicodeDecodeError as exc: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message" +*/ + __pyx_t_16 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_UnicodeDecodeError)))); + if (__pyx_t_16) { + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketReader._handle_frame", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_6, &__pyx_t_15) < 0) __PYX_ERR(0, 332, __pyx_L40_except_error) + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_INCREF(__pyx_t_6); + __pyx_v_exc = ((PyObject*)__pyx_t_6); + /*try:*/ { + + /* "aiohttp/_websocket/reader_py.py":333 + * text = payload_merged.decode("utf-8") + * except UnicodeDecodeError as exc: + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message" + * ) from exc +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 333, __pyx_L49_error) + __Pyx_GOTREF(__pyx_t_5); + + /* "aiohttp/_websocket/reader_py.py":334 + * except UnicodeDecodeError as exc: + * raise WebSocketError( + * WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message" # <<<<<<<<<<<<<< + * ) from exc + * +*/ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 334, __pyx_L49_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_INVALID_TEXT); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 334, __pyx_L49_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Invalid_UTF_8_text_message}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 333, __pyx_L49_error) + __Pyx_GOTREF(__pyx_t_2); + } + + /* "aiohttp/_websocket/reader_py.py":335 + * raise WebSocketError( + * WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message" + * ) from exc # <<<<<<<<<<<<<< + * + * # XXX: The Text and Binary messages here can be a performance +*/ + __Pyx_Raise(__pyx_t_2, 0, 0, __pyx_v_exc); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 333, __pyx_L49_error) + } + + /* "aiohttp/_websocket/reader_py.py":332 + * try: + * text = payload_merged.decode("utf-8") + * except UnicodeDecodeError as exc: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message" +*/ + /*finally:*/ { + __pyx_L49_error:; + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __pyx_t_23 = 0; __pyx_t_22 = 0; __pyx_t_21 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; + __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; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_19, &__pyx_t_18); + if ( unlikely(__Pyx_GetException(&__pyx_t_23, &__pyx_t_22, &__pyx_t_21) < 0)) __Pyx_ErrFetch(&__pyx_t_23, &__pyx_t_22, &__pyx_t_21); + __Pyx_XGOTREF(__pyx_t_23); + __Pyx_XGOTREF(__pyx_t_22); + __Pyx_XGOTREF(__pyx_t_21); + __Pyx_XGOTREF(__pyx_t_20); + __Pyx_XGOTREF(__pyx_t_19); + __Pyx_XGOTREF(__pyx_t_18); + __pyx_t_16 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_17 = __pyx_filename; + { + __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0; + } + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_18); + __Pyx_ExceptionReset(__pyx_t_20, __pyx_t_19, __pyx_t_18); + __Pyx_XGIVEREF(__pyx_t_23); + __Pyx_XGIVEREF(__pyx_t_22); + __Pyx_XGIVEREF(__pyx_t_21); + __Pyx_ErrRestore(__pyx_t_23, __pyx_t_22, __pyx_t_21); + __pyx_t_23 = 0; __pyx_t_22 = 0; __pyx_t_21 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_t_18 = 0; + __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_17; + goto __pyx_L40_except_error; + } + } + } + goto __pyx_L40_except_error; + + /* "aiohttp/_websocket/reader_py.py":330 + * if opcode == OP_CODE_TEXT: + * if self._decode_text: + * try: # <<<<<<<<<<<<<< + * text = payload_merged.decode("utf-8") + * except UnicodeDecodeError as exc: +*/ + __pyx_L40_except_error:; + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_13, __pyx_t_12); + goto __pyx_L1_error; + __pyx_L43_try_end:; + } + + /* "aiohttp/_websocket/reader_py.py":341 + * # This is not type safe, but many tests should fail in + * # test_client_ws_functional.py if this is wrong. + * msg = TUPLE_NEW(WSMessageText, (text, size, "", WS_MSG_TYPE_TEXT)) # <<<<<<<<<<<<<< + * else: + * # Return raw bytes for TEXT messages when decode_text=False +*/ + __pyx_t_6 = NULL; + __Pyx_INCREF(__pyx_v_7aiohttp_10_websocket_8reader_c_TUPLE_NEW); + __pyx_t_1 = __pyx_v_7aiohttp_10_websocket_8reader_c_TUPLE_NEW; + __pyx_t_2 = PyLong_FromSsize_t(__pyx_v_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_text); + __Pyx_GIVEREF(__pyx_v_text); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_text) != (0)) __PYX_ERR(0, 341, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 341, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u__3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_mstate_global->__pyx_kp_u__3) != (0)) __PYX_ERR(0, 341, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_TEXT); + __Pyx_GIVEREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_TEXT); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_TEXT) != (0)) __PYX_ERR(0, 341, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_1, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageText, __pyx_t_5}; + __pyx_t_15 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_1, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + } + __pyx_v_msg = __pyx_t_15; + __pyx_t_15 = 0; + + /* "aiohttp/_websocket/reader_py.py":329 + * size = len(payload_merged) + * if opcode == OP_CODE_TEXT: + * if self._decode_text: # <<<<<<<<<<<<<< + * try: + * text = payload_merged.decode("utf-8") +*/ + goto __pyx_L37; + } + + /* "aiohttp/_websocket/reader_py.py":344 + * else: + * # Return raw bytes for TEXT messages when decode_text=False + * msg = TUPLE_NEW( # <<<<<<<<<<<<<< + * WSMessageTextBytes, (payload_merged, size, "", WS_MSG_TYPE_TEXT) + * ) +*/ + /*else*/ { + __pyx_t_1 = NULL; + __Pyx_INCREF(__pyx_v_7aiohttp_10_websocket_8reader_c_TUPLE_NEW); + __pyx_t_5 = __pyx_v_7aiohttp_10_websocket_8reader_c_TUPLE_NEW; + + /* "aiohttp/_websocket/reader_py.py":345 + * # Return raw bytes for TEXT messages when decode_text=False + * msg = TUPLE_NEW( + * WSMessageTextBytes, (payload_merged, size, "", WS_MSG_TYPE_TEXT) # <<<<<<<<<<<<<< + * ) + * else: +*/ + __pyx_t_6 = PyLong_FromSsize_t(__pyx_v_size); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_payload_merged); + __Pyx_GIVEREF(__pyx_v_payload_merged); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_payload_merged) != (0)) __PYX_ERR(0, 345, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 345, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u__3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_mstate_global->__pyx_kp_u__3) != (0)) __PYX_ERR(0, 345, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_TEXT); + __Pyx_GIVEREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_TEXT); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_TEXT) != (0)) __PYX_ERR(0, 345, __pyx_L1_error); + __pyx_t_6 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_1); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageTextBytes, __pyx_t_2}; + __pyx_t_15 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 344, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + } + __pyx_v_msg = __pyx_t_15; + __pyx_t_15 = 0; + } + __pyx_L37:; + + /* "aiohttp/_websocket/reader_py.py":328 + * + * size = len(payload_merged) + * if opcode == OP_CODE_TEXT: # <<<<<<<<<<<<<< + * if self._decode_text: + * try: +*/ + goto __pyx_L36; + } + + /* "aiohttp/_websocket/reader_py.py":348 + * ) + * else: + * msg = TUPLE_NEW( # <<<<<<<<<<<<<< + * WSMessageBinary, (payload_merged, size, "", WS_MSG_TYPE_BINARY) + * ) +*/ + /*else*/ { + __pyx_t_5 = NULL; + __Pyx_INCREF(__pyx_v_7aiohttp_10_websocket_8reader_c_TUPLE_NEW); + __pyx_t_2 = __pyx_v_7aiohttp_10_websocket_8reader_c_TUPLE_NEW; + + /* "aiohttp/_websocket/reader_py.py":349 + * else: + * msg = TUPLE_NEW( + * WSMessageBinary, (payload_merged, size, "", WS_MSG_TYPE_BINARY) # <<<<<<<<<<<<<< + * ) + * +*/ + __pyx_t_1 = PyLong_FromSsize_t(__pyx_v_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_v_payload_merged); + __Pyx_GIVEREF(__pyx_v_payload_merged); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_payload_merged) != (0)) __PYX_ERR(0, 349, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_1) != (0)) __PYX_ERR(0, 349, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u__3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_mstate_global->__pyx_kp_u__3) != (0)) __PYX_ERR(0, 349, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_BINARY); + __Pyx_GIVEREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_BINARY); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_BINARY) != (0)) __PYX_ERR(0, 349, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageBinary, __pyx_t_6}; + __pyx_t_15 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_2, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + } + __pyx_v_msg = __pyx_t_15; + __pyx_t_15 = 0; + } + __pyx_L36:; + + /* "aiohttp/_websocket/reader_py.py":352 + * ) + * + * self.queue.feed_data(msg) # <<<<<<<<<<<<<< + * elif opcode == OP_CODE_CLOSE: + * payload_len = len(payload) +*/ + ((struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self->queue->__pyx_vtab)->feed_data(__pyx_v_self->queue, __pyx_v_msg, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 352, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":257 + * ) -> None: + * msg: WSMessage + * if opcode in {OP_CODE_TEXT, OP_CODE_BINARY, OP_CODE_CONTINUATION}: # <<<<<<<<<<<<<< + * # Validate continuation frames before processing + * if opcode == OP_CODE_CONTINUATION and self._opcode == OP_CODE_NOT_SET: +*/ + goto __pyx_L3; + } + + /* "aiohttp/_websocket/reader_py.py":353 + * + * self.queue.feed_data(msg) + * elif opcode == OP_CODE_CLOSE: # <<<<<<<<<<<<<< + * payload_len = len(payload) + * if payload_len >= 2: +*/ + __pyx_t_10 = (__pyx_v_opcode == __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_CLOSE); + + if (__pyx_t_10) { + + + /* "aiohttp/_websocket/reader_py.py":354 + * self.queue.feed_data(msg) + * elif opcode == OP_CODE_CLOSE: + * payload_len = len(payload) # <<<<<<<<<<<<<< + * if payload_len >= 2: + * close_code = UNPACK_CLOSE_CODE(payload[:2])[0] +*/ + __pyx_t_24 = PyObject_Length(__pyx_v_payload); if (unlikely(__pyx_t_24 == ((Py_ssize_t)-1))) __PYX_ERR(0, 354, __pyx_L1_error) + __pyx_v_payload_len = __pyx_t_24; + + /* "aiohttp/_websocket/reader_py.py":355 + * elif opcode == OP_CODE_CLOSE: + * payload_len = len(payload) + * if payload_len >= 2: # <<<<<<<<<<<<<< + * close_code = UNPACK_CLOSE_CODE(payload[:2])[0] + * # https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.2 +*/ + __pyx_t_10 = (__pyx_v_payload_len >= 2); + + if (__pyx_t_10) { + + + /* "aiohttp/_websocket/reader_py.py":356 + * payload_len = len(payload) + * if payload_len >= 2: + * close_code = UNPACK_CLOSE_CODE(payload[:2])[0] # <<<<<<<<<<<<<< + * # https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.2 + * if close_code > 4999 or ( +*/ + __pyx_t_2 = NULL; + __Pyx_INCREF(__pyx_v_7aiohttp_10_websocket_8reader_c_UNPACK_CLOSE_CODE); + __pyx_t_6 = __pyx_v_7aiohttp_10_websocket_8reader_c_UNPACK_CLOSE_CODE; + __pyx_t_5 = __Pyx_PyObject_GetSlice(__pyx_v_payload, 0, 2, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_5}; + __pyx_t_15 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + } + __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_15, 0, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_v_close_code = __pyx_t_6; + __pyx_t_6 = 0; + + /* "aiohttp/_websocket/reader_py.py":358 + * close_code = UNPACK_CLOSE_CODE(payload[:2])[0] + * # https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.2 + * if close_code > 4999 or ( # <<<<<<<<<<<<<< + * close_code < 3000 and close_code not in ALLOWED_CLOSE_CODES + * ): +*/ + __pyx_t_11 = __Pyx_PyObject_CompareBoolGt_object_int(__pyx_v_close_code, __pyx_mstate_global->__pyx_int_4999, Py_GT); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 358, __pyx_L1_error) + if (!__pyx_t_11) { + + } else { + + __pyx_t_10 = __pyx_t_11; + + goto __pyx_L57_bool_binop_done; + } + + /* "aiohttp/_websocket/reader_py.py":359 + * # https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.2 + * if close_code > 4999 or ( + * close_code < 3000 and close_code not in ALLOWED_CLOSE_CODES # <<<<<<<<<<<<<< + * ): + * raise WebSocketError( +*/ + __pyx_t_11 = __Pyx_PyObject_CompareBoolLt_object_int(__pyx_v_close_code, __pyx_mstate_global->__pyx_int_3000, Py_LT); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 359, __pyx_L1_error) + if (__pyx_t_11) { + + } else { + + __pyx_t_10 = __pyx_t_11; + + goto __pyx_L57_bool_binop_done; + } + if (unlikely(__pyx_v_7aiohttp_10_websocket_8reader_c_ALLOWED_CLOSE_CODES == Py_None)) { + PyErr_SetString(PyExc_TypeError, "\047NoneType\047 object is not iterable"); + __PYX_ERR(0, 359, __pyx_L1_error) + } + __pyx_t_11 = (__Pyx_PySet_ContainsTF(__pyx_v_close_code, __pyx_v_7aiohttp_10_websocket_8reader_c_ALLOWED_CLOSE_CODES, Py_NE)); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 359, __pyx_L1_error) + + __pyx_t_10 = __pyx_t_11; + + __pyx_L57_bool_binop_done:; + + /* "aiohttp/_websocket/reader_py.py":358 + * close_code = UNPACK_CLOSE_CODE(payload[:2])[0] + * # https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.2 + * if close_code > 4999 or ( # <<<<<<<<<<<<<< + * close_code < 3000 and close_code not in ALLOWED_CLOSE_CODES + * ): +*/ + if (unlikely(__pyx_t_10)) { + + + /* "aiohttp/_websocket/reader_py.py":361 + * close_code < 3000 and close_code not in ALLOWED_CLOSE_CODES + * ): + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.PROTOCOL_ERROR, + * f"Invalid close code: {close_code}", +*/ + __pyx_t_15 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + + /* "aiohttp/_websocket/reader_py.py":362 + * ): + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, # <<<<<<<<<<<<<< + * f"Invalid close code: {close_code}", + * ) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_PROTOCOL_ERROR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":363 + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, + * f"Invalid close code: {close_code}", # <<<<<<<<<<<<<< + * ) + * try: +*/ + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_close_code, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Invalid_close_code, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_15); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_15); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_15, __pyx_t_1, __pyx_t_3}; + __pyx_t_6 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __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; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 361, __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(0, 361, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":358 + * close_code = UNPACK_CLOSE_CODE(payload[:2])[0] + * # https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.2 + * if close_code > 4999 or ( # <<<<<<<<<<<<<< + * close_code < 3000 and close_code not in ALLOWED_CLOSE_CODES + * ): +*/ + } + + /* "aiohttp/_websocket/reader_py.py":365 + * f"Invalid close code: {close_code}", + * ) + * try: # <<<<<<<<<<<<<< + * close_message = payload[2:].decode("utf-8") + * except UnicodeDecodeError as exc: +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_14); + /*try:*/ { + + /* "aiohttp/_websocket/reader_py.py":366 + * ) + * try: + * close_message = payload[2:].decode("utf-8") # <<<<<<<<<<<<<< + * except UnicodeDecodeError as exc: + * raise WebSocketError( +*/ + __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_v_payload, 2, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[1], 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 366, __pyx_L60_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_utf_8}; + __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_decode, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 366, __pyx_L60_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_v_close_message = __pyx_t_6; + __pyx_t_6 = 0; + + /* "aiohttp/_websocket/reader_py.py":365 + * f"Invalid close code: {close_code}", + * ) + * try: # <<<<<<<<<<<<<< + * close_message = payload[2:].decode("utf-8") + * except UnicodeDecodeError as exc: +*/ + } + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + goto __pyx_L65_try_end; + __pyx_L60_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __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; + __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; + + /* "aiohttp/_websocket/reader_py.py":367 + * try: + * close_message = payload[2:].decode("utf-8") + * except UnicodeDecodeError as exc: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message" +*/ + __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_UnicodeDecodeError)))); + if (__pyx_t_9) { + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketReader._handle_frame", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_3, &__pyx_t_5) < 0) __PYX_ERR(0, 367, __pyx_L62_except_error) + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_exc = ((PyObject*)__pyx_t_3); + /*try:*/ { + + /* "aiohttp/_websocket/reader_py.py":368 + * close_message = payload[2:].decode("utf-8") + * except UnicodeDecodeError as exc: + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message" + * ) from exc +*/ + __pyx_t_15 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 368, __pyx_L71_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "aiohttp/_websocket/reader_py.py":369 + * except UnicodeDecodeError as exc: + * raise WebSocketError( + * WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message" # <<<<<<<<<<<<<< + * ) from exc + * msg = WSMessageClose( +*/ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 369, __pyx_L71_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_INVALID_TEXT); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 369, __pyx_L71_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_15); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_15); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_15, __pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Invalid_UTF_8_text_message}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_2, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 368, __pyx_L71_error) + __Pyx_GOTREF(__pyx_t_1); + } + + /* "aiohttp/_websocket/reader_py.py":370 + * raise WebSocketError( + * WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message" + * ) from exc # <<<<<<<<<<<<<< + * msg = WSMessageClose( + * data=close_code, size=payload_len, extra=close_message +*/ + __Pyx_Raise(__pyx_t_1, 0, 0, __pyx_v_exc); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 368, __pyx_L71_error) + } + + /* "aiohttp/_websocket/reader_py.py":367 + * try: + * close_message = payload[2:].decode("utf-8") + * except UnicodeDecodeError as exc: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message" +*/ + /*finally:*/ { + __pyx_L71_error:; + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_ExceptionSwap(&__pyx_t_21, &__pyx_t_22, &__pyx_t_23); + if ( unlikely(__Pyx_GetException(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20) < 0)) __Pyx_ErrFetch(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20); + __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_XGOTREF(__pyx_t_23); + __pyx_t_9 = __pyx_lineno; __pyx_t_16 = __pyx_clineno; __pyx_t_17 = __pyx_filename; + { + __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0; + } + __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_18); + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_20); + __Pyx_ErrRestore(__pyx_t_18, __pyx_t_19, __pyx_t_20); + __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; + __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_16; __pyx_filename = __pyx_t_17; + goto __pyx_L62_except_error; + } + } + } + goto __pyx_L62_except_error; + + /* "aiohttp/_websocket/reader_py.py":365 + * f"Invalid close code: {close_code}", + * ) + * try: # <<<<<<<<<<<<<< + * close_message = payload[2:].decode("utf-8") + * except UnicodeDecodeError as exc: +*/ + __pyx_L62_except_error:; + __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); + goto __pyx_L1_error; + __pyx_L65_try_end:; + } + + /* "aiohttp/_websocket/reader_py.py":371 + * WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message" + * ) from exc + * msg = WSMessageClose( # <<<<<<<<<<<<<< + * data=close_code, size=payload_len, extra=close_message + * ) +*/ + __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageClose); + __pyx_t_6 = __pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageClose; + + /* "aiohttp/_websocket/reader_py.py":372 + * ) from exc + * msg = WSMessageClose( + * data=close_code, size=payload_len, extra=close_message # <<<<<<<<<<<<<< + * ) + * elif payload: +*/ + __pyx_t_1 = PyLong_FromSsize_t(__pyx_v_payload_len); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_3, __pyx_v_close_code, __pyx_t_1, __pyx_v_close_message}; + #if CYTHON_VECTORCALL + __pyx_t_2 = __pyx_mstate_global->__pyx_tuple[1]; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 371, __pyx_L1_error) + __Pyx_INCREF(__pyx_t_2); + #else + { + PyObject *__pyx_temp[3] = {__pyx_mstate_global->__pyx_n_u_data, __pyx_mstate_global->__pyx_n_u_size, __pyx_mstate_global->__pyx_n_u_extra}; + __pyx_t_2 = __Pyx_MakeKwargDict(__pyx_temp, __pyx_callargs+1, 3); + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + #endif + __pyx_t_5 = __Pyx_Object_VectorcallKwds((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_2); + __Pyx_XDECREF(__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; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_v_msg = __pyx_t_5; + __pyx_t_5 = 0; + + /* "aiohttp/_websocket/reader_py.py":355 + * elif opcode == OP_CODE_CLOSE: + * payload_len = len(payload) + * if payload_len >= 2: # <<<<<<<<<<<<<< + * close_code = UNPACK_CLOSE_CODE(payload[:2])[0] + * # https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.2 +*/ + goto __pyx_L55; + } + + /* "aiohttp/_websocket/reader_py.py":374 + * data=close_code, size=payload_len, extra=close_message + * ) + * elif payload: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, +*/ + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_payload); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 374, __pyx_L1_error) + if (unlikely(__pyx_t_10)) { + + + /* "aiohttp/_websocket/reader_py.py":375 + * ) + * elif payload: + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.PROTOCOL_ERROR, + * f"Invalid close frame: {fin} {opcode} {payload!r}", +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 375, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "aiohttp/_websocket/reader_py.py":376 + * elif payload: + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, # <<<<<<<<<<<<<< + * f"Invalid close frame: {fin} {opcode} {payload!r}", + * ) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_PROTOCOL_ERROR); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":377 + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, + * f"Invalid close frame: {fin} {opcode} {payload!r}", # <<<<<<<<<<<<<< + * ) + * else: +*/ + __pyx_t_1 = __Pyx_PyUnicode_FromBInt_bint(__pyx_v_fin); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyUnicode_From_int(__pyx_v_opcode, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_15 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_payload), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_25[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_close_frame; + __pyx_t_25[1] = __pyx_t_1; + __pyx_t_25[2] = __pyx_mstate_global->__pyx_kp_u__4; + __pyx_t_25[3] = __pyx_t_4; + __pyx_t_25[4] = __pyx_mstate_global->__pyx_kp_u__4; + __pyx_t_25[5] = __pyx_t_15; + __pyx_t_24 = 23; + #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH + __pyx_t_24 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_25[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_25[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_25[5]); + #endif + __pyx_t_16 = 0; + #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH + __pyx_t_16 |= __Pyx_PyUnicode_KIND_04(__pyx_t_25[5]); + #endif + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_25, 6, __pyx_t_24, __pyx_t_16); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_7}; + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_2, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 375, __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(0, 375, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":374 + * data=close_code, size=payload_len, extra=close_message + * ) + * elif payload: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, +*/ + } + + /* "aiohttp/_websocket/reader_py.py":380 + * ) + * else: + * msg = WSMessageClose(data=0, size=payload_len, extra="") # <<<<<<<<<<<<<< + * + * self.queue.feed_data(msg) +*/ + /*else*/ { + __pyx_t_2 = NULL; + __Pyx_INCREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageClose); + __pyx_t_7 = __pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageClose; + __pyx_t_3 = PyLong_FromSsize_t(__pyx_v_payload_len); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_2, __pyx_mstate_global->__pyx_int_0, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u__3}; + #if CYTHON_VECTORCALL + __pyx_t_6 = __pyx_mstate_global->__pyx_tuple[1]; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_INCREF(__pyx_t_6); + #else + { + PyObject *__pyx_temp[3] = {__pyx_mstate_global->__pyx_n_u_data, __pyx_mstate_global->__pyx_n_u_size, __pyx_mstate_global->__pyx_n_u_extra}; + __pyx_t_6 = __Pyx_MakeKwargDict(__pyx_temp, __pyx_callargs+1, 3); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + #endif + __pyx_t_5 = __Pyx_Object_VectorcallKwds((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 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; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_v_msg = __pyx_t_5; + __pyx_t_5 = 0; + } + __pyx_L55:; + + /* "aiohttp/_websocket/reader_py.py":382 + * msg = WSMessageClose(data=0, size=payload_len, extra="") + * + * self.queue.feed_data(msg) # <<<<<<<<<<<<<< + * elif opcode == OP_CODE_PING: + * self.queue.feed_data( +*/ + ((struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self->queue->__pyx_vtab)->feed_data(__pyx_v_self->queue, __pyx_v_msg, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 382, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":353 + * + * self.queue.feed_data(msg) + * elif opcode == OP_CODE_CLOSE: # <<<<<<<<<<<<<< + * payload_len = len(payload) + * if payload_len >= 2: +*/ + goto __pyx_L3; + } + + /* "aiohttp/_websocket/reader_py.py":383 + * + * self.queue.feed_data(msg) + * elif opcode == OP_CODE_PING: # <<<<<<<<<<<<<< + * self.queue.feed_data( + * WSMessagePing(data=bytes(payload), size=len(payload), extra="") +*/ + __pyx_t_10 = (__pyx_v_opcode == __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_PING); + + if (__pyx_t_10) { + + + /* "aiohttp/_websocket/reader_py.py":385 + * elif opcode == OP_CODE_PING: + * self.queue.feed_data( + * WSMessagePing(data=bytes(payload), size=len(payload), extra="") # <<<<<<<<<<<<<< + * ) + * elif opcode == OP_CODE_PONG: +*/ + __pyx_t_7 = NULL; + __Pyx_INCREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessagePing); + __pyx_t_6 = __pyx_v_7aiohttp_10_websocket_8reader_c_WSMessagePing; + __pyx_t_2 = NULL; + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_payload}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)(&PyBytes_Type), __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_24 = PyObject_Length(__pyx_v_payload); if (unlikely(__pyx_t_24 == ((Py_ssize_t)-1))) __PYX_ERR(0, 385, __pyx_L1_error) + __pyx_t_2 = PyLong_FromSsize_t(__pyx_t_24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_t_3, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u__3}; + #if CYTHON_VECTORCALL + __pyx_t_15 = __pyx_mstate_global->__pyx_tuple[1]; + if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 385, __pyx_L1_error) + __Pyx_INCREF(__pyx_t_15); + #else + { + PyObject *__pyx_temp[3] = {__pyx_mstate_global->__pyx_n_u_data, __pyx_mstate_global->__pyx_n_u_size, __pyx_mstate_global->__pyx_n_u_extra}; + __pyx_t_15 = __Pyx_MakeKwargDict(__pyx_temp, __pyx_callargs+1, 3); + if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + } + #endif + __pyx_t_5 = __Pyx_Object_VectorcallKwds((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_15); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + + /* "aiohttp/_websocket/reader_py.py":384 + * self.queue.feed_data(msg) + * elif opcode == OP_CODE_PING: + * self.queue.feed_data( # <<<<<<<<<<<<<< + * WSMessagePing(data=bytes(payload), size=len(payload), extra="") + * ) +*/ + ((struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self->queue->__pyx_vtab)->feed_data(__pyx_v_self->queue, __pyx_t_5, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "aiohttp/_websocket/reader_py.py":383 + * + * self.queue.feed_data(msg) + * elif opcode == OP_CODE_PING: # <<<<<<<<<<<<<< + * self.queue.feed_data( + * WSMessagePing(data=bytes(payload), size=len(payload), extra="") +*/ + goto __pyx_L3; + } + + /* "aiohttp/_websocket/reader_py.py":387 + * WSMessagePing(data=bytes(payload), size=len(payload), extra="") + * ) + * elif opcode == OP_CODE_PONG: # <<<<<<<<<<<<<< + * self.queue.feed_data( + * WSMessagePong(data=bytes(payload), size=len(payload), extra="") +*/ + __pyx_t_10 = (__pyx_v_opcode == __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_PONG); + + if (likely(__pyx_t_10)) { + + + /* "aiohttp/_websocket/reader_py.py":389 + * elif opcode == OP_CODE_PONG: + * self.queue.feed_data( + * WSMessagePong(data=bytes(payload), size=len(payload), extra="") # <<<<<<<<<<<<<< + * ) + * else: +*/ + __pyx_t_6 = NULL; + __Pyx_INCREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessagePong); + __pyx_t_15 = __pyx_v_7aiohttp_10_websocket_8reader_c_WSMessagePong; + __pyx_t_3 = NULL; + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_payload}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(&PyBytes_Type), __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_24 = PyObject_Length(__pyx_v_payload); if (unlikely(__pyx_t_24 == ((Py_ssize_t)-1))) __PYX_ERR(0, 389, __pyx_L1_error) + __pyx_t_3 = PyLong_FromSsize_t(__pyx_t_24); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_15))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_15); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_15); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_15, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_t_2, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u__3}; + #if CYTHON_VECTORCALL + __pyx_t_7 = __pyx_mstate_global->__pyx_tuple[1]; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 389, __pyx_L1_error) + __Pyx_INCREF(__pyx_t_7); + #else + { + PyObject *__pyx_temp[3] = {__pyx_mstate_global->__pyx_n_u_data, __pyx_mstate_global->__pyx_n_u_size, __pyx_mstate_global->__pyx_n_u_extra}; + __pyx_t_7 = __Pyx_MakeKwargDict(__pyx_temp, __pyx_callargs+1, 3); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + #endif + __pyx_t_5 = __Pyx_Object_VectorcallKwds((PyObject*)__pyx_t_15, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + + /* "aiohttp/_websocket/reader_py.py":388 + * ) + * elif opcode == OP_CODE_PONG: + * self.queue.feed_data( # <<<<<<<<<<<<<< + * WSMessagePong(data=bytes(payload), size=len(payload), extra="") + * ) +*/ + ((struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v_self->queue->__pyx_vtab)->feed_data(__pyx_v_self->queue, __pyx_t_5, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 388, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "aiohttp/_websocket/reader_py.py":387 + * WSMessagePing(data=bytes(payload), size=len(payload), extra="") + * ) + * elif opcode == OP_CODE_PONG: # <<<<<<<<<<<<<< + * self.queue.feed_data( + * WSMessagePong(data=bytes(payload), size=len(payload), extra="") +*/ + goto __pyx_L3; + } + + /* "aiohttp/_websocket/reader_py.py":392 + * ) + * else: + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.PROTOCOL_ERROR, f"Unexpected opcode={opcode!r}" + * ) +*/ + /*else*/ { + __pyx_t_15 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + + /* "aiohttp/_websocket/reader_py.py":393 + * else: + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, f"Unexpected opcode={opcode!r}" # <<<<<<<<<<<<<< + * ) + * +*/ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_PROTOCOL_ERROR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_From_int(__pyx_v_opcode, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Unexpected_opcode, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_15); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_15); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_15, __pyx_t_2, __pyx_t_6}; + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 392, __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(0, 392, __pyx_L1_error) + } + __pyx_L3:; + + /* "aiohttp/_websocket/reader_py.py":249 + * return EMPTY_FRAME + * + * def _handle_frame( # <<<<<<<<<<<<<< + * self, + * fin: bool, +*/ + + /* function exit code */ + 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_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketReader._handle_frame", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + + __Pyx_XDECREF(__pyx_v_payload_merged); + __Pyx_XDECREF(__pyx_v_msg); + __Pyx_XDECREF(__pyx_v_assembled_payload); + __Pyx_XDECREF(__pyx_v_exc); + + __Pyx_XDECREF(__pyx_v_text); + + __Pyx_XDECREF(__pyx_v_close_code); + __Pyx_XDECREF(__pyx_v_close_message); + + + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_7_handle_frame(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_8reader_c_15WebSocketReader_7_handle_frame = {"_handle_frame", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_7_handle_frame, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_7_handle_frame(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + int __pyx_v_fin; + int __pyx_v_opcode; + PyObject *__pyx_v_payload = 0; + int __pyx_v_compressed; + #if !CYTHON_VECTORCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_handle_frame (wrapper)", 0); + #if !CYTHON_VECTORCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_fin,&__pyx_mstate_global->__pyx_n_u_opcode,&__pyx_mstate_global->__pyx_n_u_payload,&__pyx_mstate_global->__pyx_n_u_compressed,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 249, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 249, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 249, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 249, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 249, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_handle_frame", 0) < (0)) __PYX_ERR(0, 249, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_handle_frame", 1, 4, 4, i); __PYX_ERR(0, 249, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 249, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 249, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 249, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 249, __pyx_L3_error) + } + __pyx_v_fin = __Pyx_PyObject_IsTrue(values[0]); if (unlikely((__pyx_v_fin == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 251, __pyx_L3_error) + __pyx_v_opcode = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_opcode == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 252, __pyx_L3_error) + __pyx_v_payload = values[2]; + __pyx_v_compressed = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_compressed == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 254, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_handle_frame", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 249, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketReader._handle_frame", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_6_handle_frame(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *)__pyx_v_self), __pyx_v_fin, __pyx_v_opcode, __pyx_v_payload, __pyx_v_compressed); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + + + + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_6_handle_frame(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self, int __pyx_v_fin, int __pyx_v_opcode, PyObject *__pyx_v_payload, int __pyx_v_compressed) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_handle_frame", 0); + __pyx_f_7aiohttp_10_websocket_8reader_c_15WebSocketReader__handle_frame(__pyx_v_self, __pyx_v_fin, __pyx_v_opcode, __pyx_v_payload, __pyx_v_compressed, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 249, __pyx_L1_error) + __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __pyx_r = __pyx_t_1; + } + __Pyx_XDECREF(__pyx_temp); + } + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketReader._handle_frame", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "aiohttp/_websocket/reader_py.py":396 + * ) + * + * def _feed_data(self, data: bytes) -> None: # <<<<<<<<<<<<<< + * """Return the next frame from the socket.""" + * self.queue._stalled_reader = None +*/ + +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_9_feed_data(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static void __pyx_f_7aiohttp_10_websocket_8reader_c_15WebSocketReader__feed_data(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self, PyObject *__pyx_v_data, int __pyx_skip_dispatch) { + Py_ssize_t __pyx_v_start_pos; + Py_ssize_t __pyx_v_data_len; + Py_ssize_t __pyx_v_length; + Py_ssize_t __pyx_v_chunk_len; + unsigned char const *__pyx_v_data_cstr; + unsigned char __pyx_v_first_byte; + unsigned char __pyx_v_second_byte; + Py_ssize_t __pyx_v_f_start_pos; + Py_ssize_t __pyx_v_f_end_pos; + int __pyx_v_has_mask; + int __pyx_v_fin; + Py_ssize_t __pyx_v_had_fragments; + Py_ssize_t __pyx_v_partial_len; + unsigned PY_LONG_LONG __pyx_v_frame_len; + PyObject *__pyx_v_payload_bytearray = 0; + long __pyx_v_rsv1; + long __pyx_v_rsv2; + long __pyx_v_rsv3; + long __pyx_v_opcode; + unsigned int __pyx_v_len_flag; + PyObject *__pyx_v_payload = 0; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + int __pyx_t_6; + Py_ssize_t __pyx_t_7; + unsigned char const *__pyx_t_8; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + long __pyx_t_11; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + unsigned int __pyx_t_14; + unsigned PY_LONG_LONG __pyx_t_15; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17[4]; + int __pyx_t_18; + int __pyx_t_19; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_feed_data", 0); + __Pyx_INCREF(__pyx_v_data); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if ( + #if !CYTHON_USE_TYPE_SLOTS + unlikely(Py_TYPE(((PyObject *)__pyx_v_self)) != __pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader && + __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), Py_TPFLAGS_HAVE_GC)) + #else + unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0 || __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE))) + #endif + ) { + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; + if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { + PY_UINT64_T __pyx_typedict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); + #endif + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_feed_data_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!__Pyx_IsSameCFunction(__pyx_t_1, (void(*)(void)) __pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_9_feed_data)) { + __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_data}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + { + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); + __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); + if (unlikely(__pyx_typedict_guard != __pyx_tp_dict_version)) { + __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; + } + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + } + #endif + } + + /* "aiohttp/_websocket/reader_py.py":398 + * def _feed_data(self, data: bytes) -> None: + * """Return the next frame from the socket.""" + * self.queue._stalled_reader = None # <<<<<<<<<<<<<< + * if self._tail: + * data, self._tail = self._tail + data, b"" +*/ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->queue->_stalled_reader); + __Pyx_DECREF(__pyx_v_self->queue->_stalled_reader); + __pyx_v_self->queue->_stalled_reader = Py_None; + + /* "aiohttp/_websocket/reader_py.py":399 + * """Return the next frame from the socket.""" + * self.queue._stalled_reader = None + * if self._tail: # <<<<<<<<<<<<<< + * data, self._tail = self._tail + data, b"" + * +*/ + if (__pyx_v_self->_tail == Py_None) __pyx_t_6 = 0; + else + { + Py_ssize_t __pyx_temp = __Pyx_PyBytes_GET_SIZE(__pyx_v_self->_tail); + if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 399, __pyx_L1_error) + __pyx_t_6 = (__pyx_temp != 0); + } + + if (__pyx_t_6) { + + + /* "aiohttp/_websocket/reader_py.py":400 + * self.queue._stalled_reader = None + * if self._tail: + * data, self._tail = self._tail + data, b"" # <<<<<<<<<<<<<< + * + * start_pos = 0 +*/ + __pyx_t_1 = PyNumber_Add(__pyx_v_self->_tail, __pyx_v_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_mstate_global->__pyx_kp_b__3; + __Pyx_INCREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_data, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->_tail); + __Pyx_DECREF(__pyx_v_self->_tail); + __pyx_v_self->_tail = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":399 + * """Return the next frame from the socket.""" + * self.queue._stalled_reader = None + * if self._tail: # <<<<<<<<<<<<<< + * data, self._tail = self._tail + data, b"" + * +*/ + } + + /* "aiohttp/_websocket/reader_py.py":402 + * data, self._tail = self._tail + data, b"" + * + * start_pos = 0 # <<<<<<<<<<<<<< + * data_len = len(data) + * data_cstr = data +*/ + __pyx_v_start_pos = 0; + + /* "aiohttp/_websocket/reader_py.py":403 + * + * start_pos = 0 + * data_len = len(data) # <<<<<<<<<<<<<< + * data_cstr = data + * +*/ + __pyx_t_7 = __Pyx_PyBytes_GET_SIZE(__pyx_v_data); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 403, __pyx_L1_error) + __pyx_v_data_len = __pyx_t_7; + + /* "aiohttp/_websocket/reader_py.py":404 + * start_pos = 0 + * data_len = len(data) + * data_cstr = data # <<<<<<<<<<<<<< + * + * while True: +*/ + __pyx_t_8 = __Pyx_PyBytes_AsUString(__pyx_v_data); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(0, 404, __pyx_L1_error) + __pyx_v_data_cstr = __pyx_t_8; + + /* "aiohttp/_websocket/reader_py.py":406 + * data_cstr = data + * + * while True: # <<<<<<<<<<<<<< + * if start_pos < data_len and self.queue._size > self.queue._limit: + * # Over the high-water mark with unparsed bytes left: stash the +*/ + while (1) { + + /* "aiohttp/_websocket/reader_py.py":407 + * + * while True: + * if start_pos < data_len and self.queue._size > self.queue._limit: # <<<<<<<<<<<<<< + * # Over the high-water mark with unparsed bytes left: stash the + * # remainder and stall. Gating on unparsed bytes keeps a read +*/ + __pyx_t_9 = (__pyx_v_start_pos < __pyx_v_data_len); + + if (__pyx_t_9) { + + } else { + + __pyx_t_6 = __pyx_t_9; + + goto __pyx_L7_bool_binop_done; + } + __pyx_t_9 = (__pyx_v_self->queue->_size > __pyx_v_self->queue->_limit); + + + __pyx_t_6 = __pyx_t_9; + + __pyx_L7_bool_binop_done:; + if (__pyx_t_6) { + + + /* "aiohttp/_websocket/reader_py.py":412 + * # that ended on a frame boundary from arming an empty stall, + * # which would hold the transport paused with nothing to drain. + * self.queue._stalled_reader = self._weak_self # <<<<<<<<<<<<<< + * break + * +*/ + __pyx_t_2 = __pyx_v_self->_weak_self; + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->queue->_stalled_reader); + __Pyx_DECREF(__pyx_v_self->queue->_stalled_reader); + __pyx_v_self->queue->_stalled_reader = __pyx_t_2; + __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":413 + * # which would hold the transport paused with nothing to drain. + * self.queue._stalled_reader = self._weak_self + * break # <<<<<<<<<<<<<< + * + * # read header +*/ + goto __pyx_L5_break; + + /* "aiohttp/_websocket/reader_py.py":407 + * + * while True: + * if start_pos < data_len and self.queue._size > self.queue._limit: # <<<<<<<<<<<<<< + * # Over the high-water mark with unparsed bytes left: stash the + * # remainder and stall. Gating on unparsed bytes keeps a read +*/ + } + + /* "aiohttp/_websocket/reader_py.py":416 + * + * # read header + * if self._state == READ_HEADER: # <<<<<<<<<<<<<< + * if data_len - start_pos < 2: + * break +*/ + __pyx_t_6 = (__pyx_v_self->_state == __pyx_v_7aiohttp_10_websocket_8reader_c_READ_HEADER); + + if (__pyx_t_6) { + + + /* "aiohttp/_websocket/reader_py.py":417 + * # read header + * if self._state == READ_HEADER: + * if data_len - start_pos < 2: # <<<<<<<<<<<<<< + * break + * first_byte = data_cstr[start_pos] +*/ + __pyx_t_6 = ((__pyx_v_data_len - __pyx_v_start_pos) < 2); + + if (__pyx_t_6) { + + + /* "aiohttp/_websocket/reader_py.py":418 + * if self._state == READ_HEADER: + * if data_len - start_pos < 2: + * break # <<<<<<<<<<<<<< + * first_byte = data_cstr[start_pos] + * second_byte = data_cstr[start_pos + 1] +*/ + goto __pyx_L5_break; + + /* "aiohttp/_websocket/reader_py.py":417 + * # read header + * if self._state == READ_HEADER: + * if data_len - start_pos < 2: # <<<<<<<<<<<<<< + * break + * first_byte = data_cstr[start_pos] +*/ + } + + /* "aiohttp/_websocket/reader_py.py":419 + * if data_len - start_pos < 2: + * break + * first_byte = data_cstr[start_pos] # <<<<<<<<<<<<<< + * second_byte = data_cstr[start_pos + 1] + * start_pos += 2 +*/ + __pyx_v_first_byte = (__pyx_v_data_cstr[__pyx_v_start_pos]); + + /* "aiohttp/_websocket/reader_py.py":420 + * break + * first_byte = data_cstr[start_pos] + * second_byte = data_cstr[start_pos + 1] # <<<<<<<<<<<<<< + * start_pos += 2 + * +*/ + __pyx_v_second_byte = (__pyx_v_data_cstr[(__pyx_v_start_pos + 1)]); + + /* "aiohttp/_websocket/reader_py.py":421 + * first_byte = data_cstr[start_pos] + * second_byte = data_cstr[start_pos + 1] + * start_pos += 2 # <<<<<<<<<<<<<< + * + * fin = (first_byte >> 7) & 1 +*/ + __pyx_v_start_pos = (__pyx_v_start_pos + 2); + + /* "aiohttp/_websocket/reader_py.py":423 + * start_pos += 2 + * + * fin = (first_byte >> 7) & 1 # <<<<<<<<<<<<<< + * rsv1 = (first_byte >> 6) & 1 + * rsv2 = (first_byte >> 5) & 1 +*/ + __pyx_v_fin = ((__pyx_v_first_byte >> 7) & 1); + + /* "aiohttp/_websocket/reader_py.py":424 + * + * fin = (first_byte >> 7) & 1 + * rsv1 = (first_byte >> 6) & 1 # <<<<<<<<<<<<<< + * rsv2 = (first_byte >> 5) & 1 + * rsv3 = (first_byte >> 4) & 1 +*/ + __pyx_v_rsv1 = ((__pyx_v_first_byte >> 6) & 1); + + /* "aiohttp/_websocket/reader_py.py":425 + * fin = (first_byte >> 7) & 1 + * rsv1 = (first_byte >> 6) & 1 + * rsv2 = (first_byte >> 5) & 1 # <<<<<<<<<<<<<< + * rsv3 = (first_byte >> 4) & 1 + * opcode = first_byte & 0xF +*/ + __pyx_v_rsv2 = ((__pyx_v_first_byte >> 5) & 1); + + /* "aiohttp/_websocket/reader_py.py":426 + * rsv1 = (first_byte >> 6) & 1 + * rsv2 = (first_byte >> 5) & 1 + * rsv3 = (first_byte >> 4) & 1 # <<<<<<<<<<<<<< + * opcode = first_byte & 0xF + * +*/ + __pyx_v_rsv3 = ((__pyx_v_first_byte >> 4) & 1); + + /* "aiohttp/_websocket/reader_py.py":427 + * rsv2 = (first_byte >> 5) & 1 + * rsv3 = (first_byte >> 4) & 1 + * opcode = first_byte & 0xF # <<<<<<<<<<<<<< + * + * # frame-fin = %x0 ; more frames of this message follow +*/ + __pyx_v_opcode = (__pyx_v_first_byte & 0xF); + + /* "aiohttp/_websocket/reader_py.py":439 + * # + * # Remove rsv1 from this test for deflate development + * if rsv2 or rsv3 or (rsv1 and not self._compress): # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, +*/ + __pyx_t_9 = (__pyx_v_rsv2 != 0); + + if (!__pyx_t_9) { + + } else { + + __pyx_t_6 = __pyx_t_9; + + goto __pyx_L12_bool_binop_done; + } + __pyx_t_9 = (__pyx_v_rsv3 != 0); + + if (!__pyx_t_9) { + + } else { + + __pyx_t_6 = __pyx_t_9; + + goto __pyx_L12_bool_binop_done; + } + __pyx_t_9 = (__pyx_v_rsv1 != 0); + + if (__pyx_t_9) { + + } else { + + __pyx_t_6 = __pyx_t_9; + + goto __pyx_L12_bool_binop_done; + } + __pyx_t_9 = (!__pyx_v_self->_compress); + + + __pyx_t_6 = __pyx_t_9; + + __pyx_L12_bool_binop_done:; + if (unlikely(__pyx_t_6)) { + + + /* "aiohttp/_websocket/reader_py.py":440 + * # Remove rsv1 from this test for deflate development + * if rsv2 or rsv3 or (rsv1 and not self._compress): + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.PROTOCOL_ERROR, + * "Received frame with non-zero reserved bits", +*/ + __pyx_t_1 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "aiohttp/_websocket/reader_py.py":441 + * if rsv2 or rsv3 or (rsv1 and not self._compress): + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, # <<<<<<<<<<<<<< + * "Received frame with non-zero reserved bits", + * ) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_PROTOCOL_ERROR); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_1); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_10, __pyx_mstate_global->__pyx_kp_u_Received_frame_with_non_zero_res}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 440, __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(0, 440, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":439 + * # + * # Remove rsv1 from this test for deflate development + * if rsv2 or rsv3 or (rsv1 and not self._compress): # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, +*/ + } + + /* "aiohttp/_websocket/reader_py.py":445 + * ) + * + * if opcode not in { # <<<<<<<<<<<<<< + * OP_CODE_CONTINUATION, + * OP_CODE_TEXT, +*/ + + __pyx_t_11 = __pyx_v_opcode; + + /* "aiohttp/_websocket/reader_py.py":446 + * + * if opcode not in { + * OP_CODE_CONTINUATION, # <<<<<<<<<<<<<< + * OP_CODE_TEXT, + * OP_CODE_BINARY, +*/ + __pyx_t_9 = (__pyx_t_11 != __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_CONTINUATION); + + if (__pyx_t_9) { + + } else { + + __pyx_t_6 = __pyx_t_9; + + goto __pyx_L17_bool_binop_done; + } + + /* "aiohttp/_websocket/reader_py.py":445 + * ) + * + * if opcode not in { # <<<<<<<<<<<<<< + * OP_CODE_CONTINUATION, + * OP_CODE_TEXT, +*/ + __pyx_t_9 = (__pyx_t_11 != __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_TEXT); + + if (__pyx_t_9) { + + } else { + + __pyx_t_6 = __pyx_t_9; + + goto __pyx_L17_bool_binop_done; + } + + /* "aiohttp/_websocket/reader_py.py":448 + * OP_CODE_CONTINUATION, + * OP_CODE_TEXT, + * OP_CODE_BINARY, # <<<<<<<<<<<<<< + * OP_CODE_CLOSE, + * OP_CODE_PING, +*/ + __pyx_t_9 = (__pyx_t_11 != __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_BINARY); + + if (__pyx_t_9) { + + } else { + + __pyx_t_6 = __pyx_t_9; + + goto __pyx_L17_bool_binop_done; + } + + /* "aiohttp/_websocket/reader_py.py":445 + * ) + * + * if opcode not in { # <<<<<<<<<<<<<< + * OP_CODE_CONTINUATION, + * OP_CODE_TEXT, +*/ + __pyx_t_9 = (__pyx_t_11 != __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_CLOSE); + + if (__pyx_t_9) { + + } else { + + __pyx_t_6 = __pyx_t_9; + + goto __pyx_L17_bool_binop_done; + } + + /* "aiohttp/_websocket/reader_py.py":450 + * OP_CODE_BINARY, + * OP_CODE_CLOSE, + * OP_CODE_PING, # <<<<<<<<<<<<<< + * OP_CODE_PONG, + * }: +*/ + __pyx_t_9 = (__pyx_t_11 != __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_PING); + + if (__pyx_t_9) { + + } else { + + __pyx_t_6 = __pyx_t_9; + + goto __pyx_L17_bool_binop_done; + } + + /* "aiohttp/_websocket/reader_py.py":445 + * ) + * + * if opcode not in { # <<<<<<<<<<<<<< + * OP_CODE_CONTINUATION, + * OP_CODE_TEXT, +*/ + __pyx_t_9 = (__pyx_t_11 != __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_PONG); + + + __pyx_t_6 = __pyx_t_9; + + __pyx_L17_bool_binop_done:; + __pyx_t_9 = __pyx_t_6; + + + if (unlikely(__pyx_t_9)) { + + + /* "aiohttp/_websocket/reader_py.py":453 + * OP_CODE_PONG, + * }: + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.PROTOCOL_ERROR, + * f"Unexpected opcode={opcode!r}", +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 453, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + /* "aiohttp/_websocket/reader_py.py":454 + * }: + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, # <<<<<<<<<<<<<< + * f"Unexpected opcode={opcode!r}", + * ) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 454, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_PROTOCOL_ERROR); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 454, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "aiohttp/_websocket/reader_py.py":455 + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, + * f"Unexpected opcode={opcode!r}", # <<<<<<<<<<<<<< + * ) + * +*/ + __pyx_t_1 = __Pyx_PyUnicode_From_long(__pyx_v_opcode, 0, ' ', 'd'); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 455, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_12 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Unexpected_opcode, __pyx_t_1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 455, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_10); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_10, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_12}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_10, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 453, __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(0, 453, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":445 + * ) + * + * if opcode not in { # <<<<<<<<<<<<<< + * OP_CODE_CONTINUATION, + * OP_CODE_TEXT, +*/ + } + + /* "aiohttp/_websocket/reader_py.py":458 + * ) + * + * if opcode > 0x7 and fin == 0: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, +*/ + __pyx_t_6 = (__pyx_v_opcode > 0x7); + + if (__pyx_t_6) { + + } else { + + __pyx_t_9 = __pyx_t_6; + + goto __pyx_L24_bool_binop_done; + } + __pyx_t_6 = (__pyx_v_fin == 0); + + + __pyx_t_9 = __pyx_t_6; + + __pyx_L24_bool_binop_done:; + if (unlikely(__pyx_t_9)) { + + + /* "aiohttp/_websocket/reader_py.py":459 + * + * if opcode > 0x7 and fin == 0: + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.PROTOCOL_ERROR, + * "Received fragmented control frame", +*/ + __pyx_t_10 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 459, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + + /* "aiohttp/_websocket/reader_py.py":460 + * if opcode > 0x7 and fin == 0: + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, # <<<<<<<<<<<<<< + * "Received fragmented control frame", + * ) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 460, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_PROTOCOL_ERROR); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 460, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_10); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_t_4, __pyx_mstate_global->__pyx_kp_u_Received_fragmented_control_fram}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 459, __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(0, 459, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":458 + * ) + * + * if opcode > 0x7 and fin == 0: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, +*/ + } + + /* "aiohttp/_websocket/reader_py.py":464 + * ) + * + * has_mask = (second_byte >> 7) & 1 # <<<<<<<<<<<<<< + * length = second_byte & 0x7F + * +*/ + __pyx_v_has_mask = ((__pyx_v_second_byte >> 7) & 1); + + /* "aiohttp/_websocket/reader_py.py":465 + * + * has_mask = (second_byte >> 7) & 1 + * length = second_byte & 0x7F # <<<<<<<<<<<<<< + * + * # Control frames MUST have a payload +*/ + __pyx_v_length = (__pyx_v_second_byte & 0x7F); + + /* "aiohttp/_websocket/reader_py.py":469 + * # Control frames MUST have a payload + * # length of 125 bytes or less + * if opcode > 0x7 and length > 125: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, +*/ + __pyx_t_6 = (__pyx_v_opcode > 0x7); + + if (__pyx_t_6) { + + } else { + + __pyx_t_9 = __pyx_t_6; + + goto __pyx_L27_bool_binop_done; + } + __pyx_t_6 = (__pyx_v_length > 0x7D); + + + __pyx_t_9 = __pyx_t_6; + + __pyx_L27_bool_binop_done:; + if (unlikely(__pyx_t_9)) { + + + /* "aiohttp/_websocket/reader_py.py":470 + * # length of 125 bytes or less + * if opcode > 0x7 and length > 125: + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.PROTOCOL_ERROR, + * "Control frame payload cannot be larger than 125 bytes", +*/ + __pyx_t_12 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 470, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "aiohttp/_websocket/reader_py.py":471 + * if opcode > 0x7 and length > 125: + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, # <<<<<<<<<<<<<< + * "Control frame payload cannot be larger than 125 bytes", + * ) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_PROTOCOL_ERROR); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_12); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_12, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Control_frame_payload_cannot_be}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 470, __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(0, 470, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":469 + * # Control frames MUST have a payload + * # length of 125 bytes or less + * if opcode > 0x7 and length > 125: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, +*/ + } + + /* "aiohttp/_websocket/reader_py.py":480 + * # https://datatracker.ietf.org/doc/html/rfc6455#section-5.4 + * # https://datatracker.ietf.org/doc/html/rfc7692#section-6.1 + * if opcode > 0x7: # <<<<<<<<<<<<<< + * if rsv1: + * raise WebSocketError( +*/ + __pyx_t_9 = (__pyx_v_opcode > 0x7); + + if (__pyx_t_9) { + + + /* "aiohttp/_websocket/reader_py.py":481 + * # https://datatracker.ietf.org/doc/html/rfc7692#section-6.1 + * if opcode > 0x7: + * if rsv1: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, +*/ + __pyx_t_9 = (__pyx_v_rsv1 != 0); + + if (unlikely(__pyx_t_9)) { + + + /* "aiohttp/_websocket/reader_py.py":482 + * if opcode > 0x7: + * if rsv1: + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.PROTOCOL_ERROR, + * "Received frame with non-zero reserved bits", +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "aiohttp/_websocket/reader_py.py":483 + * if rsv1: + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, # <<<<<<<<<<<<<< + * "Received frame with non-zero reserved bits", + * ) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 483, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_PROTOCOL_ERROR); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 483, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_10, __pyx_mstate_global->__pyx_kp_u_Received_frame_with_non_zero_res}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 482, __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(0, 482, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":481 + * # https://datatracker.ietf.org/doc/html/rfc7692#section-6.1 + * if opcode > 0x7: + * if rsv1: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, +*/ + } + + /* "aiohttp/_websocket/reader_py.py":480 + * # https://datatracker.ietf.org/doc/html/rfc6455#section-5.4 + * # https://datatracker.ietf.org/doc/html/rfc7692#section-6.1 + * if opcode > 0x7: # <<<<<<<<<<<<<< + * if rsv1: + * raise WebSocketError( +*/ + goto __pyx_L29; + } + + /* "aiohttp/_websocket/reader_py.py":490 + * # OR set compress status if this is first fragment + * # Raise error if not first fragment with rsv1 = 0x1 + * if self._frame_fin or self._compressed == COMPRESSED_NOT_SET: # <<<<<<<<<<<<<< + * self._compressed = COMPRESSED_TRUE if rsv1 else COMPRESSED_FALSE + * elif rsv1: +*/ + /*else*/ { + if (!__pyx_v_self->_frame_fin) { + } else { + + __pyx_t_9 = __pyx_v_self->_frame_fin; + goto __pyx_L32_bool_binop_done; + } + __pyx_t_6 = (__pyx_v_self->_compressed == __pyx_v_7aiohttp_10_websocket_8reader_c_COMPRESSED_NOT_SET); + + + __pyx_t_9 = __pyx_t_6; + + __pyx_L32_bool_binop_done:; + if (__pyx_t_9) { + + + /* "aiohttp/_websocket/reader_py.py":491 + * # Raise error if not first fragment with rsv1 = 0x1 + * if self._frame_fin or self._compressed == COMPRESSED_NOT_SET: + * self._compressed = COMPRESSED_TRUE if rsv1 else COMPRESSED_FALSE # <<<<<<<<<<<<<< + * elif rsv1: + * raise WebSocketError( +*/ + __pyx_t_9 = (__pyx_v_rsv1 != 0); + + if (__pyx_t_9) { + + __pyx_t_13 = __pyx_v_7aiohttp_10_websocket_8reader_c_COMPRESSED_TRUE; + } else { + + __pyx_t_13 = __pyx_v_7aiohttp_10_websocket_8reader_c_COMPRESSED_FALSE; + } + + __pyx_v_self->_compressed = __pyx_t_13; + + /* "aiohttp/_websocket/reader_py.py":490 + * # OR set compress status if this is first fragment + * # Raise error if not first fragment with rsv1 = 0x1 + * if self._frame_fin or self._compressed == COMPRESSED_NOT_SET: # <<<<<<<<<<<<<< + * self._compressed = COMPRESSED_TRUE if rsv1 else COMPRESSED_FALSE + * elif rsv1: +*/ + goto __pyx_L31; + } + + /* "aiohttp/_websocket/reader_py.py":492 + * if self._frame_fin or self._compressed == COMPRESSED_NOT_SET: + * self._compressed = COMPRESSED_TRUE if rsv1 else COMPRESSED_FALSE + * elif rsv1: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, +*/ + __pyx_t_9 = (__pyx_v_rsv1 != 0); + + if (unlikely(__pyx_t_9)) { + + + /* "aiohttp/_websocket/reader_py.py":493 + * self._compressed = COMPRESSED_TRUE if rsv1 else COMPRESSED_FALSE + * elif rsv1: + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.PROTOCOL_ERROR, + * "Received frame with non-zero reserved bits", +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + /* "aiohttp/_websocket/reader_py.py":494 + * elif rsv1: + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, # <<<<<<<<<<<<<< + * "Received frame with non-zero reserved bits", + * ) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_PROTOCOL_ERROR); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_10); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_10, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_12, __pyx_mstate_global->__pyx_kp_u_Received_frame_with_non_zero_res}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_10, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 493, __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(0, 493, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":492 + * if self._frame_fin or self._compressed == COMPRESSED_NOT_SET: + * self._compressed = COMPRESSED_TRUE if rsv1 else COMPRESSED_FALSE + * elif rsv1: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.PROTOCOL_ERROR, +*/ + } + __pyx_L31:; + + /* "aiohttp/_websocket/reader_py.py":497 + * "Received frame with non-zero reserved bits", + * ) + * self._frame_fin = bool(fin) # <<<<<<<<<<<<<< + * + * self._frame_opcode = opcode +*/ + __pyx_t_9 = __pyx_v_fin; + + __pyx_v_self->_frame_fin = (!(!__pyx_t_9)); + + } + __pyx_L29:; + + /* "aiohttp/_websocket/reader_py.py":499 + * self._frame_fin = bool(fin) + * + * self._frame_opcode = opcode # <<<<<<<<<<<<<< + * self._has_mask = bool(has_mask) + * self._payload_len_flag = length +*/ + __pyx_v_self->_frame_opcode = __pyx_v_opcode; + + /* "aiohttp/_websocket/reader_py.py":500 + * + * self._frame_opcode = opcode + * self._has_mask = bool(has_mask) # <<<<<<<<<<<<<< + * self._payload_len_flag = length + * self._state = READ_PAYLOAD_LENGTH +*/ + __pyx_t_9 = __pyx_v_has_mask; + + __pyx_v_self->_has_mask = (!(!__pyx_t_9)); + + + /* "aiohttp/_websocket/reader_py.py":501 + * self._frame_opcode = opcode + * self._has_mask = bool(has_mask) + * self._payload_len_flag = length # <<<<<<<<<<<<<< + * self._state = READ_PAYLOAD_LENGTH + * +*/ + __pyx_v_self->_payload_len_flag = __pyx_v_length; + + /* "aiohttp/_websocket/reader_py.py":502 + * self._has_mask = bool(has_mask) + * self._payload_len_flag = length + * self._state = READ_PAYLOAD_LENGTH # <<<<<<<<<<<<<< + * + * # read payload length +*/ + __pyx_v_self->_state = __pyx_v_7aiohttp_10_websocket_8reader_c_READ_PAYLOAD_LENGTH; + + /* "aiohttp/_websocket/reader_py.py":416 + * + * # read header + * if self._state == READ_HEADER: # <<<<<<<<<<<<<< + * if data_len - start_pos < 2: + * break +*/ + } + + /* "aiohttp/_websocket/reader_py.py":505 + * + * # read payload length + * if self._state == READ_PAYLOAD_LENGTH: # <<<<<<<<<<<<<< + * len_flag = self._payload_len_flag + * if len_flag == 126: +*/ + __pyx_t_9 = (__pyx_v_self->_state == __pyx_v_7aiohttp_10_websocket_8reader_c_READ_PAYLOAD_LENGTH); + + if (__pyx_t_9) { + + + /* "aiohttp/_websocket/reader_py.py":506 + * # read payload length + * if self._state == READ_PAYLOAD_LENGTH: + * len_flag = self._payload_len_flag # <<<<<<<<<<<<<< + * if len_flag == 126: + * if data_len - start_pos < 2: +*/ + __pyx_t_14 = __pyx_v_self->_payload_len_flag; + + __pyx_v_len_flag = __pyx_t_14; + + /* "aiohttp/_websocket/reader_py.py":507 + * if self._state == READ_PAYLOAD_LENGTH: + * len_flag = self._payload_len_flag + * if len_flag == 126: # <<<<<<<<<<<<<< + * if data_len - start_pos < 2: + * break +*/ + __pyx_t_9 = (__pyx_v_len_flag == 0x7E); + + if (__pyx_t_9) { + + + /* "aiohttp/_websocket/reader_py.py":508 + * len_flag = self._payload_len_flag + * if len_flag == 126: + * if data_len - start_pos < 2: # <<<<<<<<<<<<<< + * break + * first_byte = data_cstr[start_pos] +*/ + __pyx_t_9 = ((__pyx_v_data_len - __pyx_v_start_pos) < 2); + + if (__pyx_t_9) { + + + /* "aiohttp/_websocket/reader_py.py":509 + * if len_flag == 126: + * if data_len - start_pos < 2: + * break # <<<<<<<<<<<<<< + * first_byte = data_cstr[start_pos] + * second_byte = data_cstr[start_pos + 1] +*/ + goto __pyx_L5_break; + + /* "aiohttp/_websocket/reader_py.py":508 + * len_flag = self._payload_len_flag + * if len_flag == 126: + * if data_len - start_pos < 2: # <<<<<<<<<<<<<< + * break + * first_byte = data_cstr[start_pos] +*/ + } + + /* "aiohttp/_websocket/reader_py.py":510 + * if data_len - start_pos < 2: + * break + * first_byte = data_cstr[start_pos] # <<<<<<<<<<<<<< + * second_byte = data_cstr[start_pos + 1] + * start_pos += 2 +*/ + __pyx_v_first_byte = (__pyx_v_data_cstr[__pyx_v_start_pos]); + + /* "aiohttp/_websocket/reader_py.py":511 + * break + * first_byte = data_cstr[start_pos] + * second_byte = data_cstr[start_pos + 1] # <<<<<<<<<<<<<< + * start_pos += 2 + * self._payload_bytes_to_read = first_byte << 8 | second_byte +*/ + __pyx_v_second_byte = (__pyx_v_data_cstr[(__pyx_v_start_pos + 1)]); + + /* "aiohttp/_websocket/reader_py.py":512 + * first_byte = data_cstr[start_pos] + * second_byte = data_cstr[start_pos + 1] + * start_pos += 2 # <<<<<<<<<<<<<< + * self._payload_bytes_to_read = first_byte << 8 | second_byte + * elif len_flag > 126: +*/ + __pyx_v_start_pos = (__pyx_v_start_pos + 2); + + /* "aiohttp/_websocket/reader_py.py":513 + * second_byte = data_cstr[start_pos + 1] + * start_pos += 2 + * self._payload_bytes_to_read = first_byte << 8 | second_byte # <<<<<<<<<<<<<< + * elif len_flag > 126: + * if data_len - start_pos < 8: +*/ + __pyx_v_self->_payload_bytes_to_read = ((__pyx_v_first_byte << 8) | __pyx_v_second_byte); + + /* "aiohttp/_websocket/reader_py.py":507 + * if self._state == READ_PAYLOAD_LENGTH: + * len_flag = self._payload_len_flag + * if len_flag == 126: # <<<<<<<<<<<<<< + * if data_len - start_pos < 2: + * break +*/ + goto __pyx_L35; + } + + /* "aiohttp/_websocket/reader_py.py":514 + * start_pos += 2 + * self._payload_bytes_to_read = first_byte << 8 | second_byte + * elif len_flag > 126: # <<<<<<<<<<<<<< + * if data_len - start_pos < 8: + * break +*/ + __pyx_t_9 = (__pyx_v_len_flag > 0x7E); + + if (__pyx_t_9) { + + + /* "aiohttp/_websocket/reader_py.py":515 + * self._payload_bytes_to_read = first_byte << 8 | second_byte + * elif len_flag > 126: + * if data_len - start_pos < 8: # <<<<<<<<<<<<<< + * break + * # The declared length is an unsigned 64-bit integer that +*/ + __pyx_t_9 = ((__pyx_v_data_len - __pyx_v_start_pos) < 8); + + if (__pyx_t_9) { + + + /* "aiohttp/_websocket/reader_py.py":516 + * elif len_flag > 126: + * if data_len - start_pos < 8: + * break # <<<<<<<<<<<<<< + * # The declared length is an unsigned 64-bit integer that + * # does not necessarily fit _payload_bytes_to_read. +*/ + goto __pyx_L5_break; + + /* "aiohttp/_websocket/reader_py.py":515 + * self._payload_bytes_to_read = first_byte << 8 | second_byte + * elif len_flag > 126: + * if data_len - start_pos < 8: # <<<<<<<<<<<<<< + * break + * # The declared length is an unsigned 64-bit integer that +*/ + } + + /* "aiohttp/_websocket/reader_py.py":519 + * # The declared length is an unsigned 64-bit integer that + * # does not necessarily fit _payload_bytes_to_read. + * frame_len = UNPACK_LEN3(data, start_pos)[0] # <<<<<<<<<<<<<< + * if frame_len > MAX_PAYLOAD_LEN: + * raise WebSocketError( +*/ + __pyx_t_10 = NULL; + __Pyx_INCREF(__pyx_v_7aiohttp_10_websocket_8reader_c_UNPACK_LEN3); + __pyx_t_12 = __pyx_v_7aiohttp_10_websocket_8reader_c_UNPACK_LEN3; + __pyx_t_3 = PyLong_FromSsize_t(__pyx_v_start_pos); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_10); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_v_data, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_15 = __Pyx_PyLong_As_unsigned_PY_LONG_LONG(__pyx_t_12); if (unlikely((__pyx_t_15 == (unsigned PY_LONG_LONG)-1) && PyErr_Occurred())) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_v_frame_len = __pyx_t_15; + + /* "aiohttp/_websocket/reader_py.py":520 + * # does not necessarily fit _payload_bytes_to_read. + * frame_len = UNPACK_LEN3(data, start_pos)[0] + * if frame_len > MAX_PAYLOAD_LEN: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, +*/ + __pyx_t_9 = (__pyx_v_frame_len > __pyx_v_7aiohttp_10_websocket_8reader_c_MAX_PAYLOAD_LEN); + + if (unlikely(__pyx_t_9)) { + + + /* "aiohttp/_websocket/reader_py.py":521 + * frame_len = UNPACK_LEN3(data, start_pos)[0] + * if frame_len > MAX_PAYLOAD_LEN: + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.MESSAGE_TOO_BIG, + * f"Message size {int(frame_len) + len(self._partial)} " +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 521, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "aiohttp/_websocket/reader_py.py":522 + * if frame_len > MAX_PAYLOAD_LEN: + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, # <<<<<<<<<<<<<< + * f"Message size {int(frame_len) + len(self._partial)} " + * f"exceeds limit {self._max_msg_size or MAX_PAYLOAD_LEN}", +*/ + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_MESSAGE_TOO_BIG); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "aiohttp/_websocket/reader_py.py":523 + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, + * f"Message size {int(frame_len) + len(self._partial)} " # <<<<<<<<<<<<<< + * f"exceeds limit {self._max_msg_size or MAX_PAYLOAD_LEN}", + * ) +*/ + __pyx_t_10 = __Pyx_PyLong_From_unsigned_PY_LONG_LONG(__pyx_v_frame_len); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyLong_Type)), __pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __pyx_v_self->_partial; + __Pyx_INCREF(__pyx_t_10); + if (unlikely(__pyx_t_10 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type \047NoneType\047 has no len()"); + __PYX_ERR(0, 523, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_PyByteArray_GET_SIZE(__pyx_t_10); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = PyLong_FromSsize_t(__pyx_t_7); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + __pyx_t_16 = __Pyx_PyNumber_Add_int_int(__pyx_t_1, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyObject_FormatSimple(__pyx_t_16, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + + /* "aiohttp/_websocket/reader_py.py":524 + * WSCloseCode.MESSAGE_TOO_BIG, + * f"Message size {int(frame_len) + len(self._partial)} " + * f"exceeds limit {self._max_msg_size or MAX_PAYLOAD_LEN}", # <<<<<<<<<<<<<< + * ) + * self._payload_bytes_to_read = frame_len +*/ + if (!__pyx_v_self->_max_msg_size) { + } else { + + __pyx_t_15 = __pyx_v_self->_max_msg_size; + goto __pyx_L39_bool_binop_done; + } + + __pyx_t_15 = __pyx_v_7aiohttp_10_websocket_8reader_c_MAX_PAYLOAD_LEN; + __pyx_L39_bool_binop_done:; + __pyx_t_16 = __Pyx_PyUnicode_From_unsigned_PY_LONG_LONG(__pyx_t_15, 0, ' ', 'd'); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 524, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + + __pyx_t_17[0] = __pyx_mstate_global->__pyx_kp_u_Message_size; + __pyx_t_17[1] = __pyx_t_10; + __pyx_t_17[2] = __pyx_mstate_global->__pyx_kp_u_exceeds_limit; + __pyx_t_17[3] = __pyx_t_16; + + /* "aiohttp/_websocket/reader_py.py":523 + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, + * f"Message size {int(frame_len) + len(self._partial)} " # <<<<<<<<<<<<<< + * f"exceeds limit {self._max_msg_size or MAX_PAYLOAD_LEN}", + * ) +*/ + __pyx_t_7 = 28; + #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_17[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_17[3]); + #endif + __pyx_t_13 = 0; + #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH + __pyx_t_13 |= __Pyx_PyUnicode_KIND_04(__pyx_t_17[1]); + #endif + __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_17, 4, __pyx_t_7, __pyx_t_13); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_4, __pyx_t_1}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 521, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __Pyx_Raise(__pyx_t_12, 0, 0, 0); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __PYX_ERR(0, 521, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":520 + * # does not necessarily fit _payload_bytes_to_read. + * frame_len = UNPACK_LEN3(data, start_pos)[0] + * if frame_len > MAX_PAYLOAD_LEN: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, +*/ + } + + /* "aiohttp/_websocket/reader_py.py":526 + * f"exceeds limit {self._max_msg_size or MAX_PAYLOAD_LEN}", + * ) + * self._payload_bytes_to_read = frame_len # <<<<<<<<<<<<<< + * start_pos += 8 + * else: +*/ + __pyx_v_self->_payload_bytes_to_read = __pyx_v_frame_len; + + /* "aiohttp/_websocket/reader_py.py":527 + * ) + * self._payload_bytes_to_read = frame_len + * start_pos += 8 # <<<<<<<<<<<<<< + * else: + * self._payload_bytes_to_read = len_flag +*/ + __pyx_v_start_pos = (__pyx_v_start_pos + 8); + + /* "aiohttp/_websocket/reader_py.py":514 + * start_pos += 2 + * self._payload_bytes_to_read = first_byte << 8 | second_byte + * elif len_flag > 126: # <<<<<<<<<<<<<< + * if data_len - start_pos < 8: + * break +*/ + goto __pyx_L35; + } + + /* "aiohttp/_websocket/reader_py.py":529 + * start_pos += 8 + * else: + * self._payload_bytes_to_read = len_flag # <<<<<<<<<<<<<< + * + * # Reject oversized data frames before buffering any payload +*/ + /*else*/ { + __pyx_v_self->_payload_bytes_to_read = __pyx_v_len_flag; + } + __pyx_L35:; + + /* "aiohttp/_websocket/reader_py.py":534 + * # bytes. Control frames are capped at 125 bytes (checked in + * # READ_HEADER) so only text/binary/continuation need this. + * if self._max_msg_size and self._frame_opcode in { # <<<<<<<<<<<<<< + * OP_CODE_TEXT, + * OP_CODE_BINARY, +*/ + __pyx_t_6 = (__pyx_v_self->_max_msg_size != 0); + + if (__pyx_t_6) { + + } else { + + __pyx_t_9 = __pyx_t_6; + + goto __pyx_L42_bool_binop_done; + } + + __pyx_t_13 = __pyx_v_self->_frame_opcode; + + /* "aiohttp/_websocket/reader_py.py":535 + * # READ_HEADER) so only text/binary/continuation need this. + * if self._max_msg_size and self._frame_opcode in { + * OP_CODE_TEXT, # <<<<<<<<<<<<<< + * OP_CODE_BINARY, + * OP_CODE_CONTINUATION, +*/ + __pyx_t_18 = (__pyx_t_13 == __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_TEXT); + + if (!__pyx_t_18) { + + } else { + + __pyx_t_6 = __pyx_t_18; + + goto __pyx_L44_bool_binop_done; + } + + /* "aiohttp/_websocket/reader_py.py":534 + * # bytes. Control frames are capped at 125 bytes (checked in + * # READ_HEADER) so only text/binary/continuation need this. + * if self._max_msg_size and self._frame_opcode in { # <<<<<<<<<<<<<< + * OP_CODE_TEXT, + * OP_CODE_BINARY, +*/ + __pyx_t_18 = (__pyx_t_13 == __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_BINARY); + + if (!__pyx_t_18) { + + } else { + + __pyx_t_6 = __pyx_t_18; + + goto __pyx_L44_bool_binop_done; + } + + /* "aiohttp/_websocket/reader_py.py":537 + * OP_CODE_TEXT, + * OP_CODE_BINARY, + * OP_CODE_CONTINUATION, # <<<<<<<<<<<<<< + * }: + * # partial_len declared in reader_c.pxd to keep it in C. +*/ + __pyx_t_18 = (__pyx_t_13 == __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_CONTINUATION); + + + __pyx_t_6 = __pyx_t_18; + + __pyx_L44_bool_binop_done:; + + /* "aiohttp/_websocket/reader_py.py":534 + * # bytes. Control frames are capped at 125 bytes (checked in + * # READ_HEADER) so only text/binary/continuation need this. + * if self._max_msg_size and self._frame_opcode in { # <<<<<<<<<<<<<< + * OP_CODE_TEXT, + * OP_CODE_BINARY, +*/ + __pyx_t_18 = __pyx_t_6; + + + + __pyx_t_9 = __pyx_t_18; + + __pyx_L42_bool_binop_done:; + if (__pyx_t_9) { + + + /* "aiohttp/_websocket/reader_py.py":540 + * }: + * # partial_len declared in reader_c.pxd to keep it in C. + * partial_len = len(self._partial) # <<<<<<<<<<<<<< + * # payload_bytes_to_read is a signed Py_ssize_t C value, + * # use subtraction here to avoid an integer overflow. +*/ + __pyx_t_12 = __pyx_v_self->_partial; + __Pyx_INCREF(__pyx_t_12); + if (unlikely(__pyx_t_12 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type \047NoneType\047 has no len()"); + __PYX_ERR(0, 540, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_PyByteArray_GET_SIZE(__pyx_t_12); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 540, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_v_partial_len = __pyx_t_7; + + /* "aiohttp/_websocket/reader_py.py":543 + * # payload_bytes_to_read is a signed Py_ssize_t C value, + * # use subtraction here to avoid an integer overflow. + * if self._payload_bytes_to_read >= self._max_msg_size - partial_len: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, +*/ + __pyx_t_9 = (__pyx_v_self->_payload_bytes_to_read >= (__pyx_v_self->_max_msg_size - __pyx_v_partial_len)); + + if (unlikely(__pyx_t_9)) { + + + /* "aiohttp/_websocket/reader_py.py":544 + * # use subtraction here to avoid an integer overflow. + * if self._payload_bytes_to_read >= self._max_msg_size - partial_len: + * raise WebSocketError( # <<<<<<<<<<<<<< + * WSCloseCode.MESSAGE_TOO_BIG, + * f"Message size {int(self._payload_bytes_to_read) + partial_len} " +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_WebSocketError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 544, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "aiohttp/_websocket/reader_py.py":545 + * if self._payload_bytes_to_read >= self._max_msg_size - partial_len: + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, # <<<<<<<<<<<<<< + * f"Message size {int(self._payload_bytes_to_read) + partial_len} " + * f"exceeds limit {self._max_msg_size}", +*/ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_MESSAGE_TOO_BIG); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "aiohttp/_websocket/reader_py.py":546 + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, + * f"Message size {int(self._payload_bytes_to_read) + partial_len} " # <<<<<<<<<<<<<< + * f"exceeds limit {self._max_msg_size}", + * ) +*/ + __pyx_t_4 = PyLong_FromSsize_t(__pyx_v_self->_payload_bytes_to_read); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 546, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_16 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyLong_Type)), __pyx_t_4); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 546, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyLong_FromSsize_t(__pyx_v_partial_len); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 546, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_10 = __Pyx_PyNumber_Add_int_int(__pyx_t_16, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 546, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_t_10, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 546, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "aiohttp/_websocket/reader_py.py":547 + * WSCloseCode.MESSAGE_TOO_BIG, + * f"Message size {int(self._payload_bytes_to_read) + partial_len} " + * f"exceeds limit {self._max_msg_size}", # <<<<<<<<<<<<<< + * ) + * +*/ + __pyx_t_10 = __Pyx_PyUnicode_From_unsigned_int(__pyx_v_self->_max_msg_size, 0, ' ', 'd'); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_17[0] = __pyx_mstate_global->__pyx_kp_u_Message_size; + __pyx_t_17[1] = __pyx_t_4; + __pyx_t_17[2] = __pyx_mstate_global->__pyx_kp_u_exceeds_limit; + __pyx_t_17[3] = __pyx_t_10; + + /* "aiohttp/_websocket/reader_py.py":546 + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, + * f"Message size {int(self._payload_bytes_to_read) + partial_len} " # <<<<<<<<<<<<<< + * f"exceeds limit {self._max_msg_size}", + * ) +*/ + __pyx_t_7 = 28; + #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_17[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_17[3]); + #endif + __pyx_t_13 = 0; + #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH + __pyx_t_13 |= __Pyx_PyUnicode_KIND_04(__pyx_t_17[1]); + #endif + __pyx_t_16 = __Pyx_PyUnicode_Join(__pyx_t_17, 4, __pyx_t_7, __pyx_t_13); + if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 546, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_1, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_2, __pyx_t_16}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_1, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 544, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __Pyx_Raise(__pyx_t_12, 0, 0, 0); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __PYX_ERR(0, 544, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":543 + * # payload_bytes_to_read is a signed Py_ssize_t C value, + * # use subtraction here to avoid an integer overflow. + * if self._payload_bytes_to_read >= self._max_msg_size - partial_len: # <<<<<<<<<<<<<< + * raise WebSocketError( + * WSCloseCode.MESSAGE_TOO_BIG, +*/ + } + + /* "aiohttp/_websocket/reader_py.py":534 + * # bytes. Control frames are capped at 125 bytes (checked in + * # READ_HEADER) so only text/binary/continuation need this. + * if self._max_msg_size and self._frame_opcode in { # <<<<<<<<<<<<<< + * OP_CODE_TEXT, + * OP_CODE_BINARY, +*/ + } + + /* "aiohttp/_websocket/reader_py.py":550 + * ) + * + * self._state = READ_PAYLOAD_MASK if self._has_mask else READ_PAYLOAD # <<<<<<<<<<<<<< + * + * # read payload mask +*/ + if (__pyx_v_self->_has_mask) { + + __pyx_t_14 = __pyx_v_7aiohttp_10_websocket_8reader_c_READ_PAYLOAD_MASK; + } else { + + __pyx_t_14 = __pyx_v_7aiohttp_10_websocket_8reader_c_READ_PAYLOAD; + } + __pyx_v_self->_state = __pyx_t_14; + + /* "aiohttp/_websocket/reader_py.py":505 + * + * # read payload length + * if self._state == READ_PAYLOAD_LENGTH: # <<<<<<<<<<<<<< + * len_flag = self._payload_len_flag + * if len_flag == 126: +*/ + } + + /* "aiohttp/_websocket/reader_py.py":553 + * + * # read payload mask + * if self._state == READ_PAYLOAD_MASK: # <<<<<<<<<<<<<< + * if data_len - start_pos < 4: + * break +*/ + __pyx_t_9 = (__pyx_v_self->_state == __pyx_v_7aiohttp_10_websocket_8reader_c_READ_PAYLOAD_MASK); + + if (__pyx_t_9) { + + + /* "aiohttp/_websocket/reader_py.py":554 + * # read payload mask + * if self._state == READ_PAYLOAD_MASK: + * if data_len - start_pos < 4: # <<<<<<<<<<<<<< + * break + * self._frame_mask = data_cstr[start_pos : start_pos + 4] +*/ + __pyx_t_9 = ((__pyx_v_data_len - __pyx_v_start_pos) < 4); + + if (__pyx_t_9) { + + + /* "aiohttp/_websocket/reader_py.py":555 + * if self._state == READ_PAYLOAD_MASK: + * if data_len - start_pos < 4: + * break # <<<<<<<<<<<<<< + * self._frame_mask = data_cstr[start_pos : start_pos + 4] + * start_pos += 4 +*/ + goto __pyx_L5_break; + + /* "aiohttp/_websocket/reader_py.py":554 + * # read payload mask + * if self._state == READ_PAYLOAD_MASK: + * if data_len - start_pos < 4: # <<<<<<<<<<<<<< + * break + * self._frame_mask = data_cstr[start_pos : start_pos + 4] +*/ + } + + /* "aiohttp/_websocket/reader_py.py":556 + * if data_len - start_pos < 4: + * break + * self._frame_mask = data_cstr[start_pos : start_pos + 4] # <<<<<<<<<<<<<< + * start_pos += 4 + * self._state = READ_PAYLOAD +*/ + __pyx_t_12 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_data_cstr) + __pyx_v_start_pos, (__pyx_v_start_pos + 4) - __pyx_v_start_pos); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_GIVEREF(__pyx_t_12); + __Pyx_GOTREF(__pyx_v_self->_frame_mask); + __Pyx_DECREF(__pyx_v_self->_frame_mask); + __pyx_v_self->_frame_mask = ((PyObject*)__pyx_t_12); + __pyx_t_12 = 0; + + /* "aiohttp/_websocket/reader_py.py":557 + * break + * self._frame_mask = data_cstr[start_pos : start_pos + 4] + * start_pos += 4 # <<<<<<<<<<<<<< + * self._state = READ_PAYLOAD + * +*/ + __pyx_v_start_pos = (__pyx_v_start_pos + 4); + + /* "aiohttp/_websocket/reader_py.py":558 + * self._frame_mask = data_cstr[start_pos : start_pos + 4] + * start_pos += 4 + * self._state = READ_PAYLOAD # <<<<<<<<<<<<<< + * + * if self._state == READ_PAYLOAD: +*/ + __pyx_v_self->_state = __pyx_v_7aiohttp_10_websocket_8reader_c_READ_PAYLOAD; + + /* "aiohttp/_websocket/reader_py.py":553 + * + * # read payload mask + * if self._state == READ_PAYLOAD_MASK: # <<<<<<<<<<<<<< + * if data_len - start_pos < 4: + * break +*/ + } + + /* "aiohttp/_websocket/reader_py.py":560 + * self._state = READ_PAYLOAD + * + * if self._state == READ_PAYLOAD: # <<<<<<<<<<<<<< + * chunk_len = data_len - start_pos + * if self._payload_bytes_to_read >= chunk_len: +*/ + __pyx_t_9 = (__pyx_v_self->_state == __pyx_v_7aiohttp_10_websocket_8reader_c_READ_PAYLOAD); + + if (__pyx_t_9) { + + + /* "aiohttp/_websocket/reader_py.py":561 + * + * if self._state == READ_PAYLOAD: + * chunk_len = data_len - start_pos # <<<<<<<<<<<<<< + * if self._payload_bytes_to_read >= chunk_len: + * f_end_pos = data_len +*/ + __pyx_v_chunk_len = (__pyx_v_data_len - __pyx_v_start_pos); + + /* "aiohttp/_websocket/reader_py.py":562 + * if self._state == READ_PAYLOAD: + * chunk_len = data_len - start_pos + * if self._payload_bytes_to_read >= chunk_len: # <<<<<<<<<<<<<< + * f_end_pos = data_len + * self._payload_bytes_to_read -= chunk_len +*/ + __pyx_t_9 = (__pyx_v_self->_payload_bytes_to_read >= __pyx_v_chunk_len); + + if (__pyx_t_9) { + + + /* "aiohttp/_websocket/reader_py.py":563 + * chunk_len = data_len - start_pos + * if self._payload_bytes_to_read >= chunk_len: + * f_end_pos = data_len # <<<<<<<<<<<<<< + * self._payload_bytes_to_read -= chunk_len + * else: +*/ + __pyx_v_f_end_pos = __pyx_v_data_len; + + /* "aiohttp/_websocket/reader_py.py":564 + * if self._payload_bytes_to_read >= chunk_len: + * f_end_pos = data_len + * self._payload_bytes_to_read -= chunk_len # <<<<<<<<<<<<<< + * else: + * f_end_pos = start_pos + self._payload_bytes_to_read +*/ + __pyx_v_self->_payload_bytes_to_read = (__pyx_v_self->_payload_bytes_to_read - __pyx_v_chunk_len); + + /* "aiohttp/_websocket/reader_py.py":562 + * if self._state == READ_PAYLOAD: + * chunk_len = data_len - start_pos + * if self._payload_bytes_to_read >= chunk_len: # <<<<<<<<<<<<<< + * f_end_pos = data_len + * self._payload_bytes_to_read -= chunk_len +*/ + goto __pyx_L51; + } + + /* "aiohttp/_websocket/reader_py.py":566 + * self._payload_bytes_to_read -= chunk_len + * else: + * f_end_pos = start_pos + self._payload_bytes_to_read # <<<<<<<<<<<<<< + * self._payload_bytes_to_read = 0 + * +*/ + /*else*/ { + __pyx_v_f_end_pos = (__pyx_v_start_pos + __pyx_v_self->_payload_bytes_to_read); + + /* "aiohttp/_websocket/reader_py.py":567 + * else: + * f_end_pos = start_pos + self._payload_bytes_to_read + * self._payload_bytes_to_read = 0 # <<<<<<<<<<<<<< + * + * had_fragments = self._frame_payload_len +*/ + __pyx_v_self->_payload_bytes_to_read = 0; + } + __pyx_L51:; + + /* "aiohttp/_websocket/reader_py.py":569 + * self._payload_bytes_to_read = 0 + * + * had_fragments = self._frame_payload_len # <<<<<<<<<<<<<< + * self._frame_payload_len += f_end_pos - start_pos + * f_start_pos = start_pos +*/ + __pyx_t_7 = __pyx_v_self->_frame_payload_len; + + __pyx_v_had_fragments = __pyx_t_7; + + /* "aiohttp/_websocket/reader_py.py":570 + * + * had_fragments = self._frame_payload_len + * self._frame_payload_len += f_end_pos - start_pos # <<<<<<<<<<<<<< + * f_start_pos = start_pos + * start_pos = f_end_pos +*/ + __pyx_v_self->_frame_payload_len = (__pyx_v_self->_frame_payload_len + (__pyx_v_f_end_pos - __pyx_v_start_pos)); + + /* "aiohttp/_websocket/reader_py.py":571 + * had_fragments = self._frame_payload_len + * self._frame_payload_len += f_end_pos - start_pos + * f_start_pos = start_pos # <<<<<<<<<<<<<< + * start_pos = f_end_pos + * +*/ + __pyx_v_f_start_pos = __pyx_v_start_pos; + + /* "aiohttp/_websocket/reader_py.py":572 + * self._frame_payload_len += f_end_pos - start_pos + * f_start_pos = start_pos + * start_pos = f_end_pos # <<<<<<<<<<<<<< + * + * if self._payload_bytes_to_read != 0: +*/ + __pyx_v_start_pos = __pyx_v_f_end_pos; + + /* "aiohttp/_websocket/reader_py.py":574 + * start_pos = f_end_pos + * + * if self._payload_bytes_to_read != 0: # <<<<<<<<<<<<<< + * # If we don't have a complete frame, we need to save the + * # data for the next call to feed_data. +*/ + __pyx_t_9 = (__pyx_v_self->_payload_bytes_to_read != 0); + + if (__pyx_t_9) { + + + /* "aiohttp/_websocket/reader_py.py":577 + * # If we don't have a complete frame, we need to save the + * # data for the next call to feed_data. + * self._payload_fragments.append(data_cstr[f_start_pos:f_end_pos]) # <<<<<<<<<<<<<< + * if ( + * self._max_fragments +*/ + if (unlikely(__pyx_v_self->_payload_fragments == Py_None)) { + PyErr_Format(PyExc_AttributeError, "\047NoneType\047 object has no attribute \047%.30s\047", "append"); + __PYX_ERR(0, 577, __pyx_L1_error) + } + __pyx_t_12 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_data_cstr) + __pyx_v_f_start_pos, __pyx_v_f_end_pos - __pyx_v_f_start_pos); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_19 = __Pyx_PyList_Append(__pyx_v_self->_payload_fragments, __pyx_t_12); if (unlikely(__pyx_t_19 == ((int)-1))) __PYX_ERR(0, 577, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + + /* "aiohttp/_websocket/reader_py.py":579 + * self._payload_fragments.append(data_cstr[f_start_pos:f_end_pos]) + * if ( + * self._max_fragments # <<<<<<<<<<<<<< + * and len(self._payload_fragments) > self._max_fragments + * and not self.queue._protocol._reading_paused +*/ + __pyx_t_18 = (__pyx_v_self->_max_fragments != 0); + + if (__pyx_t_18) { + + } else { + + __pyx_t_9 = __pyx_t_18; + + goto __pyx_L54_bool_binop_done; + } + + /* "aiohttp/_websocket/reader_py.py":580 + * if ( + * self._max_fragments + * and len(self._payload_fragments) > self._max_fragments # <<<<<<<<<<<<<< + * and not self.queue._protocol._reading_paused + * ): +*/ + __pyx_t_12 = __pyx_v_self->_payload_fragments; + __Pyx_INCREF(__pyx_t_12); + if (unlikely(__pyx_t_12 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type \047NoneType\047 has no len()"); + __PYX_ERR(0, 580, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_PyList_GET_SIZE(__pyx_t_12); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 580, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_18 = (__pyx_t_7 > __pyx_v_self->_max_fragments); + + + if (__pyx_t_18) { + + } else { + + __pyx_t_9 = __pyx_t_18; + + goto __pyx_L54_bool_binop_done; + } + + /* "aiohttp/_websocket/reader_py.py":581 + * self._max_fragments + * and len(self._payload_fragments) > self._max_fragments + * and not self.queue._protocol._reading_paused # <<<<<<<<<<<<<< + * ): + * self.queue._protocol.pause_reading() +*/ + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->queue->_protocol, __pyx_mstate_global->__pyx_n_u_reading_paused); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_t_12); if (unlikely((__pyx_t_18 < 0))) __PYX_ERR(0, 581, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_6 = (!__pyx_t_18); + + + + __pyx_t_9 = __pyx_t_6; + + __pyx_L54_bool_binop_done:; + + /* "aiohttp/_websocket/reader_py.py":578 + * # data for the next call to feed_data. + * self._payload_fragments.append(data_cstr[f_start_pos:f_end_pos]) + * if ( # <<<<<<<<<<<<<< + * self._max_fragments + * and len(self._payload_fragments) > self._max_fragments +*/ + if (__pyx_t_9) { + + + /* "aiohttp/_websocket/reader_py.py":583 + * and not self.queue._protocol._reading_paused + * ): + * self.queue._protocol.pause_reading() # <<<<<<<<<<<<<< + * break + * +*/ + __pyx_t_1 = __pyx_v_self->queue->_protocol; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_12 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_pause_reading, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + /* "aiohttp/_websocket/reader_py.py":578 + * # data for the next call to feed_data. + * self._payload_fragments.append(data_cstr[f_start_pos:f_end_pos]) + * if ( # <<<<<<<<<<<<<< + * self._max_fragments + * and len(self._payload_fragments) > self._max_fragments +*/ + } + + /* "aiohttp/_websocket/reader_py.py":584 + * ): + * self.queue._protocol.pause_reading() + * break # <<<<<<<<<<<<<< + * + * payload: bytes | bytearray +*/ + goto __pyx_L5_break; + + /* "aiohttp/_websocket/reader_py.py":574 + * start_pos = f_end_pos + * + * if self._payload_bytes_to_read != 0: # <<<<<<<<<<<<<< + * # If we don't have a complete frame, we need to save the + * # data for the next call to feed_data. +*/ + } + + /* "aiohttp/_websocket/reader_py.py":587 + * + * payload: bytes | bytearray + * if had_fragments: # <<<<<<<<<<<<<< + * # We have to join the payload fragments get the payload + * self._payload_fragments.append(data_cstr[f_start_pos:f_end_pos]) +*/ + __pyx_t_9 = (__pyx_v_had_fragments != 0); + + if (__pyx_t_9) { + + + /* "aiohttp/_websocket/reader_py.py":589 + * if had_fragments: + * # We have to join the payload fragments get the payload + * self._payload_fragments.append(data_cstr[f_start_pos:f_end_pos]) # <<<<<<<<<<<<<< + * if self._has_mask: + * assert self._frame_mask is not None +*/ + if (unlikely(__pyx_v_self->_payload_fragments == Py_None)) { + PyErr_Format(PyExc_AttributeError, "\047NoneType\047 object has no attribute \047%.30s\047", "append"); + __PYX_ERR(0, 589, __pyx_L1_error) + } + __pyx_t_12 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_data_cstr) + __pyx_v_f_start_pos, __pyx_v_f_end_pos - __pyx_v_f_start_pos); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_19 = __Pyx_PyList_Append(__pyx_v_self->_payload_fragments, __pyx_t_12); if (unlikely(__pyx_t_19 == ((int)-1))) __PYX_ERR(0, 589, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + + /* "aiohttp/_websocket/reader_py.py":590 + * # We have to join the payload fragments get the payload + * self._payload_fragments.append(data_cstr[f_start_pos:f_end_pos]) + * if self._has_mask: # <<<<<<<<<<<<<< + * assert self._frame_mask is not None + * payload_bytearray = bytearray(b"".join(self._payload_fragments)) +*/ + if (__pyx_v_self->_has_mask) { + + /* "aiohttp/_websocket/reader_py.py":591 + * self._payload_fragments.append(data_cstr[f_start_pos:f_end_pos]) + * if self._has_mask: + * assert self._frame_mask is not None # <<<<<<<<<<<<<< + * payload_bytearray = bytearray(b"".join(self._payload_fragments)) + * websocket_mask(self._frame_mask, payload_bytearray) +*/ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_9 = (__pyx_v_self->_frame_mask != ((PyObject*)Py_None)); + if (unlikely(!__pyx_t_9)) { + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_AssertionError))), 0, 0, 0); + __PYX_ERR(0, 591, __pyx_L1_error) + } + + } + #else + if ((1)); else __PYX_ERR(0, 591, __pyx_L1_error) + #endif + + /* "aiohttp/_websocket/reader_py.py":592 + * if self._has_mask: + * assert self._frame_mask is not None + * payload_bytearray = bytearray(b"".join(self._payload_fragments)) # <<<<<<<<<<<<<< + * websocket_mask(self._frame_mask, payload_bytearray) + * payload = payload_bytearray +*/ + __pyx_t_1 = NULL; + __pyx_t_16 = __pyx_v_self->_payload_fragments; + __Pyx_INCREF(__pyx_t_16); + __pyx_t_2 = __Pyx_PyBytes_Join(__pyx_mstate_global->__pyx_kp_b__3, __pyx_t_16); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_2}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)(&PyByteArray_Type), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __Pyx_XDECREF_SET(__pyx_v_payload_bytearray, ((PyObject*)__pyx_t_12)); + __pyx_t_12 = 0; + + /* "aiohttp/_websocket/reader_py.py":593 + * assert self._frame_mask is not None + * payload_bytearray = bytearray(b"".join(self._payload_fragments)) + * websocket_mask(self._frame_mask, payload_bytearray) # <<<<<<<<<<<<<< + * payload = payload_bytearray + * else: +*/ + __pyx_t_12 = __pyx_v_self->_frame_mask; + __Pyx_INCREF(__pyx_t_12); + __pyx_f_7aiohttp_10_websocket_4mask__websocket_mask_cython(((PyObject*)__pyx_t_12), __pyx_v_payload_bytearray, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 593, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + /* "aiohttp/_websocket/reader_py.py":594 + * payload_bytearray = bytearray(b"".join(self._payload_fragments)) + * websocket_mask(self._frame_mask, payload_bytearray) + * payload = payload_bytearray # <<<<<<<<<<<<<< + * else: + * payload = b"".join(self._payload_fragments) +*/ + __Pyx_INCREF(__pyx_v_payload_bytearray); + __Pyx_XDECREF_SET(__pyx_v_payload, __pyx_v_payload_bytearray); + + /* "aiohttp/_websocket/reader_py.py":590 + * # We have to join the payload fragments get the payload + * self._payload_fragments.append(data_cstr[f_start_pos:f_end_pos]) + * if self._has_mask: # <<<<<<<<<<<<<< + * assert self._frame_mask is not None + * payload_bytearray = bytearray(b"".join(self._payload_fragments)) +*/ + goto __pyx_L58; + } + + /* "aiohttp/_websocket/reader_py.py":596 + * payload = payload_bytearray + * else: + * payload = b"".join(self._payload_fragments) # <<<<<<<<<<<<<< + * self._payload_fragments.clear() + * elif self._has_mask: +*/ + /*else*/ { + __pyx_t_12 = __pyx_v_self->_payload_fragments; + __Pyx_INCREF(__pyx_t_12); + __pyx_t_2 = __Pyx_PyBytes_Join(__pyx_mstate_global->__pyx_kp_b__3, __pyx_t_12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 596, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF_SET(__pyx_v_payload, __pyx_t_2); + __pyx_t_2 = 0; + } + __pyx_L58:; + + /* "aiohttp/_websocket/reader_py.py":597 + * else: + * payload = b"".join(self._payload_fragments) + * self._payload_fragments.clear() # <<<<<<<<<<<<<< + * elif self._has_mask: + * assert self._frame_mask is not None +*/ + __pyx_t_12 = __pyx_v_self->_payload_fragments; + __Pyx_INCREF(__pyx_t_12); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_clear, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":587 + * + * payload: bytes | bytearray + * if had_fragments: # <<<<<<<<<<<<<< + * # We have to join the payload fragments get the payload + * self._payload_fragments.append(data_cstr[f_start_pos:f_end_pos]) +*/ + goto __pyx_L57; + } + + /* "aiohttp/_websocket/reader_py.py":598 + * payload = b"".join(self._payload_fragments) + * self._payload_fragments.clear() + * elif self._has_mask: # <<<<<<<<<<<<<< + * assert self._frame_mask is not None + * payload_bytearray = data_cstr[f_start_pos:f_end_pos] # type: ignore[assignment] +*/ + if (__pyx_v_self->_has_mask) { + + /* "aiohttp/_websocket/reader_py.py":599 + * self._payload_fragments.clear() + * elif self._has_mask: + * assert self._frame_mask is not None # <<<<<<<<<<<<<< + * payload_bytearray = data_cstr[f_start_pos:f_end_pos] # type: ignore[assignment] + * if type(payload_bytearray) is not bytearray: +*/ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_9 = (__pyx_v_self->_frame_mask != ((PyObject*)Py_None)); + if (unlikely(!__pyx_t_9)) { + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_AssertionError))), 0, 0, 0); + __PYX_ERR(0, 599, __pyx_L1_error) + } + + } + #else + if ((1)); else __PYX_ERR(0, 599, __pyx_L1_error) + #endif + + /* "aiohttp/_websocket/reader_py.py":600 + * elif self._has_mask: + * assert self._frame_mask is not None + * payload_bytearray = data_cstr[f_start_pos:f_end_pos] # type: ignore[assignment] # <<<<<<<<<<<<<< + * if type(payload_bytearray) is not bytearray: + * # Cython will do the conversion for us +*/ + __pyx_t_2 = __Pyx_PyByteArray_FromStringAndSize(((char const *)__pyx_v_data_cstr) + __pyx_v_f_start_pos, __pyx_v_f_end_pos - __pyx_v_f_start_pos); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_payload_bytearray, ((PyObject*)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":601 + * assert self._frame_mask is not None + * payload_bytearray = data_cstr[f_start_pos:f_end_pos] # type: ignore[assignment] + * if type(payload_bytearray) is not bytearray: # <<<<<<<<<<<<<< + * # Cython will do the conversion for us + * # but we need to do it for Python and we +*/ + __pyx_t_9 = (((PyObject *)Py_TYPE(__pyx_v_payload_bytearray)) != ((PyObject *)(&PyByteArray_Type))); + if (__pyx_t_9) { + + + /* "aiohttp/_websocket/reader_py.py":605 + * # but we need to do it for Python and we + * # will always get here in Python + * payload_bytearray = bytearray(payload_bytearray) # <<<<<<<<<<<<<< + * websocket_mask(self._frame_mask, payload_bytearray) + * payload = payload_bytearray +*/ + __pyx_t_12 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_v_payload_bytearray}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(&PyByteArray_Type), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_DECREF_SET(__pyx_v_payload_bytearray, ((PyObject*)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":601 + * assert self._frame_mask is not None + * payload_bytearray = data_cstr[f_start_pos:f_end_pos] # type: ignore[assignment] + * if type(payload_bytearray) is not bytearray: # <<<<<<<<<<<<<< + * # Cython will do the conversion for us + * # but we need to do it for Python and we +*/ + } + + /* "aiohttp/_websocket/reader_py.py":606 + * # will always get here in Python + * payload_bytearray = bytearray(payload_bytearray) + * websocket_mask(self._frame_mask, payload_bytearray) # <<<<<<<<<<<<<< + * payload = payload_bytearray + * else: +*/ + __pyx_t_2 = __pyx_v_self->_frame_mask; + __Pyx_INCREF(__pyx_t_2); + __pyx_f_7aiohttp_10_websocket_4mask__websocket_mask_cython(((PyObject*)__pyx_t_2), __pyx_v_payload_bytearray, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 606, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":607 + * payload_bytearray = bytearray(payload_bytearray) + * websocket_mask(self._frame_mask, payload_bytearray) + * payload = payload_bytearray # <<<<<<<<<<<<<< + * else: + * payload = data_cstr[f_start_pos:f_end_pos] +*/ + __Pyx_INCREF(__pyx_v_payload_bytearray); + __Pyx_XDECREF_SET(__pyx_v_payload, __pyx_v_payload_bytearray); + + /* "aiohttp/_websocket/reader_py.py":598 + * payload = b"".join(self._payload_fragments) + * self._payload_fragments.clear() + * elif self._has_mask: # <<<<<<<<<<<<<< + * assert self._frame_mask is not None + * payload_bytearray = data_cstr[f_start_pos:f_end_pos] # type: ignore[assignment] +*/ + goto __pyx_L57; + } + + /* "aiohttp/_websocket/reader_py.py":609 + * payload = payload_bytearray + * else: + * payload = data_cstr[f_start_pos:f_end_pos] # <<<<<<<<<<<<<< + * + * self._handle_frame( +*/ + /*else*/ { + __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_data_cstr) + __pyx_v_f_start_pos, __pyx_v_f_end_pos - __pyx_v_f_start_pos); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 609, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_payload, __pyx_t_2); + __pyx_t_2 = 0; + } + __pyx_L57:; + + /* "aiohttp/_websocket/reader_py.py":611 + * payload = data_cstr[f_start_pos:f_end_pos] + * + * self._handle_frame( # <<<<<<<<<<<<<< + * self._frame_fin, self._frame_opcode, payload, self._compressed + * ) +*/ + ((struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketReader *)__pyx_v_self->__pyx_vtab)->_handle_frame(__pyx_v_self, __pyx_v_self->_frame_fin, __pyx_v_self->_frame_opcode, __pyx_v_payload, __pyx_v_self->_compressed, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 611, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":614 + * self._frame_fin, self._frame_opcode, payload, self._compressed + * ) + * self._frame_payload_len = 0 # <<<<<<<<<<<<<< + * self._state = READ_HEADER + * +*/ + __pyx_v_self->_frame_payload_len = 0; + + /* "aiohttp/_websocket/reader_py.py":615 + * ) + * self._frame_payload_len = 0 + * self._state = READ_HEADER # <<<<<<<<<<<<<< + * + * # XXX: Cython needs slices to be bounded, so we can't omit the slice end here. +*/ + __pyx_v_self->_state = __pyx_v_7aiohttp_10_websocket_8reader_c_READ_HEADER; + + /* "aiohttp/_websocket/reader_py.py":560 + * self._state = READ_PAYLOAD + * + * if self._state == READ_PAYLOAD: # <<<<<<<<<<<<<< + * chunk_len = data_len - start_pos + * if self._payload_bytes_to_read >= chunk_len: +*/ + } + } + __pyx_L5_break:; + + /* "aiohttp/_websocket/reader_py.py":618 + * + * # XXX: Cython needs slices to be bounded, so we can't omit the slice end here. + * self._tail = data_cstr[start_pos:data_len] if start_pos < data_len else b"" # <<<<<<<<<<<<<< +*/ + __pyx_t_9 = (__pyx_v_start_pos < __pyx_v_data_len); + + if (__pyx_t_9) { + __pyx_t_12 = __Pyx_PyBytes_FromStringAndSize(((char const *)__pyx_v_data_cstr) + __pyx_v_start_pos, __pyx_v_data_len - __pyx_v_start_pos); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_2 = __pyx_t_12; + __pyx_t_12 = 0; + } else { + __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_b__3); + __pyx_t_2 = __pyx_mstate_global->__pyx_kp_b__3; + } + + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->_tail); + __Pyx_DECREF(__pyx_v_self->_tail); + __pyx_v_self->_tail = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":396 + * ) + * + * def _feed_data(self, data: bytes) -> None: # <<<<<<<<<<<<<< + * """Return the next frame from the socket.""" + * self.queue._stalled_reader = None +*/ + + /* function exit code */ + 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_10); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_16); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketReader._feed_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + + + + + + + + + + + + + + + __Pyx_XDECREF(__pyx_v_payload_bytearray); + + + + + + __Pyx_XDECREF(__pyx_v_payload); + __Pyx_XDECREF(__pyx_v_data); + + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_9_feed_data(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_7aiohttp_10_websocket_8reader_c_15WebSocketReader_8_feed_data, "Return the next frame from the socket."); +static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_8reader_c_15WebSocketReader_9_feed_data = {"_feed_data", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_9_feed_data, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7aiohttp_10_websocket_8reader_c_15WebSocketReader_8_feed_data}; +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_9_feed_data(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_data = 0; + #if !CYTHON_VECTORCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_feed_data (wrapper)", 0); + #if !CYTHON_VECTORCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_data,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 396, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 396, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_feed_data", 0) < (0)) __PYX_ERR(0, 396, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_feed_data", 1, 1, 1, i); __PYX_ERR(0, 396, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 396, __pyx_L3_error) + } + __pyx_v_data = ((PyObject*)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_feed_data", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 396, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketReader._feed_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_data), (&PyBytes_Type), 0, "data", 2))) __PYX_ERR(0, 396, __pyx_L1_error) + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_8_feed_data(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *)__pyx_v_self), __pyx_v_data); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_8_feed_data(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self, PyObject *__pyx_v_data) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_feed_data", 0); + __pyx_f_7aiohttp_10_websocket_8reader_c_15WebSocketReader__feed_data(__pyx_v_self, __pyx_v_data, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 396, __pyx_L1_error) + __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __pyx_r = __pyx_t_1; + } + __Pyx_XDECREF(__pyx_temp); + } + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketReader._feed_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_11__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_8reader_c_15WebSocketReader_11__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_11__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_VECTORCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_VECTORCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_10__reduce_cython__(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_10__reduce_cython__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + 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; + 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; + PyObject *__pyx_t_15 = NULL; + int __pyx_t_16; + int __pyx_t_17; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * with CRITICAL_SECTION(self): # <<<<<<<<<<<<<< + * state = (self._compress, self._compressed, self._decode_text, self._decompressobj, self._exc, self._frame_fin, self._frame_mask, self._frame_opcode, self._frame_payload_len, self._has_mask, self._max_fragments, self._max_msg_size, self._opcode, self._partial, self._payload_bytes_to_read, self._payload_fragments, self._payload_len_flag, self._state, self._tail, self._weak_self, self.queue) + * _dict = getattr(self, '__dict__', None) +*/ + { + __Pyx_PyCriticalSection __pyx_cs; + __pyx_t_1 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_1); + __Pyx_PyCriticalSection_Begin(&__pyx_cs, (PyObject*)__pyx_t_1); + /*try:*/ { + + /* "(tree fragment)":6 + * cdef bint use_setstate + * with CRITICAL_SECTION(self): + * state = (self._compress, self._compressed, self._decode_text, self._decompressobj, self._exc, self._frame_fin, self._frame_mask, self._frame_opcode, self._frame_payload_len, self._has_mask, self._max_fragments, self._max_msg_size, self._opcode, self._partial, self._payload_bytes_to_read, self._payload_fragments, self._payload_len_flag, self._state, self._tail, self._weak_self, self.queue) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: +*/ + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->_compress); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_self->_compressed); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_self->_decode_text); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyBool_FromLong(__pyx_v_self->_frame_fin); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_self->_frame_opcode); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyLong_FromSsize_t(__pyx_v_self->_frame_payload_len); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_self->_has_mask); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = PyLong_FromSsize_t(__pyx_v_self->_max_fragments); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyLong_From_unsigned_int(__pyx_v_self->_max_msg_size); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = __Pyx_PyLong_From_int(__pyx_v_self->_opcode); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = PyLong_FromSsize_t(__pyx_v_self->_payload_bytes_to_read); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_13 = __Pyx_PyLong_From_unsigned_int(__pyx_v_self->_payload_len_flag); if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_14 = __Pyx_PyLong_From_unsigned_int(__pyx_v_self->_state); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_15 = PyTuple_New(21); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 6, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_2) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_t_3) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 2, __pyx_t_4) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_INCREF(__pyx_v_self->_decompressobj); + __Pyx_GIVEREF(__pyx_v_self->_decompressobj); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 3, __pyx_v_self->_decompressobj) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_INCREF(__pyx_v_self->_exc); + __Pyx_GIVEREF(__pyx_v_self->_exc); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 4, __pyx_v_self->_exc) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 5, __pyx_t_5) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_INCREF(__pyx_v_self->_frame_mask); + __Pyx_GIVEREF(__pyx_v_self->_frame_mask); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 6, __pyx_v_self->_frame_mask) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 7, __pyx_t_6) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 8, __pyx_t_7) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 9, __pyx_t_8) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_GIVEREF(__pyx_t_9); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 10, __pyx_t_9) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_GIVEREF(__pyx_t_10); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 11, __pyx_t_10) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_GIVEREF(__pyx_t_11); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 12, __pyx_t_11) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_INCREF(__pyx_v_self->_partial); + __Pyx_GIVEREF(__pyx_v_self->_partial); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 13, __pyx_v_self->_partial) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_GIVEREF(__pyx_t_12); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 14, __pyx_t_12) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_INCREF(__pyx_v_self->_payload_fragments); + __Pyx_GIVEREF(__pyx_v_self->_payload_fragments); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 15, __pyx_v_self->_payload_fragments) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_GIVEREF(__pyx_t_13); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 16, __pyx_t_13) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_GIVEREF(__pyx_t_14); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 17, __pyx_t_14) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_INCREF(__pyx_v_self->_tail); + __Pyx_GIVEREF(__pyx_v_self->_tail); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 18, __pyx_v_self->_tail) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_INCREF(__pyx_v_self->_weak_self); + __Pyx_GIVEREF(__pyx_v_self->_weak_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 19, __pyx_v_self->_weak_self) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __Pyx_INCREF((PyObject *)__pyx_v_self->queue); + __Pyx_GIVEREF((PyObject *)__pyx_v_self->queue); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 20, ((PyObject *)__pyx_v_self->queue)) != (0)) __PYX_ERR(2, 6, __pyx_L4_error); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_8 = 0; + __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_v_state = ((PyObject*)__pyx_t_15); + __pyx_t_15 = 0; + + /* "(tree fragment)":7 + * with CRITICAL_SECTION(self): + * state = (self._compress, self._compressed, self._decode_text, self._decompressobj, self._exc, self._frame_fin, self._frame_mask, self._frame_opcode, self._frame_payload_len, self._has_mask, self._max_fragments, self._max_msg_size, self._opcode, self._partial, self._payload_bytes_to_read, self._payload_fragments, self._payload_len_flag, self._state, self._tail, self._weak_self, self.queue) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None and _dict: + * state += (_dict,) +*/ + __pyx_t_15 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 7, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_v__dict = __pyx_t_15; + __pyx_t_15 = 0; + } + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * with CRITICAL_SECTION(self): # <<<<<<<<<<<<<< + * state = (self._compress, self._compressed, self._decode_text, self._decompressobj, self._exc, self._frame_fin, self._frame_mask, self._frame_opcode, self._frame_payload_len, self._has_mask, self._max_fragments, self._max_msg_size, self._opcode, self._partial, self._payload_bytes_to_read, self._payload_fragments, self._payload_len_flag, self._state, self._tail, self._weak_self, self.queue) + * _dict = getattr(self, '__dict__', None) +*/ + /*finally:*/ { + /*normal exit:*/{ + __Pyx_PyCriticalSection_End(&__pyx_cs); + goto __pyx_L5; + } + __pyx_L4_error: { + __Pyx_PyCriticalSection_End(&__pyx_cs); + goto __pyx_L1_error; + } + __pyx_L5:; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "(tree fragment)":8 + * state = (self._compress, self._compressed, self._decode_text, self._decompressobj, self._exc, self._frame_fin, self._frame_mask, self._frame_opcode, self._frame_payload_len, self._has_mask, self._max_fragments, self._max_msg_size, self._opcode, self._partial, self._payload_bytes_to_read, self._payload_fragments, self._payload_len_flag, self._state, self._tail, self._weak_self, self.queue) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __pyx_t_17 = (__pyx_v__dict != Py_None); + if (__pyx_t_17) { + + } else { + + __pyx_t_16 = __pyx_t_17; + + goto __pyx_L7_bool_binop_done; + } + __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v__dict); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(2, 8, __pyx_L1_error) + + __pyx_t_16 = __pyx_t_17; + + __pyx_L7_bool_binop_done:; + if (__pyx_t_16) { + + + /* "(tree fragment)":9 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: +*/ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict) != (0)) __PYX_ERR(2, 9, __pyx_L1_error); + __pyx_t_15 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_15)); + __pyx_t_15 = 0; + + /* "(tree fragment)":10 + * if _dict is not None and _dict: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self._decompressobj is not None or self._exc is not None or self._frame_mask is not None or self._partial is not None or self._payload_fragments is not None or self._tail is not None or self._weak_self is not None or self.queue is not None +*/ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":8 + * state = (self._compress, self._compressed, self._decode_text, self._decompressobj, self._exc, self._frame_fin, self._frame_mask, self._frame_opcode, self._frame_payload_len, self._has_mask, self._max_fragments, self._max_msg_size, self._opcode, self._partial, self._payload_bytes_to_read, self._payload_fragments, self._payload_len_flag, self._state, self._tail, self._weak_self, self.queue) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L6; + } + + /* "(tree fragment)":12 + * use_setstate = True + * else: + * use_setstate = self._decompressobj is not None or self._exc is not None or self._frame_mask is not None or self._partial is not None or self._payload_fragments is not None or self._tail is not None or self._weak_self is not None or self.queue is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_WebSocketReader, (type(self), 0xd550ae4, None), state +*/ + /*else*/ { + __pyx_t_17 = (__pyx_v_self->_decompressobj != Py_None); + if (!__pyx_t_17) { + + } else { + + __pyx_t_16 = __pyx_t_17; + + goto __pyx_L9_bool_binop_done; + } + __pyx_t_17 = (__pyx_v_self->_exc != ((PyObject*)Py_None)); + if (!__pyx_t_17) { + + } else { + + __pyx_t_16 = __pyx_t_17; + + goto __pyx_L9_bool_binop_done; + } + __pyx_t_17 = (__pyx_v_self->_frame_mask != ((PyObject*)Py_None)); + if (!__pyx_t_17) { + + } else { + + __pyx_t_16 = __pyx_t_17; + + goto __pyx_L9_bool_binop_done; + } + __pyx_t_17 = (__pyx_v_self->_partial != ((PyObject*)Py_None)); + if (!__pyx_t_17) { + + } else { + + __pyx_t_16 = __pyx_t_17; + + goto __pyx_L9_bool_binop_done; + } + __pyx_t_17 = (__pyx_v_self->_payload_fragments != ((PyObject*)Py_None)); + if (!__pyx_t_17) { + + } else { + + __pyx_t_16 = __pyx_t_17; + + goto __pyx_L9_bool_binop_done; + } + __pyx_t_17 = (__pyx_v_self->_tail != ((PyObject*)Py_None)); + if (!__pyx_t_17) { + + } else { + + __pyx_t_16 = __pyx_t_17; + + goto __pyx_L9_bool_binop_done; + } + __pyx_t_17 = (__pyx_v_self->_weak_self != Py_None); + if (!__pyx_t_17) { + + } else { + + __pyx_t_16 = __pyx_t_17; + + goto __pyx_L9_bool_binop_done; + } + __pyx_t_17 = (((PyObject *)__pyx_v_self->queue) != Py_None); + + __pyx_t_16 = __pyx_t_17; + + __pyx_L9_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_16; + } + __pyx_L6:; + + /* "(tree fragment)":13 + * else: + * use_setstate = self._decompressobj is not None or self._exc is not None or self._frame_mask is not None or self._partial is not None or self._payload_fragments is not None or self._tail is not None or self._weak_self is not None or self.queue is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_WebSocketReader, (type(self), 0xd550ae4, None), state + * else: +*/ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":14 + * use_setstate = self._decompressobj is not None or self._exc is not None or self._frame_mask is not None or self._partial is not None or self._payload_fragments is not None or self._tail is not None or self._weak_self is not None or self.queue is not None + * if use_setstate: + * return __pyx_unpickle_WebSocketReader, (type(self), 0xd550ae4, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_WebSocketReader, (type(self), 0xd550ae4, state) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_WebSocketReader); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(2, 14, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_223677156); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_223677156); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_223677156) != (0)) __PYX_ERR(2, 14, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None) != (0)) __PYX_ERR(2, 14, __pyx_L1_error); + __pyx_t_14 = PyTuple_New(3); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_GIVEREF(__pyx_t_15); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_15) != (0)) __PYX_ERR(2, 14, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_t_1) != (0)) __PYX_ERR(2, 14, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 2, __pyx_v_state) != (0)) __PYX_ERR(2, 14, __pyx_L1_error); + __pyx_t_15 = 0; + __pyx_t_1 = 0; + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __pyx_r = __pyx_t_14; + } + __Pyx_XDECREF(__pyx_temp); + } + __pyx_t_14 = 0; + goto __pyx_L0; + + /* "(tree fragment)":13 + * else: + * use_setstate = self._decompressobj is not None or self._exc is not None or self._frame_mask is not None or self._partial is not None or self._payload_fragments is not None or self._tail is not None or self._weak_self is not None or self.queue is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_WebSocketReader, (type(self), 0xd550ae4, None), state + * else: +*/ + } + + /* "(tree fragment)":16 + * return __pyx_unpickle_WebSocketReader, (type(self), 0xd550ae4, None), state + * else: + * return __pyx_unpickle_WebSocketReader, (type(self), 0xd550ae4, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_WebSocketReader__set_state(self, __pyx_state) +*/ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_14, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_WebSocketReader); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(2, 16, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_223677156); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_223677156); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_223677156) != (0)) __PYX_ERR(2, 16, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state) != (0)) __PYX_ERR(2, 16, __pyx_L1_error); + __pyx_t_15 = PyTuple_New(2); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_GIVEREF(__pyx_t_14); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_14) != (0)) __PYX_ERR(2, 16, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_t_1) != (0)) __PYX_ERR(2, 16, __pyx_L1_error); + __pyx_t_14 = 0; + __pyx_t_1 = 0; + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __pyx_r = __pyx_t_15; + } + __Pyx_XDECREF(__pyx_temp); + } + __pyx_t_15 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + + /* 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_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketReader.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":17 + * else: + * return __pyx_unpickle_WebSocketReader, (type(self), 0xd550ae4, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_WebSocketReader__set_state(self, __pyx_state) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_13__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_8reader_c_15WebSocketReader_13__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_13__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_VECTORCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_VECTORCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 17, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 17, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(2, 17, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(2, 17, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 17, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 17, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("aiohttp._websocket.reader_c.WebSocketReader.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_12__setstate_cython__(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_15WebSocketReader_12__setstate_cython__(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":18 + * return __pyx_unpickle_WebSocketReader, (type(self), 0xd550ae4, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_WebSocketReader__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __pyx_t_1 = __pyx_v___pyx_state; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(2, 18, __pyx_L1_error) + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared \047not None\047"); + __PYX_ERR(2, 18, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_7aiohttp_10_websocket_8reader_c___pyx_unpickle_WebSocketReader__set_state(__pyx_v_self, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 18, __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; + + /* "(tree fragment)":17 + * else: + * return __pyx_unpickle_WebSocketReader, (type(self), 0xd550ae4, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_WebSocketReader__set_state(self, __pyx_state) +*/ + + /* 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("aiohttp._websocket.reader_c.WebSocketReader.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_WebSocketDataQueue(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x7cbbcf5, 0xf3050d7, 0x7050118, b'_buffer, _eof, _exception, _get_buffer, _limit, _loop, _protocol, _put_buffer, _size, _stalled_reader, _waiter') +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_1__pyx_unpickle_WebSocketDataQueue(PyObject *__pyx_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_8reader_c_1__pyx_unpickle_WebSocketDataQueue = {"__pyx_unpickle_WebSocketDataQueue", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_1__pyx_unpickle_WebSocketDataQueue, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_1__pyx_unpickle_WebSocketDataQueue(PyObject *__pyx_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_VECTORCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_WebSocketDataQueue (wrapper)", 0); + #if !CYTHON_VECTORCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 4, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_WebSocketDataQueue", 0) < (0)) __PYX_ERR(2, 4, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_WebSocketDataQueue", 1, 3, 3, i); __PYX_ERR(2, 4, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 4, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 4, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 4, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(2, 4, __pyx_L3_error) + __pyx_v___pyx_state = ((PyObject*)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_WebSocketDataQueue", 1, 3, 3, __pyx_nargs); __PYX_ERR(2, 4, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("aiohttp._websocket.reader_c.__pyx_unpickle_WebSocketDataQueue", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v___pyx_state), (&PyTuple_Type), 1, "__pyx_state", 1))) __PYX_ERR(2, 4, __pyx_L1_error) + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c___pyx_unpickle_WebSocketDataQueue(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c___pyx_unpickle_WebSocketDataQueue(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_WebSocketDataQueue", 0); + + /* "(tree fragment)":6 + * def __pyx_unpickle_WebSocketDataQueue(__pyx_type, long __pyx_checksum, tuple __pyx_state): + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x7cbbcf5, 0xf3050d7, 0x7050118, b'_buffer, _eof, _exception, _get_buffer, _limit, _loop, _protocol, _put_buffer, _size, _stalled_reader, _waiter') # <<<<<<<<<<<<<< + * __pyx_result = WebSocketDataQueue.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __pyx_t_1 = __Pyx_CheckUnpickleChecksum(__pyx_v___pyx_checksum, 0x7cbbcf5, 0xf3050d7, 0x7050118, __pyx_k_buffer__eof__exception__get_buf); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 6, __pyx_L1_error) + + + /* "(tree fragment)":7 + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x7cbbcf5, 0xf3050d7, 0x7050118, b'_buffer, _eof, _exception, _get_buffer, _limit, _loop, _protocol, _put_buffer, _size, _stalled_reader, _waiter') + * __pyx_result = WebSocketDataQueue.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_WebSocketDataQueue__set_state( __pyx_result, __pyx_state) +*/ + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v___pyx_result = __pyx_t_2; + __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x7cbbcf5, 0xf3050d7, 0x7050118, b'_buffer, _eof, _exception, _get_buffer, _limit, _loop, _protocol, _put_buffer, _size, _stalled_reader, _waiter') + * __pyx_result = WebSocketDataQueue.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_WebSocketDataQueue__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __pyx_t_5 = (__pyx_v___pyx_state != ((PyObject*)Py_None)); + if (__pyx_t_5) { + + + /* "(tree fragment)":9 + * __pyx_result = WebSocketDataQueue.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_WebSocketDataQueue__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_WebSocketDataQueue__set_state(WebSocketDataQueue __pyx_result, __pyx_state: tuple): +*/ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared \047not None\047"); + __PYX_ERR(2, 9, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_7aiohttp_10_websocket_8reader_c___pyx_unpickle_WebSocketDataQueue__set_state(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_v___pyx_result), __pyx_v___pyx_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x7cbbcf5, 0xf3050d7, 0x7050118, b'_buffer, _eof, _exception, _get_buffer, _limit, _loop, _protocol, _put_buffer, _size, _stalled_reader, _waiter') + * __pyx_result = WebSocketDataQueue.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_WebSocketDataQueue__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_WebSocketDataQueue__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_WebSocketDataQueue__set_state(WebSocketDataQueue __pyx_result, __pyx_state: tuple): + * __pyx_result._buffer = __pyx_state[0]; __pyx_result._eof = __pyx_state[1]; __pyx_result._exception = __pyx_state[2]; __pyx_result._get_buffer = __pyx_state[3]; __pyx_result._limit = __pyx_state[4]; __pyx_result._loop = __pyx_state[5]; __pyx_result._protocol = __pyx_state[6]; __pyx_result._put_buffer = __pyx_state[7]; __pyx_result._size = __pyx_state[8]; __pyx_result._stalled_reader = __pyx_state[9]; __pyx_result._waiter = __pyx_state[10] +*/ + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + } + __Pyx_XDECREF(__pyx_temp); + } + goto __pyx_L0; + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_WebSocketDataQueue(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x7cbbcf5, 0xf3050d7, 0x7050118, b'_buffer, _eof, _exception, _get_buffer, _limit, _loop, _protocol, _put_buffer, _size, _stalled_reader, _waiter') +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.__pyx_unpickle_WebSocketDataQueue", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_WebSocketDataQueue__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_WebSocketDataQueue__set_state(WebSocketDataQueue __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result._buffer = __pyx_state[0]; __pyx_result._eof = __pyx_state[1]; __pyx_result._exception = __pyx_state[2]; __pyx_result._get_buffer = __pyx_state[3]; __pyx_result._limit = __pyx_state[4]; __pyx_result._loop = __pyx_state[5]; __pyx_result._protocol = __pyx_state[6]; __pyx_result._put_buffer = __pyx_state[7]; __pyx_result._size = __pyx_state[8]; __pyx_result._stalled_reader = __pyx_state[9]; __pyx_result._waiter = __pyx_state[10] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 11) +*/ + +static PyObject *__pyx_f_7aiohttp_10_websocket_8reader_c___pyx_unpickle_WebSocketDataQueue__set_state(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + unsigned int __pyx_t_3; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_WebSocketDataQueue__set_state", 0); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_WebSocketDataQueue__set_state(WebSocketDataQueue __pyx_result, __pyx_state: tuple): + * __pyx_result._buffer = __pyx_state[0]; __pyx_result._eof = __pyx_state[1]; __pyx_result._exception = __pyx_state[2]; __pyx_result._get_buffer = __pyx_state[3]; __pyx_result._limit = __pyx_state[4]; __pyx_result._loop = __pyx_state[5]; __pyx_result._protocol = __pyx_state[6]; __pyx_result._put_buffer = __pyx_state[7]; __pyx_result._size = __pyx_state[8]; __pyx_result._stalled_reader = __pyx_state[9]; __pyx_result._waiter = __pyx_state[10] # <<<<<<<<<<<<<< + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 11) +*/ + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_buffer); + __Pyx_DECREF(__pyx_v___pyx_result->_buffer); + __pyx_v___pyx_result->_buffer = __pyx_t_1; + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->_eof = __pyx_t_2; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_exception); + __Pyx_DECREF(__pyx_v___pyx_result->_exception); + __pyx_v___pyx_result->_exception = __pyx_t_1; + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_get_buffer); + __Pyx_DECREF(__pyx_v___pyx_result->_get_buffer); + __pyx_v___pyx_result->_get_buffer = __pyx_t_1; + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyLong_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->_limit = __pyx_t_3; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_loop); + __Pyx_DECREF(__pyx_v___pyx_result->_loop); + __pyx_v___pyx_result->_loop = __pyx_t_1; + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 6, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_protocol); + __Pyx_DECREF(__pyx_v___pyx_result->_protocol); + __pyx_v___pyx_result->_protocol = __pyx_t_1; + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 7, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_put_buffer); + __Pyx_DECREF(__pyx_v___pyx_result->_put_buffer); + __pyx_v___pyx_result->_put_buffer = __pyx_t_1; + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 8, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyLong_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->_size = __pyx_t_3; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 9, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_stalled_reader); + __Pyx_DECREF(__pyx_v___pyx_result->_stalled_reader); + __pyx_v___pyx_result->_stalled_reader = __pyx_t_1; + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 10, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_waiter); + __Pyx_DECREF(__pyx_v___pyx_result->_waiter); + __pyx_v___pyx_result->_waiter = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_WebSocketDataQueue__set_state(WebSocketDataQueue __pyx_result, __pyx_state: tuple): + * __pyx_result._buffer = __pyx_state[0]; __pyx_result._eof = __pyx_state[1]; __pyx_result._exception = __pyx_state[2]; __pyx_result._get_buffer = __pyx_state[3]; __pyx_result._limit = __pyx_state[4]; __pyx_result._loop = __pyx_state[5]; __pyx_result._protocol = __pyx_state[6]; __pyx_result._put_buffer = __pyx_state[7]; __pyx_result._size = __pyx_state[8]; __pyx_result._stalled_reader = __pyx_state[9]; __pyx_result._waiter = __pyx_state[10] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 11) # <<<<<<<<<<<<<< +*/ + __pyx_t_4 = __Pyx_UpdateUnpickledDict(((PyObject *)__pyx_v___pyx_result), __pyx_v___pyx_state, 11); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 13, __pyx_L1_error) + + + /* "(tree fragment)":11 + * __pyx_unpickle_WebSocketDataQueue__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_WebSocketDataQueue__set_state(WebSocketDataQueue __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result._buffer = __pyx_state[0]; __pyx_result._eof = __pyx_state[1]; __pyx_result._exception = __pyx_state[2]; __pyx_result._get_buffer = __pyx_state[3]; __pyx_result._limit = __pyx_state[4]; __pyx_result._loop = __pyx_state[5]; __pyx_result._protocol = __pyx_state[6]; __pyx_result._put_buffer = __pyx_state[7]; __pyx_result._size = __pyx_state[8]; __pyx_result._stalled_reader = __pyx_state[9]; __pyx_result._waiter = __pyx_state[10] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 11) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.__pyx_unpickle_WebSocketDataQueue__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_WebSocketReader(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xd550ae4, 0xe1d928a, 0x11e3d59, b'_compress, _compressed, _decode_text, _decompressobj, _exc, _frame_fin, _frame_mask, _frame_opcode, _frame_payload_len, _has_mask, _max_fragments, _max_msg_size, _opcode, _partial, _payload_bytes_to_read, _payload_fragments, _payload_len_flag, _state, _tail, _weak_self, queue') +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_3__pyx_unpickle_WebSocketReader(PyObject *__pyx_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_8reader_c_3__pyx_unpickle_WebSocketReader = {"__pyx_unpickle_WebSocketReader", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_3__pyx_unpickle_WebSocketReader, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7aiohttp_10_websocket_8reader_c_3__pyx_unpickle_WebSocketReader(PyObject *__pyx_self, +#if CYTHON_VECTORCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_VECTORCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_WebSocketReader (wrapper)", 0); + #if !CYTHON_VECTORCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(2, 4, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_WebSocketReader", 0) < (0)) __PYX_ERR(2, 4, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_WebSocketReader", 1, 3, 3, i); __PYX_ERR(2, 4, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 4, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 4, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 4, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(2, 4, __pyx_L3_error) + __pyx_v___pyx_state = ((PyObject*)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_WebSocketReader", 1, 3, 3, __pyx_nargs); __PYX_ERR(2, 4, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("aiohttp._websocket.reader_c.__pyx_unpickle_WebSocketReader", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v___pyx_state), (&PyTuple_Type), 1, "__pyx_state", 1))) __PYX_ERR(2, 4, __pyx_L1_error) + __pyx_r = __pyx_pf_7aiohttp_10_websocket_8reader_c_2__pyx_unpickle_WebSocketReader(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7aiohttp_10_websocket_8reader_c_2__pyx_unpickle_WebSocketReader(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_WebSocketReader", 0); + + /* "(tree fragment)":6 + * def __pyx_unpickle_WebSocketReader(__pyx_type, long __pyx_checksum, tuple __pyx_state): + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xd550ae4, 0xe1d928a, 0x11e3d59, b'_compress, _compressed, _decode_text, _decompressobj, _exc, _frame_fin, _frame_mask, _frame_opcode, _frame_payload_len, _has_mask, _max_fragments, _max_msg_size, _opcode, _partial, _payload_bytes_to_read, _payload_fragments, _payload_len_flag, _state, _tail, _weak_self, queue') # <<<<<<<<<<<<<< + * __pyx_result = WebSocketReader.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __pyx_t_1 = __Pyx_CheckUnpickleChecksum(__pyx_v___pyx_checksum, 0xd550ae4, 0xe1d928a, 0x11e3d59, __pyx_k_compress__compressed__decode_te); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 6, __pyx_L1_error) + + + /* "(tree fragment)":7 + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xd550ae4, 0xe1d928a, 0x11e3d59, b'_compress, _compressed, _decode_text, _decompressobj, _exc, _frame_fin, _frame_mask, _frame_opcode, _frame_payload_len, _has_mask, _max_fragments, _max_msg_size, _opcode, _partial, _payload_bytes_to_read, _payload_fragments, _payload_len_flag, _state, _tail, _weak_self, queue') + * __pyx_result = WebSocketReader.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_WebSocketReader__set_state( __pyx_result, __pyx_state) +*/ + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v___pyx_result = __pyx_t_2; + __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xd550ae4, 0xe1d928a, 0x11e3d59, b'_compress, _compressed, _decode_text, _decompressobj, _exc, _frame_fin, _frame_mask, _frame_opcode, _frame_payload_len, _has_mask, _max_fragments, _max_msg_size, _opcode, _partial, _payload_bytes_to_read, _payload_fragments, _payload_len_flag, _state, _tail, _weak_self, queue') + * __pyx_result = WebSocketReader.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_WebSocketReader__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __pyx_t_5 = (__pyx_v___pyx_state != ((PyObject*)Py_None)); + if (__pyx_t_5) { + + + /* "(tree fragment)":9 + * __pyx_result = WebSocketReader.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_WebSocketReader__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_WebSocketReader__set_state(WebSocketReader __pyx_result, __pyx_state: tuple): +*/ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared \047not None\047"); + __PYX_ERR(2, 9, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_7aiohttp_10_websocket_8reader_c___pyx_unpickle_WebSocketReader__set_state(((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *)__pyx_v___pyx_result), __pyx_v___pyx_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xd550ae4, 0xe1d928a, 0x11e3d59, b'_compress, _compressed, _decode_text, _decompressobj, _exc, _frame_fin, _frame_mask, _frame_opcode, _frame_payload_len, _has_mask, _max_fragments, _max_msg_size, _opcode, _partial, _payload_bytes_to_read, _payload_fragments, _payload_len_flag, _state, _tail, _weak_self, queue') + * __pyx_result = WebSocketReader.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_WebSocketReader__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_WebSocketReader__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_WebSocketReader__set_state(WebSocketReader __pyx_result, __pyx_state: tuple): + * __pyx_result._compress = __pyx_state[0]; __pyx_result._compressed = __pyx_state[1]; __pyx_result._decode_text = __pyx_state[2]; __pyx_result._decompressobj = __pyx_state[3]; __pyx_result._exc = __pyx_state[4]; __pyx_result._frame_fin = __pyx_state[5]; __pyx_result._frame_mask = __pyx_state[6]; __pyx_result._frame_opcode = __pyx_state[7]; __pyx_result._frame_payload_len = __pyx_state[8]; __pyx_result._has_mask = __pyx_state[9]; __pyx_result._max_fragments = __pyx_state[10]; __pyx_result._max_msg_size = __pyx_state[11]; __pyx_result._opcode = __pyx_state[12]; __pyx_result._partial = __pyx_state[13]; __pyx_result._payload_bytes_to_read = __pyx_state[14]; __pyx_result._payload_fragments = __pyx_state[15]; __pyx_result._payload_len_flag = __pyx_state[16]; __pyx_result._state = __pyx_state[17]; __pyx_result._tail = __pyx_state[18]; __pyx_result._weak_self = __pyx_state[19]; __pyx_result.queue = __pyx_state[20] +*/ + { + PyObject *__pyx_temp; + { + __pyx_temp = __pyx_r; + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + } + __Pyx_XDECREF(__pyx_temp); + } + goto __pyx_L0; + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_WebSocketReader(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xd550ae4, 0xe1d928a, 0x11e3d59, b'_compress, _compressed, _decode_text, _decompressobj, _exc, _frame_fin, _frame_mask, _frame_opcode, _frame_payload_len, _has_mask, _max_fragments, _max_msg_size, _opcode, _partial, _payload_bytes_to_read, _payload_fragments, _payload_len_flag, _state, _tail, _weak_self, queue') +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.__pyx_unpickle_WebSocketReader", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_WebSocketReader__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_WebSocketReader__set_state(WebSocketReader __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result._compress = __pyx_state[0]; __pyx_result._compressed = __pyx_state[1]; __pyx_result._decode_text = __pyx_state[2]; __pyx_result._decompressobj = __pyx_state[3]; __pyx_result._exc = __pyx_state[4]; __pyx_result._frame_fin = __pyx_state[5]; __pyx_result._frame_mask = __pyx_state[6]; __pyx_result._frame_opcode = __pyx_state[7]; __pyx_result._frame_payload_len = __pyx_state[8]; __pyx_result._has_mask = __pyx_state[9]; __pyx_result._max_fragments = __pyx_state[10]; __pyx_result._max_msg_size = __pyx_state[11]; __pyx_result._opcode = __pyx_state[12]; __pyx_result._partial = __pyx_state[13]; __pyx_result._payload_bytes_to_read = __pyx_state[14]; __pyx_result._payload_fragments = __pyx_state[15]; __pyx_result._payload_len_flag = __pyx_state[16]; __pyx_result._state = __pyx_state[17]; __pyx_result._tail = __pyx_state[18]; __pyx_result._weak_self = __pyx_state[19]; __pyx_result.queue = __pyx_state[20] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 21) +*/ + +static PyObject *__pyx_f_7aiohttp_10_websocket_8reader_c___pyx_unpickle_WebSocketReader__set_state(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + unsigned int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_WebSocketReader__set_state", 0); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_WebSocketReader__set_state(WebSocketReader __pyx_result, __pyx_state: tuple): + * __pyx_result._compress = __pyx_state[0]; __pyx_result._compressed = __pyx_state[1]; __pyx_result._decode_text = __pyx_state[2]; __pyx_result._decompressobj = __pyx_state[3]; __pyx_result._exc = __pyx_state[4]; __pyx_result._frame_fin = __pyx_state[5]; __pyx_result._frame_mask = __pyx_state[6]; __pyx_result._frame_opcode = __pyx_state[7]; __pyx_result._frame_payload_len = __pyx_state[8]; __pyx_result._has_mask = __pyx_state[9]; __pyx_result._max_fragments = __pyx_state[10]; __pyx_result._max_msg_size = __pyx_state[11]; __pyx_result._opcode = __pyx_state[12]; __pyx_result._partial = __pyx_state[13]; __pyx_result._payload_bytes_to_read = __pyx_state[14]; __pyx_result._payload_fragments = __pyx_state[15]; __pyx_result._payload_len_flag = __pyx_state[16]; __pyx_result._state = __pyx_state[17]; __pyx_result._tail = __pyx_state[18]; __pyx_result._weak_self = __pyx_state[19]; __pyx_result.queue = __pyx_state[20] # <<<<<<<<<<<<<< + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 21) +*/ + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->_compress = __pyx_t_2; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->_compressed = __pyx_t_3; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->_decode_text = __pyx_t_2; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_decompressobj); + __Pyx_DECREF(__pyx_v___pyx_result->_decompressobj); + __pyx_v___pyx_result->_decompressobj = __pyx_t_1; + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_PyExc_Exception_Check(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("Exception", __pyx_t_1))) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_exc); + __Pyx_DECREF(__pyx_v___pyx_result->_exc); + __pyx_v___pyx_result->_exc = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->_frame_fin = __pyx_t_2; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 6, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyBytes_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_1))) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_frame_mask); + __Pyx_DECREF(__pyx_v___pyx_result->_frame_mask); + __pyx_v___pyx_result->_frame_mask = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 7, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->_frame_opcode = __pyx_t_3; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 8, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->_frame_payload_len = __pyx_t_4; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 9, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->_has_mask = __pyx_t_2; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 10, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->_max_fragments = __pyx_t_4; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 11, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyLong_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_5 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->_max_msg_size = __pyx_t_5; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 12, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->_opcode = __pyx_t_3; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 13, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyByteArray_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytearray", __pyx_t_1))) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_partial); + __Pyx_DECREF(__pyx_v___pyx_result->_partial); + __pyx_v___pyx_result->_partial = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 14, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->_payload_bytes_to_read = __pyx_t_4; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 15, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_payload_fragments); + __Pyx_DECREF(__pyx_v___pyx_result->_payload_fragments); + __pyx_v___pyx_result->_payload_fragments = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 16, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyLong_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_5 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->_payload_len_flag = __pyx_t_5; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 17, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyLong_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_5 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->_state = __pyx_t_5; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 18, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyBytes_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_1))) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_tail); + __Pyx_DECREF(__pyx_v___pyx_result->_tail); + __pyx_v___pyx_result->_tail = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 19, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_weak_self); + __Pyx_DECREF(__pyx_v___pyx_result->_weak_self); + __pyx_v___pyx_result->_weak_self = __pyx_t_1; + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 20, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue))))) __PYX_ERR(2, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v___pyx_result->queue); + __Pyx_DECREF((PyObject *)__pyx_v___pyx_result->queue); + __pyx_v___pyx_result->queue = ((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_WebSocketReader__set_state(WebSocketReader __pyx_result, __pyx_state: tuple): + * __pyx_result._compress = __pyx_state[0]; __pyx_result._compressed = __pyx_state[1]; __pyx_result._decode_text = __pyx_state[2]; __pyx_result._decompressobj = __pyx_state[3]; __pyx_result._exc = __pyx_state[4]; __pyx_result._frame_fin = __pyx_state[5]; __pyx_result._frame_mask = __pyx_state[6]; __pyx_result._frame_opcode = __pyx_state[7]; __pyx_result._frame_payload_len = __pyx_state[8]; __pyx_result._has_mask = __pyx_state[9]; __pyx_result._max_fragments = __pyx_state[10]; __pyx_result._max_msg_size = __pyx_state[11]; __pyx_result._opcode = __pyx_state[12]; __pyx_result._partial = __pyx_state[13]; __pyx_result._payload_bytes_to_read = __pyx_state[14]; __pyx_result._payload_fragments = __pyx_state[15]; __pyx_result._payload_len_flag = __pyx_state[16]; __pyx_result._state = __pyx_state[17]; __pyx_result._tail = __pyx_state[18]; __pyx_result._weak_self = __pyx_state[19]; __pyx_result.queue = __pyx_state[20] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 21) # <<<<<<<<<<<<<< +*/ + __pyx_t_3 = __Pyx_UpdateUnpickledDict(((PyObject *)__pyx_v___pyx_result), __pyx_v___pyx_state, 21); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 13, __pyx_L1_error) + + + /* "(tree fragment)":11 + * __pyx_unpickle_WebSocketReader__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_WebSocketReader__set_state(WebSocketReader __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result._compress = __pyx_state[0]; __pyx_result._compressed = __pyx_state[1]; __pyx_result._decode_text = __pyx_state[2]; __pyx_result._decompressobj = __pyx_state[3]; __pyx_result._exc = __pyx_state[4]; __pyx_result._frame_fin = __pyx_state[5]; __pyx_result._frame_mask = __pyx_state[6]; __pyx_result._frame_opcode = __pyx_state[7]; __pyx_result._frame_payload_len = __pyx_state[8]; __pyx_result._has_mask = __pyx_state[9]; __pyx_result._max_fragments = __pyx_state[10]; __pyx_result._max_msg_size = __pyx_state[11]; __pyx_result._opcode = __pyx_state[12]; __pyx_result._partial = __pyx_state[13]; __pyx_result._payload_bytes_to_read = __pyx_state[14]; __pyx_result._payload_fragments = __pyx_state[15]; __pyx_result._payload_len_flag = __pyx_state[16]; __pyx_result._state = __pyx_state[17]; __pyx_result._tail = __pyx_state[18]; __pyx_result._weak_self = __pyx_state[19]; __pyx_result.queue = __pyx_state[20] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 21) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("aiohttp._websocket.reader_c.__pyx_unpickle_WebSocketReader__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +/* #### Code section: module_exttypes ### */ +static struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue __pyx_vtable_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue; + +static PyObject *__pyx_tp_new__initialisation_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(PyObject *o, +#if CYTHON_VECTORCALL_TPNEW + CYTHON_UNUSED PyObject *const *args, CYTHON_UNUSED Py_ssize_t nargs, CYTHON_UNUSED PyObject *kwnames +#else + CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k +#endif +) { + struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *p = ((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)o); + p->__pyx_vtab = __pyx_vtabptr_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue; + p->_protocol = Py_None; Py_INCREF(Py_None); + p->_loop = Py_None; Py_INCREF(Py_None); + p->_waiter = Py_None; Py_INCREF(Py_None); + p->_exception = Py_None; Py_INCREF(Py_None); + p->_buffer = Py_None; Py_INCREF(Py_None); + p->_get_buffer = Py_None; Py_INCREF(Py_None); + p->_put_buffer = Py_None; Py_INCREF(Py_None); + p->_stalled_reader = Py_None; Py_INCREF(Py_None); + return o; +} + +static PyObject *__pyx_tp_new_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(PyTypeObject *t, +#if CYTHON_VECTORCALL_TPNEW + PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames +#else + PyObject *a, PyObject *k +#endif +) { + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 0); + if (unlikely(!o)) return 0; + return __pyx_tp_new__initialisation_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(o, +#if CYTHON_VECTORCALL_TPNEW + args, nargs, kwnames +#else + a, k +#endif +); +} + +#if CYTHON_VECTORCALL_TPNEW +static PyObject *__pyx_tp_new_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(PyTypeObject *t, PyObject *a, PyObject *k) { + return __Pyx_CallTpnewAsVectorcall(__pyx_tp_new_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, t, a, k); +} +#endif + +#if CYTHON_VECTORCALL_TPNEW +static PyObject *__pyx_tp_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(PyObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames) { + if (unlikely((PyTypeObject*)t != __pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue || __Pyx_PyType_HasFeature((PyTypeObject*)t, Py_TPFLAGS_IS_ABSTRACT))) { + return __Pyx_CallNewInitFromVectorcall((PyTypeObject*)t, args, nargsf, kwnames); + } + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *o = __pyx_tp_new_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue((PyTypeObject*)t, args, nargs, kwnames); + if (likely(o)) { + assert(Py_TYPE(o) == (PyTypeObject*)t); + if (unlikely(__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_1__init__(o, args, nargs, kwnames) < 0)) { + Py_CLEAR(o); + } + } + return o; +} +#endif + +#if CYTHON_VECTORCALL_TPNEW +static int __pyx_tp_init_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(PyObject *o, PyObject *args, PyObject *kwds) { + return __Pyx_CallTpinitAsVectorcall(__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_1__init__, o, args, kwds); +} +#endif + +static void __pyx_tp_dealloc_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(PyObject *o) { + struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *p = (struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->_protocol); + Py_CLEAR(p->_loop); + Py_CLEAR(p->_waiter); + Py_CLEAR(p->_exception); + Py_CLEAR(p->_buffer); + Py_CLEAR(p->_get_buffer); + Py_CLEAR(p->_put_buffer); + Py_CLEAR(p->_stalled_reader); + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static int __pyx_tp_traverse_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *p = (struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->_protocol) { + e = (*v)(p->_protocol, a); if (e) return e; + } + if (p->_loop) { + e = (*v)(p->_loop, a); if (e) return e; + } + if (p->_waiter) { + e = (*v)(p->_waiter, a); if (e) return e; + } + if (p->_exception) { + e = (*v)(p->_exception, a); if (e) return e; + } + if (p->_buffer) { + e = (*v)(p->_buffer, a); if (e) return e; + } + if (p->_get_buffer) { + e = (*v)(p->_get_buffer, a); if (e) return e; + } + if (p->_put_buffer) { + e = (*v)(p->_put_buffer, a); if (e) return e; + } + if (p->_stalled_reader) { + e = (*v)(p->_stalled_reader, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *p = (struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)o; + tmp = ((PyObject*)p->_protocol); + p->_protocol = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_loop); + p->_loop = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_waiter); + p->_waiter = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_exception); + p->_exception = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_buffer); + p->_buffer = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_get_buffer); + p->_get_buffer = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_put_buffer); + p->_put_buffer = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_stalled_reader); + p->_stalled_reader = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__size(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_5_size_1__get__(o); +} + +static PyObject *__pyx_getprop_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__protocol(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol_1__get__(o); +} + +static int __pyx_setprop_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__protocol(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol_3__set__(o, v); + } + else { + return __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9_protocol_5__del__(o); + } +} + +static PyObject *__pyx_getprop_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__limit(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_6_limit_1__get__(o); +} + +static PyObject *__pyx_getprop_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__buffer(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer_1__get__(o); +} + +static int __pyx_setprop_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__buffer(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer_3__set__(o, v); + } + else { + return __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7_buffer_5__del__(o); + } +} + +static PyObject *__pyx_getprop_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__stalled_reader(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_15_stalled_reader_1__get__(o); +} + +static PyMethodDef __pyx_methods_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue[] = { + {"is_eof", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_3is_eof, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"exception", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_5exception, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"set_exception", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7set_exception, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"feed_eof", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9feed_eof, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"read", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_13read, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_16__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_18__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue[] = { + {"_size", __pyx_getprop_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__size, 0, 0, 0}, + {"_protocol", __pyx_getprop_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__protocol, __pyx_setprop_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__protocol, 0, 0}, + {"_limit", __pyx_getprop_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__limit, 0, 0, 0}, + {"_buffer", __pyx_getprop_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__buffer, __pyx_setprop_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__buffer, 0, 0}, + {"_stalled_reader", __pyx_getprop_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__stalled_reader, 0, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue}, + {Py_tp_doc, (void *)PyDoc_STR("WebSocketDataQueue resumes and pauses an underlying stream.\n\n It is a destination for WebSocket data.\n ")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue}, + {Py_tp_clear, (void *)__pyx_tp_clear_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue}, + {Py_tp_methods, (void *)__pyx_methods_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue}, + {Py_tp_getset, (void *)__pyx_getsets_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue}, + {Py_tp_init, (void *)__pyx_tp_init_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue}, + {Py_tp_new, (void *)__pyx_tp_new_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue}, + #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) && (!CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x030E0000) + #if CYTHON_VECTORCALL_TPNEW + {Py_tp_vectorcall, (void *)__pyx_tp_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue}, + #endif + #endif + {0, 0}, +}; +static PyType_Spec __pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue_spec = { + "aiohttp._websocket.reader_c.WebSocketDataQueue", + sizeof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue_slots, +}; +#else + +static PyTypeObject __pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue = { + PyVarObject_HEAD_INIT(0, 0) + "aiohttp._websocket.reader_c.""WebSocketDataQueue", /*tp_name*/ + sizeof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("WebSocketDataQueue resumes and pauses an underlying stream.\n\n It is a destination for WebSocket data.\n "), /*tp_doc*/ + __pyx_tp_traverse_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, /*tp_traverse*/ + __pyx_tp_clear_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_tp_init_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) && (!CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x030E0000) + #if CYTHON_VECTORCALL_TPNEW + __pyx_tp_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, /*tp_vectorcall*/ + #else + NULL, /*tp_vectorcall*/ + #endif + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_7aiohttp_10_websocket_8reader_c_WebSocketReader __pyx_vtable_7aiohttp_10_websocket_8reader_c_WebSocketReader; + +static PyObject *__pyx_tp_new__initialisation_7aiohttp_10_websocket_8reader_c_WebSocketReader(PyObject *o, +#if CYTHON_VECTORCALL_TPNEW + CYTHON_UNUSED PyObject *const *args, CYTHON_UNUSED Py_ssize_t nargs, CYTHON_UNUSED PyObject *kwnames +#else + CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k +#endif +) { + struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *p = ((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *)o); + p->__pyx_vtab = __pyx_vtabptr_7aiohttp_10_websocket_8reader_c_WebSocketReader; + p->_weak_self = Py_None; Py_INCREF(Py_None); + p->queue = ((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)Py_None); Py_INCREF(Py_None); + p->_exc = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_partial = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_payload_fragments = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_tail = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_frame_mask = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_decompressobj = Py_None; Py_INCREF(Py_None); + return o; +} + +static PyObject *__pyx_tp_new_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketReader(PyTypeObject *t, +#if CYTHON_VECTORCALL_TPNEW + PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames +#else + PyObject *a, PyObject *k +#endif +) { + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 0); + if (unlikely(!o)) return 0; + return __pyx_tp_new__initialisation_7aiohttp_10_websocket_8reader_c_WebSocketReader(o, +#if CYTHON_VECTORCALL_TPNEW + args, nargs, kwnames +#else + a, k +#endif +); +} + +#if CYTHON_VECTORCALL_TPNEW +static PyObject *__pyx_tp_new_7aiohttp_10_websocket_8reader_c_WebSocketReader(PyTypeObject *t, PyObject *a, PyObject *k) { + return __Pyx_CallTpnewAsVectorcall(__pyx_tp_new_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketReader, t, a, k); +} +#endif + +#if CYTHON_VECTORCALL_TPNEW +static PyObject *__pyx_tp_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketReader(PyObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames) { + if (unlikely((PyTypeObject*)t != __pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader || __Pyx_PyType_HasFeature((PyTypeObject*)t, Py_TPFLAGS_IS_ABSTRACT))) { + return __Pyx_CallNewInitFromVectorcall((PyTypeObject*)t, args, nargsf, kwnames); + } + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *o = __pyx_tp_new_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketReader((PyTypeObject*)t, args, nargs, kwnames); + if (likely(o)) { + assert(Py_TYPE(o) == (PyTypeObject*)t); + if (unlikely(__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_1__init__(o, args, nargs, kwnames) < 0)) { + Py_CLEAR(o); + } + } + return o; +} +#endif + +#if CYTHON_VECTORCALL_TPNEW +static int __pyx_tp_init_7aiohttp_10_websocket_8reader_c_WebSocketReader(PyObject *o, PyObject *args, PyObject *kwds) { + return __Pyx_CallTpinitAsVectorcall(__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_1__init__, o, args, kwds); +} +#endif + +static void __pyx_tp_dealloc_7aiohttp_10_websocket_8reader_c_WebSocketReader(PyObject *o) { + struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *p = (struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7aiohttp_10_websocket_8reader_c_WebSocketReader) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + if (p->__weakref__) PyObject_ClearWeakRefs(o); + Py_CLEAR(p->_weak_self); + Py_CLEAR(p->queue); + Py_CLEAR(p->_exc); + Py_CLEAR(p->_partial); + Py_CLEAR(p->_payload_fragments); + Py_CLEAR(p->_tail); + Py_CLEAR(p->_frame_mask); + Py_CLEAR(p->_decompressobj); + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static int __pyx_tp_traverse_7aiohttp_10_websocket_8reader_c_WebSocketReader(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *p = (struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->_weak_self) { + e = (*v)(p->_weak_self, a); if (e) return e; + } + if (p->queue) { + e = (*v)(((PyObject *)p->queue), a); if (e) return e; + } + if (p->_exc) { + e = (*v)(p->_exc, a); if (e) return e; + } + if (p->_payload_fragments) { + e = (*v)(p->_payload_fragments, a); if (e) return e; + } + if (p->_decompressobj) { + e = (*v)(p->_decompressobj, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7aiohttp_10_websocket_8reader_c_WebSocketReader(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *p = (struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *)o; + tmp = ((PyObject*)p->_weak_self); + p->_weak_self = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->queue); + p->queue = ((struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_exc); + p->_exc = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_payload_fragments); + p->_payload_fragments = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_decompressobj); + p->_decompressobj = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyMethodDef __pyx_methods_7aiohttp_10_websocket_8reader_c_WebSocketReader[] = { + {"feed_eof", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_3feed_eof, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7aiohttp_10_websocket_8reader_c_15WebSocketReader_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyMemberDef __pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketReader_members[] = { + #if !CYTHON_USE_TYPE_SLOTS + {"__weaklistoffset__", T_PYSSIZET, offsetof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader, __weakref__), READONLY, 0}, + #endif + {0, 0, 0, 0, 0} +}; +static PyType_Slot __pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketReader_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7aiohttp_10_websocket_8reader_c_WebSocketReader}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_7aiohttp_10_websocket_8reader_c_WebSocketReader}, + {Py_tp_clear, (void *)__pyx_tp_clear_7aiohttp_10_websocket_8reader_c_WebSocketReader}, + {Py_tp_methods, (void *)__pyx_methods_7aiohttp_10_websocket_8reader_c_WebSocketReader}, + {Py_tp_init, (void *)__pyx_tp_init_7aiohttp_10_websocket_8reader_c_WebSocketReader}, + {Py_tp_new, (void *)__pyx_tp_new_7aiohttp_10_websocket_8reader_c_WebSocketReader}, + #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) && (!CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x030E0000) + #if CYTHON_VECTORCALL_TPNEW + {Py_tp_vectorcall, (void *)__pyx_tp_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketReader}, + #endif + #endif + {Py_tp_members, (void*)__pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketReader_members}, + {0, 0}, +}; +static PyType_Spec __pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketReader_spec = { + "aiohttp._websocket.reader_c.WebSocketReader", + sizeof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketReader_slots, +}; +#else + +static PyTypeObject __pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketReader = { + PyVarObject_HEAD_INIT(0, 0) + "aiohttp._websocket.reader_c.""WebSocketReader", /*tp_name*/ + sizeof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7aiohttp_10_websocket_8reader_c_WebSocketReader, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7aiohttp_10_websocket_8reader_c_WebSocketReader, /*tp_traverse*/ + __pyx_tp_clear_7aiohttp_10_websocket_8reader_c_WebSocketReader, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7aiohttp_10_websocket_8reader_c_WebSocketReader, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_tp_init_7aiohttp_10_websocket_8reader_c_WebSocketReader, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7aiohttp_10_websocket_8reader_c_WebSocketReader, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) && (!CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x030E0000) + #if CYTHON_VECTORCALL_TPNEW + __pyx_tp_vectorcall_7aiohttp_10_websocket_8reader_c_WebSocketReader, /*tp_vectorcall*/ + #else + NULL, /*tp_vectorcall*/ + #endif + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new__initialisation_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read(PyObject *o, +#if CYTHON_VECTORCALL_TPNEW + CYTHON_UNUSED PyObject *const *args, CYTHON_UNUSED Py_ssize_t nargs, CYTHON_UNUSED PyObject *kwnames +#else + CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k +#endif +) { + return o; +} + +static PyObject *__pyx_tp_new_vectorcall_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read(PyTypeObject *t, +#if CYTHON_VECTORCALL_TPNEW + PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames +#else + PyObject *a, PyObject *k +#endif +) { + PyObject *o; + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read > 0) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, __pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read, sizeof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read)))) + { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read[--__pyx_mstate_global->__pyx_freecount_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read]; + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(Py_TYPE(o)); + #endif + memset(o, 0, sizeof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read)); + #if CYTHON_COMPILING_IN_LIMITED_API + (void) PyObject_Init(o, t); + #else + (void) PyObject_INIT(o, t); + #endif + PyObject_GC_Track(o); + } else + #endif + { + o = __Pyx_AllocateExtensionType(t, 1); + } + if (unlikely(!o)) return 0; + return __pyx_tp_new__initialisation_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read(o, +#if CYTHON_VECTORCALL_TPNEW + args, nargs, kwnames +#else + a, k +#endif +); +} + +#if CYTHON_VECTORCALL_TPNEW +static PyObject *__pyx_tp_new_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read(PyTypeObject *t, PyObject *a, PyObject *k) { + return __Pyx_CallTpnewAsVectorcall(__pyx_tp_new_vectorcall_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read, t, a, k); +} +#endif + +#if CYTHON_VECTORCALL_TPNEW +static PyObject *__pyx_tp_vectorcall_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read(PyObject *t, PyObject *const *args, size_t nargsf, PyObject *kwnames) { + if (unlikely((PyTypeObject*)t != __pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read || __Pyx_PyType_HasFeature((PyTypeObject*)t, Py_TPFLAGS_IS_ABSTRACT))) { + return __Pyx_CallNewInitFromVectorcall((PyTypeObject*)t, args, nargsf, kwnames); + } + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *o = __pyx_tp_new_vectorcall_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read((PyTypeObject*)t, args, nargs, kwnames); + return o; +} +#endif + +static void __pyx_tp_dealloc_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read(PyObject *o) { + struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read *p = (struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_self); + Py_CLEAR(p->__pyx_t_0); + Py_CLEAR(p->__pyx_t_1); + Py_CLEAR(p->__pyx_t_2); + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read < 8) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(Py_TYPE(o), __pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read, sizeof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read)))) + { + __pyx_mstate_global->__pyx_freelist_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read[__pyx_mstate_global->__pyx_freecount_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read++] = ((struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read *)o); + } else + #endif + { + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif + } +} + +static int __pyx_tp_traverse_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read *p = (struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_v_self) { + e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + if (p->__pyx_t_1) { + e = (*v)(p->__pyx_t_1, a); if (e) return e; + } + if (p->__pyx_t_2) { + e = (*v)(p->__pyx_t_2, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read}, + {Py_tp_new, (void *)__pyx_tp_new_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read}, + #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) && (!CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x030E0000) + #if CYTHON_VECTORCALL_TPNEW + {Py_tp_vectorcall, (void *)__pyx_tp_vectorcall_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read}, + #endif + #endif + {0, 0}, +}; +static PyType_Spec __pyx_type_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read_spec = { + "aiohttp._websocket.reader_c.__pyx_scope_struct__read", + sizeof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_HAVE_GC, + __pyx_type_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read_slots, +}; +#else + +static PyTypeObject __pyx_type_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read = { + PyVarObject_HEAD_INIT(0, 0) + "aiohttp._websocket.reader_c.""__pyx_scope_struct__read", /*tp_name*/ + sizeof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) && (!CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x030E0000) + #if CYTHON_VECTORCALL_TPNEW + __pyx_tp_vectorcall_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read, /*tp_vectorcall*/ + #else + NULL, /*tp_vectorcall*/ + #endif + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; +/* #### Code section: initfunc_declarations ### */ +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitAfterSharedUtility(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_Global_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_Variable_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_Function_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_Exttype___pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_Exttype___pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_Exttype___pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_Type_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_Variable_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_Function_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate); /*proto*/ +/* #### Code section: init_module ### */ + +static int __Pyx_modinit_Global_init_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_Global_init_code", 0); + /*--- Global init code ---*/ + __pyx_v_7aiohttp_10_websocket_8reader_c_UNPACK_LEN3 = Py_None; Py_INCREF(Py_None); + __pyx_v_7aiohttp_10_websocket_8reader_c_UNPACK_CLOSE_CODE = Py_None; Py_INCREF(Py_None); + __pyx_v_7aiohttp_10_websocket_8reader_c_TUPLE_NEW = Py_None; Py_INCREF(Py_None); + __pyx_v_7aiohttp_10_websocket_8reader_c_WSMsgType = Py_None; Py_INCREF(Py_None); + __pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageText = Py_None; Py_INCREF(Py_None); + __pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageTextBytes = Py_None; Py_INCREF(Py_None); + __pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageBinary = Py_None; Py_INCREF(Py_None); + __pyx_v_7aiohttp_10_websocket_8reader_c_WSMessagePing = Py_None; Py_INCREF(Py_None); + __pyx_v_7aiohttp_10_websocket_8reader_c_WSMessagePong = Py_None; Py_INCREF(Py_None); + __pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageClose = Py_None; Py_INCREF(Py_None); + __pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_TEXT = Py_None; Py_INCREF(Py_None); + __pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_BINARY = Py_None; Py_INCREF(Py_None); + __pyx_v_7aiohttp_10_websocket_8reader_c_ALLOWED_CLOSE_CODES = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_7aiohttp_10_websocket_8reader_c_MESSAGE_TYPES_WITH_CONTENT = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_7aiohttp_10_websocket_8reader_c_EMPTY_FRAME = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_7aiohttp_10_websocket_8reader_c_EMPTY_FRAME_ERROR = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_7genexpr__pyx_v_7aiohttp_10_websocket_8reader_c_i = Py_None; Py_INCREF(Py_None); + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_Variable_export_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_Variable_export_code", 0); + /*--- Variable export code ---*/ + { + __pyx_t_1 = __Pyx_ApiExport_GetApiDict(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + const char * __pyx_export_signature = __Pyx_PyBytes_AsString(__pyx_mstate_global->__pyx_kp_b_PyObject_int_unsigned_PY_LONG_LO); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!__pyx_export_signature)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + const char * __pyx_export_name = __pyx_export_signature + 78; + void *const __pyx_export_pointers[] = {(void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_ALLOWED_CLOSE_CODES, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_EMPTY_FRAME, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_EMPTY_FRAME_ERROR, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_MESSAGE_TYPES_WITH_CONTENT, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_TUPLE_NEW, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_UNPACK_CLOSE_CODE, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_UNPACK_LEN3, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageBinary, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageClose, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessagePing, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessagePong, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageText, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageTextBytes, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_WSMsgType, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_BINARY, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_TEXT, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_COMPRESSED_FALSE, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_COMPRESSED_NOT_SET, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_COMPRESSED_TRUE, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_BINARY, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_CLOSE, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_CONTINUATION, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_NOT_SET, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_PING, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_PONG, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_TEXT, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_MAX_PAYLOAD_LEN, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_MSG_SIZE_OVERHEAD, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_READ_HEADER, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_READ_PAYLOAD, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_READ_PAYLOAD_LENGTH, (void *)&__pyx_v_7aiohttp_10_websocket_8reader_c_READ_PAYLOAD_MASK, (void *) NULL}; + void *const *__pyx_export_pointer = __pyx_export_pointers; + const char *__pyx_export_current_signature = __pyx_export_signature; + while (*__pyx_export_pointer) { + if (__Pyx_ExportVoidPtr(__pyx_t_1, __pyx_export_name, *__pyx_export_pointer, __pyx_export_current_signature) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + ++__pyx_export_pointer; + __pyx_export_name = strchr(__pyx_export_name, '\0') + 1; + __pyx_export_signature = strchr(__pyx_export_signature, '\0') + 1; + if (*__pyx_export_signature != '\0') __pyx_export_current_signature = __pyx_export_signature; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_Function_export_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_Function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_Exttype___pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_Exttype___pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue", 0); + /*--- Exttype __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue ---*/ + __pyx_vtabptr_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue = &__pyx_vtable_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue; + __pyx_vtable_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue._release_waiter = (void (*)(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *))__pyx_f_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__release_waiter; + __pyx_vtable_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue.feed_data = (void (*)(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *, PyObject *, int __pyx_skip_dispatch))__pyx_f_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_feed_data; + __pyx_vtable_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue._read_from_buffer = (PyObject *(*)(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue *))__pyx_f_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue__read_from_buffer; + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue)) __PYX_ERR(0, 81, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue = &__pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue) < (0)) __PYX_ERR(0, 81, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue->tp_dictoffset && __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, __pyx_vtabptr_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue) < (0)) __PYX_ERR(0, 81, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_WebSocketDataQueue, (PyObject *) __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue) < (0)) __PYX_ERR(0, 81, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue) < (0)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_Exttype___pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_Exttype___pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader", 0); + /*--- Exttype __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader ---*/ + __pyx_vtabptr_7aiohttp_10_websocket_8reader_c_WebSocketReader = &__pyx_vtable_7aiohttp_10_websocket_8reader_c_WebSocketReader; + __pyx_vtable_7aiohttp_10_websocket_8reader_c_WebSocketReader.feed_data = (PyObject *(*)(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *, PyObject *, int __pyx_skip_dispatch))__pyx_f_7aiohttp_10_websocket_8reader_c_15WebSocketReader_feed_data; + __pyx_vtable_7aiohttp_10_websocket_8reader_c_WebSocketReader._handle_frame = (void (*)(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *, int, int, PyObject *, int, int __pyx_skip_dispatch))__pyx_f_7aiohttp_10_websocket_8reader_c_15WebSocketReader__handle_frame; + __pyx_vtable_7aiohttp_10_websocket_8reader_c_WebSocketReader._feed_data = (void (*)(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader *, PyObject *, int __pyx_skip_dispatch))__pyx_f_7aiohttp_10_websocket_8reader_c_15WebSocketReader__feed_data; + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketReader_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader)) __PYX_ERR(0, 190, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader = &__pyx_type_7aiohttp_10_websocket_8reader_c_WebSocketReader; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader) < (0)) __PYX_ERR(0, 190, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader->tp_dictoffset && __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader, __pyx_vtabptr_7aiohttp_10_websocket_8reader_c_WebSocketReader) < (0)) __PYX_ERR(0, 190, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_WebSocketReader, (PyObject *) __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader) < (0)) __PYX_ERR(0, 190, __pyx_L1_error) + #if CYTHON_USE_TYPE_SLOTS + if (__pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader->tp_weaklistoffset == 0) __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader->tp_weaklistoffset = offsetof(struct __pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader, __weakref__); + #endif + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader) < (0)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_Exttype___pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_Exttype___pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read", 0); + /*--- Exttype __pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read ---*/ + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read)) __PYX_ERR(0, 141, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read = &__pyx_type_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read) < (0)) __PYX_ERR(0, 141, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read->tp_dictoffset && __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read->tp_getattro = PyObject_GenericGetAttr; + } + #endif + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_Type_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_Type_import_code", 0); + /*--- Type import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_Variable_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_Variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_Function_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_Function_import_code", 0); + /*--- Function import code ---*/ + { + __pyx_t_1 = PyImport_ImportModule("aiohttp._websocket.mask"); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + const char * __pyx_import_signature = __Pyx_PyBytes_AsString(__pyx_mstate_global->__pyx_kp_b_void_PyObject_PyObject_int___pyx); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!__pyx_import_signature)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + const char * __pyx_import_name = __pyx_import_signature + 55; + void (**const __pyx_import_pointers[])(void) = {(void (**)(void))&__pyx_f_7aiohttp_10_websocket_4mask__websocket_mask_cython, (void (**)(void)) NULL}; + void (**const *__pyx_import_pointer)(void) = __pyx_import_pointers; + const char *__pyx_import_current_signature = __pyx_import_signature; + while (*__pyx_import_pointer) { + if (__Pyx_ImportFunction_3_3_0(__pyx_t_1, __pyx_import_name, *__pyx_import_pointer, __pyx_import_current_signature) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + ++__pyx_import_pointer; + __pyx_import_name = strchr(__pyx_import_name, '\0') + 1; + __pyx_import_signature = strchr(__pyx_import_signature, '\0') + 1; + if (*__pyx_import_signature != '\0') __pyx_import_current_signature = __pyx_import_signature; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_reader_c(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_reader_c}, + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + {Py_mod_gil, __Pyx_FREETHREADING_COMPATIBLE}, + #endif + #if PY_VERSION_HEX >= 0x030C0000 && CYTHON_USE_MODULE_STATE + {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED}, + #endif + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "reader_c", + __pyx_k_Reader_for_WebSocket_protocol_ve, /* m_doc */ + #if CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstatetype), /* m_size */ + #else + (CYTHON_PEP489_MULTI_PHASE_INIT) ? 0 : -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif + +/* PyModInitFuncType */ +#ifndef CYTHON_NO_PYINIT_EXPORT + #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#else + #ifdef __cplusplus + #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * + #else + #define __Pyx_PyMODINIT_FUNC PyObject * + #endif +#endif + +__Pyx_PyMODINIT_FUNC PyInit_reader_c(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_reader_c(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +/* ModuleCreationPEP489 */ +#if CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x030A0000 &&\ + (defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS))) +static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) { + { + PyObject *module = PyImport_ImportModule("_interpreters"); // 3.13+ I think + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_Exception)) { + goto bad; // BaseException + } + PyErr_Clear(); // just try the 3.8-3.12 version + module = PyImport_ImportModule("_xxsubinterpreters"); + if (!module) goto bad; + } + PyObject *current = PyObject_CallMethod(module, "get_current", NULL); + Py_DECREF(module); + if (!current) goto bad; + if (PyTuple_Check(current)) { + PyObject *new_current = PySequence_GetItem(current, 0); + Py_DECREF(current); + current = new_current; + if (!new_current) goto bad; + } + long long as_c_int = PyLong_AsLongLong(current); + Py_DECREF(current); + return as_c_int; + } + bad: + PySys_WriteStderr("__Pyx_GetCurrentInterpreterId failed. Try setting the C define CYTHON_PEP489_MULTI_PHASE_INIT=0\n"); + return -1; +} +#endif +#if !CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + static PY_INT64_T main_interpreter_id = -1; +#if CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000 + PY_INT64_T current_id = GraalPyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); +#elif CYTHON_COMPILING_IN_GRAAL + PY_INT64_T current_id = PyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); +#elif CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x030A0000 &&\ + (defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS))) + PY_INT64_T current_id = __Pyx_GetCurrentInterpreterId(); +#elif CYTHON_COMPILING_IN_LIMITED_API + PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get()); +#else + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); +#endif + if (unlikely(current_id == -1)) { + return -1; + } + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return 0; + } else if (unlikely(main_interpreter_id != current_id)) { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +#endif +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +{ + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); + #if !CYTHON_USE_MODULE_STATE + if (__Pyx_check_single_interpreter()) + return NULL; + #endif + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_reader_c(PyObject *__pyx_pyinit_module) +#endif +{ + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif + __pyx_mstatetype *__pyx_mstate = NULL; + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *(*__pyx_t_6)(PyObject *); + unsigned PY_LONG_LONG __pyx_t_7; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'reader_c' has already been imported. Re-initialisation is not supported."); + return -1; + } + #else + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_t_1 = __pyx_pyinit_module; + Py_INCREF(__pyx_t_1); + #else + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #if CYTHON_USE_MODULE_STATE + { + int add_module_result = __Pyx_State_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "reader_c" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = __pyx_t_1; + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + PyUnstable_Module_SetGIL(__pyx_m, Py_MOD_GIL_NOT_USED); + #endif + __pyx_mstate = __pyx_mstate_global; + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_mstate->__pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_mstate->__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_mstate->__pyx_d); + __pyx_mstate->__pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_mstate->__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_cython_runtime = __Pyx_PyImport_AddModuleRef("cython_runtime"); if (unlikely(!__pyx_mstate->__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_mstate->__pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /* ImportRefnannyAPI */ + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + if (PyErr_ExceptionMatches(PyExc_Exception)) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + } + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + +__Pyx_RefNannySetupContext("PyInit_reader_c", 0); + __Pyx_init_runtime_version(); + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_mstate->__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Library function declarations ---*/ + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; + if (__Pyx_InitGlobals() < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_module_is_main_aiohttp___websocket__reader_c) { + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name, __pyx_mstate_global->__pyx_n_u_main) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "aiohttp._websocket.reader_c")) { + if (unlikely((PyDict_SetItemString(modules, "aiohttp._websocket.reader_c", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_CreateCodeObjects(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_Global_init_code(__pyx_mstate); + if (unlikely((__Pyx_modinit_Variable_export_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_Function_export_code(__pyx_mstate); + /*--- Type init code ---*/ + if (unlikely((__Pyx_modinit_Exttype___pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_Exttype___pyx_obj_7aiohttp_10_websocket_8reader_c_WebSocketReader(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_Exttype___pyx_obj_7aiohttp_10_websocket_8reader_c___pyx_scope_struct__read(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_Type_import_code(__pyx_mstate); + (void)__Pyx_modinit_Variable_import_code(__pyx_mstate); + if (unlikely((__Pyx_modinit_Function_import_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_InitAfterSharedUtility() < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Execution code ---*/ + + /* "aiohttp/_websocket/reader_py.py":3 + * """Reader for WebSocket protocol versions 13 and 8.""" + * + * import asyncio # <<<<<<<<<<<<<< + * import builtins + * import sys +*/ + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_asyncio, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3, __pyx_L1_error) + __pyx_t_2 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_asyncio, __pyx_t_2) < (0)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":4 + * + * import asyncio + * import builtins # <<<<<<<<<<<<<< + * import sys + * import weakref +*/ + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_builtins, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __pyx_t_2 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_builtins, __pyx_t_2) < (0)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":5 + * import asyncio + * import builtins + * import sys # <<<<<<<<<<<<<< + * import weakref + * from collections import deque +*/ + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_sys, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __pyx_t_2 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_sys, __pyx_t_2) < (0)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":6 + * import builtins + * import sys + * import weakref # <<<<<<<<<<<<<< + * from collections import deque + * +*/ + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_weakref, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + __pyx_t_2 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_weakref, __pyx_t_2) < (0)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":7 + * import sys + * import weakref + * from collections import deque # <<<<<<<<<<<<<< + * + * from ..base_protocol import BaseProtocol +*/ + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_deque}; + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_collections, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + } + __pyx_t_2 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_2); + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_deque}; + __pyx_t_3 = 0; { + __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":9 + * from collections import deque + * + * from ..base_protocol import BaseProtocol # <<<<<<<<<<<<<< + * from ..compression_utils import TooManyMembersError, ZLibDecompressor + * from ..helpers import _EXC_SENTINEL, set_exception +*/ + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_BaseProtocol}; + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_base_protocol, __pyx_imported_names, 1, __pyx_mstate_global->__pyx_kp_u_aiohttp_base_protocol, 2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) + } + __pyx_t_2 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_2); + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_BaseProtocol}; + __pyx_t_3 = 0; { + __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":10 + * + * from ..base_protocol import BaseProtocol + * from ..compression_utils import TooManyMembersError, ZLibDecompressor # <<<<<<<<<<<<<< + * from ..helpers import _EXC_SENTINEL, set_exception + * from ..log import ws_logger +*/ + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_TooManyMembersError,__pyx_mstate_global->__pyx_n_u_ZLibDecompressor}; + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_compression_utils, __pyx_imported_names, 2, __pyx_mstate_global->__pyx_kp_u_aiohttp_compression_utils, 2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error) + } + __pyx_t_2 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_2); + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_TooManyMembersError,__pyx_mstate_global->__pyx_n_u_ZLibDecompressor}; + for (__pyx_t_3=0; __pyx_t_3 < 2; __pyx_t_3++) { + __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":11 + * from ..base_protocol import BaseProtocol + * from ..compression_utils import TooManyMembersError, ZLibDecompressor + * from ..helpers import _EXC_SENTINEL, set_exception # <<<<<<<<<<<<<< + * from ..log import ws_logger + * from ..streams import EofStream +*/ + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_EXC_SENTINEL,__pyx_mstate_global->__pyx_n_u_set_exception}; + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_helpers, __pyx_imported_names, 2, __pyx_mstate_global->__pyx_kp_u_aiohttp_helpers, 2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error) + } + __pyx_t_2 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_2); + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_EXC_SENTINEL,__pyx_mstate_global->__pyx_n_u_set_exception}; + for (__pyx_t_3=0; __pyx_t_3 < 2; __pyx_t_3++) { + __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 11, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":12 + * from ..compression_utils import TooManyMembersError, ZLibDecompressor + * from ..helpers import _EXC_SENTINEL, set_exception + * from ..log import ws_logger # <<<<<<<<<<<<<< + * from ..streams import EofStream + * from .helpers import UNPACK_CLOSE_CODE, UNPACK_LEN3, websocket_mask +*/ + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_ws_logger}; + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_log, __pyx_imported_names, 1, __pyx_mstate_global->__pyx_kp_u_aiohttp_log, 2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) + } + __pyx_t_2 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_2); + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_ws_logger}; + __pyx_t_3 = 0; { + __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":13 + * from ..helpers import _EXC_SENTINEL, set_exception + * from ..log import ws_logger + * from ..streams import EofStream # <<<<<<<<<<<<<< + * from .helpers import UNPACK_CLOSE_CODE, UNPACK_LEN3, websocket_mask + * from .models import ( +*/ + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_EofStream}; + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_streams, __pyx_imported_names, 1, __pyx_mstate_global->__pyx_kp_u_aiohttp_streams, 2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) + } + __pyx_t_2 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_2); + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_EofStream}; + __pyx_t_3 = 0; { + __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":14 + * from ..log import ws_logger + * from ..streams import EofStream + * from .helpers import UNPACK_CLOSE_CODE, UNPACK_LEN3, websocket_mask # <<<<<<<<<<<<<< + * from .models import ( + * WS_DEFLATE_TRAILING, +*/ + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_UNPACK_CLOSE_CODE,__pyx_mstate_global->__pyx_n_u_UNPACK_LEN3,__pyx_mstate_global->__pyx_n_u_websocket_mask}; + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_helpers, __pyx_imported_names, 3, __pyx_mstate_global->__pyx_kp_u_aiohttp__websocket_helpers, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) + } + __pyx_t_2 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_2); + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_UNPACK_CLOSE_CODE,__pyx_mstate_global->__pyx_n_u_UNPACK_LEN3,__pyx_mstate_global->__pyx_n_u_websocket_mask}; + for (__pyx_t_3=0; __pyx_t_3 < 3; __pyx_t_3++) { + __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + switch (__pyx_t_3) { + case 0: + __Pyx_INCREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_7aiohttp_10_websocket_8reader_c_UNPACK_CLOSE_CODE); + __Pyx_DECREF_SET(__pyx_v_7aiohttp_10_websocket_8reader_c_UNPACK_CLOSE_CODE, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + break; + case 1: + __Pyx_INCREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_7aiohttp_10_websocket_8reader_c_UNPACK_LEN3); + __Pyx_DECREF_SET(__pyx_v_7aiohttp_10_websocket_8reader_c_UNPACK_LEN3, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + break; + default:; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 14, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":15 + * from ..streams import EofStream + * from .helpers import UNPACK_CLOSE_CODE, UNPACK_LEN3, websocket_mask + * from .models import ( # <<<<<<<<<<<<<< + * WS_DEFLATE_TRAILING, + * WebSocketError, +*/ + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_WS_DEFLATE_TRAILING,__pyx_mstate_global->__pyx_n_u_WebSocketError,__pyx_mstate_global->__pyx_n_u_WSCloseCode,__pyx_mstate_global->__pyx_n_u_WSMessage,__pyx_mstate_global->__pyx_n_u_WSMessageBinary,__pyx_mstate_global->__pyx_n_u_WSMessageClose,__pyx_mstate_global->__pyx_n_u_WSMessagePing,__pyx_mstate_global->__pyx_n_u_WSMessagePong,__pyx_mstate_global->__pyx_n_u_WSMessageText,__pyx_mstate_global->__pyx_n_u_WSMessageTextBytes,__pyx_mstate_global->__pyx_n_u_WSMsgType}; + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_models, __pyx_imported_names, 11, __pyx_mstate_global->__pyx_kp_u_aiohttp__websocket_models, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error) + } + __pyx_t_2 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_2); + { + PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_WS_DEFLATE_TRAILING,__pyx_mstate_global->__pyx_n_u_WebSocketError,__pyx_mstate_global->__pyx_n_u_WSCloseCode,__pyx_mstate_global->__pyx_n_u_WSMessage,__pyx_mstate_global->__pyx_n_u_WSMessageBinary,__pyx_mstate_global->__pyx_n_u_WSMessageClose,__pyx_mstate_global->__pyx_n_u_WSMessagePing,__pyx_mstate_global->__pyx_n_u_WSMessagePong,__pyx_mstate_global->__pyx_n_u_WSMessageText,__pyx_mstate_global->__pyx_n_u_WSMessageTextBytes,__pyx_mstate_global->__pyx_n_u_WSMsgType}; + for (__pyx_t_3=0; __pyx_t_3 < 11; __pyx_t_3++) { + __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + switch (__pyx_t_3) { + case 4: + __Pyx_INCREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageBinary); + __Pyx_DECREF_SET(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageBinary, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + break; + case 5: + __Pyx_INCREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageClose); + __Pyx_DECREF_SET(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageClose, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + break; + case 6: + __Pyx_INCREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessagePing); + __Pyx_DECREF_SET(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessagePing, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + break; + case 7: + __Pyx_INCREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessagePong); + __Pyx_DECREF_SET(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessagePong, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + break; + case 8: + __Pyx_INCREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageText); + __Pyx_DECREF_SET(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageText, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + break; + case 9: + __Pyx_INCREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageTextBytes); + __Pyx_DECREF_SET(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMessageTextBytes, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + break; + case 10: + __Pyx_INCREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMsgType); + __Pyx_DECREF_SET(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMsgType, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + break; + default:; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 15, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":31 + * # ABNORMAL_CLOSURE is used internally, should never be accepted from a client. + * # https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.1 + * ALLOWED_CLOSE_CODES = {int(i) for i in WSCloseCode} - { # <<<<<<<<<<<<<< + * int(WSCloseCode.ABNORMAL_CLOSURE) + * } +*/ + { /* enter inner scope */ + __pyx_t_2 = PySet_New(NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 31, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 31, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) { + __pyx_t_5 = __pyx_t_4; __Pyx_INCREF(__pyx_t_5); + __pyx_t_3 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 31, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 31, __pyx_L4_error) + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_5))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 31, __pyx_L4_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_5, __pyx_t_3, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_3; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 31, __pyx_L4_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_3)); + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_3); + #endif + ++__pyx_t_3; + } + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 31, __pyx_L4_error) + } else { + __pyx_t_4 = __pyx_t_6(__pyx_t_5); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 31, __pyx_L4_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_7genexpr__pyx_v_7aiohttp_10_websocket_8reader_c_i); + __Pyx_DECREF_SET(__pyx_7genexpr__pyx_v_7aiohttp_10_websocket_8reader_c_i, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyNumber_Int(__pyx_7genexpr__pyx_v_7aiohttp_10_websocket_8reader_c_i); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 31, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + if (unlikely(PySet_Add(__pyx_t_2, __pyx_t_4))) __PYX_ERR(0, 31, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_7genexpr__pyx_v_7aiohttp_10_websocket_8reader_c_i); + __Pyx_DECREF_SET(__pyx_7genexpr__pyx_v_7aiohttp_10_websocket_8reader_c_i, Py_None); + goto __pyx_L8_exit_scope; + __pyx_L4_error:; + __Pyx_GOTREF(__pyx_7genexpr__pyx_v_7aiohttp_10_websocket_8reader_c_i); + __Pyx_DECREF_SET(__pyx_7genexpr__pyx_v_7aiohttp_10_websocket_8reader_c_i, Py_None); + goto __pyx_L1_error; + __pyx_L8_exit_scope:; + } /* exit inner scope */ + + /* "aiohttp/_websocket/reader_py.py":32 + * # https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.1 + * ALLOWED_CLOSE_CODES = {int(i) for i in WSCloseCode} - { + * int(WSCloseCode.ABNORMAL_CLOSURE) # <<<<<<<<<<<<<< + * } + * +*/ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_WSCloseCode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ABNORMAL_CLOSURE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyNumber_Int(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PySet_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PySet_Add(__pyx_t_4, __pyx_t_5) < (0)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "aiohttp/_websocket/reader_py.py":31 + * # ABNORMAL_CLOSURE is used internally, should never be accepted from a client. + * # https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.1 + * ALLOWED_CLOSE_CODES = {int(i) for i in WSCloseCode} - { # <<<<<<<<<<<<<< + * int(WSCloseCode.ABNORMAL_CLOSURE) + * } +*/ + __pyx_t_5 = PyNumber_Subtract(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!(likely(PySet_CheckExact(__pyx_t_5)) || __Pyx_RaiseUnexpectedTypeError("set", __pyx_t_5))) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_v_7aiohttp_10_websocket_8reader_c_ALLOWED_CLOSE_CODES); + __Pyx_DECREF_SET(__pyx_v_7aiohttp_10_websocket_8reader_c_ALLOWED_CLOSE_CODES, ((PyObject*)__pyx_t_5)); + __Pyx_GIVEREF(__pyx_t_5); + __pyx_t_5 = 0; + + /* "aiohttp/_websocket/reader_py.py":37 + * # States for the reader, used to parse the WebSocket frame + * # integer values are used so they can be cythonized + * READ_HEADER = 1 # <<<<<<<<<<<<<< + * READ_PAYLOAD_LENGTH = 2 + * READ_PAYLOAD_MASK = 3 +*/ + __pyx_v_7aiohttp_10_websocket_8reader_c_READ_HEADER = 1; + + /* "aiohttp/_websocket/reader_py.py":38 + * # integer values are used so they can be cythonized + * READ_HEADER = 1 + * READ_PAYLOAD_LENGTH = 2 # <<<<<<<<<<<<<< + * READ_PAYLOAD_MASK = 3 + * READ_PAYLOAD = 4 +*/ + __pyx_v_7aiohttp_10_websocket_8reader_c_READ_PAYLOAD_LENGTH = 2; + + /* "aiohttp/_websocket/reader_py.py":39 + * READ_HEADER = 1 + * READ_PAYLOAD_LENGTH = 2 + * READ_PAYLOAD_MASK = 3 # <<<<<<<<<<<<<< + * READ_PAYLOAD = 4 + * +*/ + __pyx_v_7aiohttp_10_websocket_8reader_c_READ_PAYLOAD_MASK = 3; + + /* "aiohttp/_websocket/reader_py.py":40 + * READ_PAYLOAD_LENGTH = 2 + * READ_PAYLOAD_MASK = 3 + * READ_PAYLOAD = 4 # <<<<<<<<<<<<<< + * + * # Largest declared payload length the reader can represent: the compiled +*/ + __pyx_v_7aiohttp_10_websocket_8reader_c_READ_PAYLOAD = 4; + + /* "aiohttp/_websocket/reader_py.py":46 + * # (the win32 and armv7l wheels) and 2**63-1 everywhere else. + * # TODO: Remove when we drop 32 bit support (and from reader_c.pxd). + * MAX_PAYLOAD_LEN = sys.maxsize # <<<<<<<<<<<<<< + * + * WS_MSG_TYPE_BINARY = WSMsgType.BINARY +*/ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_sys); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_maxsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = __Pyx_PyLong_As_unsigned_PY_LONG_LONG(__pyx_t_4); if (unlikely((__pyx_t_7 == (unsigned PY_LONG_LONG)-1) && PyErr_Occurred())) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_7aiohttp_10_websocket_8reader_c_MAX_PAYLOAD_LEN = __pyx_t_7; + + /* "aiohttp/_websocket/reader_py.py":48 + * MAX_PAYLOAD_LEN = sys.maxsize + * + * WS_MSG_TYPE_BINARY = WSMsgType.BINARY # <<<<<<<<<<<<<< + * WS_MSG_TYPE_TEXT = WSMsgType.TEXT + * +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMsgType, __pyx_mstate_global->__pyx_n_u_BINARY); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_BINARY); + __Pyx_DECREF_SET(__pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_BINARY, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "aiohttp/_websocket/reader_py.py":49 + * + * WS_MSG_TYPE_BINARY = WSMsgType.BINARY + * WS_MSG_TYPE_TEXT = WSMsgType.TEXT # <<<<<<<<<<<<<< + * + * # WSMsgType values unpacked so they can by cythonized to ints +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMsgType, __pyx_mstate_global->__pyx_n_u_TEXT); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_TEXT); + __Pyx_DECREF_SET(__pyx_v_7aiohttp_10_websocket_8reader_c_WS_MSG_TYPE_TEXT, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "aiohttp/_websocket/reader_py.py":52 + * + * # WSMsgType values unpacked so they can by cythonized to ints + * OP_CODE_NOT_SET = -1 # <<<<<<<<<<<<<< + * OP_CODE_CONTINUATION = WSMsgType.CONTINUATION.value + * OP_CODE_TEXT = WSMsgType.TEXT.value +*/ + __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_NOT_SET = -1; + + /* "aiohttp/_websocket/reader_py.py":53 + * # WSMsgType values unpacked so they can by cythonized to ints + * OP_CODE_NOT_SET = -1 + * OP_CODE_CONTINUATION = WSMsgType.CONTINUATION.value # <<<<<<<<<<<<<< + * OP_CODE_TEXT = WSMsgType.TEXT.value + * OP_CODE_BINARY = WSMsgType.BINARY.value +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMsgType, __pyx_mstate_global->__pyx_n_u_CONTINUATION); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_value); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_8 = __Pyx_PyLong_As_int(__pyx_t_5); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_CONTINUATION = __pyx_t_8; + + /* "aiohttp/_websocket/reader_py.py":54 + * OP_CODE_NOT_SET = -1 + * OP_CODE_CONTINUATION = WSMsgType.CONTINUATION.value + * OP_CODE_TEXT = WSMsgType.TEXT.value # <<<<<<<<<<<<<< + * OP_CODE_BINARY = WSMsgType.BINARY.value + * OP_CODE_CLOSE = WSMsgType.CLOSE.value +*/ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMsgType, __pyx_mstate_global->__pyx_n_u_TEXT); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_8 = __Pyx_PyLong_As_int(__pyx_t_4); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 54, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_TEXT = __pyx_t_8; + + /* "aiohttp/_websocket/reader_py.py":55 + * OP_CODE_CONTINUATION = WSMsgType.CONTINUATION.value + * OP_CODE_TEXT = WSMsgType.TEXT.value + * OP_CODE_BINARY = WSMsgType.BINARY.value # <<<<<<<<<<<<<< + * OP_CODE_CLOSE = WSMsgType.CLOSE.value + * OP_CODE_PING = WSMsgType.PING.value +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMsgType, __pyx_mstate_global->__pyx_n_u_BINARY); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_value); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_8 = __Pyx_PyLong_As_int(__pyx_t_5); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 55, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_BINARY = __pyx_t_8; + + /* "aiohttp/_websocket/reader_py.py":56 + * OP_CODE_TEXT = WSMsgType.TEXT.value + * OP_CODE_BINARY = WSMsgType.BINARY.value + * OP_CODE_CLOSE = WSMsgType.CLOSE.value # <<<<<<<<<<<<<< + * OP_CODE_PING = WSMsgType.PING.value + * OP_CODE_PONG = WSMsgType.PONG.value +*/ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMsgType, __pyx_mstate_global->__pyx_n_u_CLOSE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_8 = __Pyx_PyLong_As_int(__pyx_t_4); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_CLOSE = __pyx_t_8; + + /* "aiohttp/_websocket/reader_py.py":57 + * OP_CODE_BINARY = WSMsgType.BINARY.value + * OP_CODE_CLOSE = WSMsgType.CLOSE.value + * OP_CODE_PING = WSMsgType.PING.value # <<<<<<<<<<<<<< + * OP_CODE_PONG = WSMsgType.PONG.value + * +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMsgType, __pyx_mstate_global->__pyx_n_u_PING); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_value); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_8 = __Pyx_PyLong_As_int(__pyx_t_5); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_PING = __pyx_t_8; + + /* "aiohttp/_websocket/reader_py.py":58 + * OP_CODE_CLOSE = WSMsgType.CLOSE.value + * OP_CODE_PING = WSMsgType.PING.value + * OP_CODE_PONG = WSMsgType.PONG.value # <<<<<<<<<<<<<< + * + * EMPTY_FRAME_ERROR = (True, b"") +*/ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7aiohttp_10_websocket_8reader_c_WSMsgType, __pyx_mstate_global->__pyx_n_u_PONG); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_8 = __Pyx_PyLong_As_int(__pyx_t_4); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_7aiohttp_10_websocket_8reader_c_OP_CODE_PONG = __pyx_t_8; + + /* "aiohttp/_websocket/reader_py.py":60 + * OP_CODE_PONG = WSMsgType.PONG.value + * + * EMPTY_FRAME_ERROR = (True, b"") # <<<<<<<<<<<<<< + * EMPTY_FRAME = (False, b"") + * +*/ + __Pyx_INCREF(__pyx_mstate_global->__pyx_tuple[2]); + __Pyx_XGOTREF(__pyx_v_7aiohttp_10_websocket_8reader_c_EMPTY_FRAME_ERROR); + __Pyx_DECREF_SET(__pyx_v_7aiohttp_10_websocket_8reader_c_EMPTY_FRAME_ERROR, __pyx_mstate_global->__pyx_tuple[2]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[2]); + + /* "aiohttp/_websocket/reader_py.py":61 + * + * EMPTY_FRAME_ERROR = (True, b"") + * EMPTY_FRAME = (False, b"") # <<<<<<<<<<<<<< + * + * COMPRESSED_NOT_SET = -1 +*/ + __Pyx_INCREF(__pyx_mstate_global->__pyx_tuple[3]); + __Pyx_XGOTREF(__pyx_v_7aiohttp_10_websocket_8reader_c_EMPTY_FRAME); + __Pyx_DECREF_SET(__pyx_v_7aiohttp_10_websocket_8reader_c_EMPTY_FRAME, __pyx_mstate_global->__pyx_tuple[3]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[3]); + + /* "aiohttp/_websocket/reader_py.py":63 + * EMPTY_FRAME = (False, b"") + * + * COMPRESSED_NOT_SET = -1 # <<<<<<<<<<<<<< + * COMPRESSED_FALSE = 0 + * COMPRESSED_TRUE = 1 +*/ + __pyx_v_7aiohttp_10_websocket_8reader_c_COMPRESSED_NOT_SET = -1; + + /* "aiohttp/_websocket/reader_py.py":64 + * + * COMPRESSED_NOT_SET = -1 + * COMPRESSED_FALSE = 0 # <<<<<<<<<<<<<< + * COMPRESSED_TRUE = 1 + * +*/ + __pyx_v_7aiohttp_10_websocket_8reader_c_COMPRESSED_FALSE = 0; + + /* "aiohttp/_websocket/reader_py.py":65 + * COMPRESSED_NOT_SET = -1 + * COMPRESSED_FALSE = 0 + * COMPRESSED_TRUE = 1 # <<<<<<<<<<<<<< + * + * TUPLE_NEW = tuple.__new__ +*/ + __pyx_v_7aiohttp_10_websocket_8reader_c_COMPRESSED_TRUE = 1; + + /* "aiohttp/_websocket/reader_py.py":67 + * COMPRESSED_TRUE = 1 + * + * TUPLE_NEW = tuple.__new__ # <<<<<<<<<<<<<< + * + * # Overhead added to each message to ensure that tiny messages can't use +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)(&PyTuple_Type)), __pyx_mstate_global->__pyx_n_u_new); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 67, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_7aiohttp_10_websocket_8reader_c_TUPLE_NEW); + __Pyx_DECREF_SET(__pyx_v_7aiohttp_10_websocket_8reader_c_TUPLE_NEW, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "aiohttp/_websocket/reader_py.py":71 + * # Overhead added to each message to ensure that tiny messages can't use + * # unreasonable amounts of memory. + * MSG_SIZE_OVERHEAD = 128 # <<<<<<<<<<<<<< + * + * STALLED_READER_COLLECTED = ( +*/ + __pyx_v_7aiohttp_10_websocket_8reader_c_MSG_SIZE_OVERHEAD = 0x80; + + /* "aiohttp/_websocket/reader_py.py":74 + * + * STALLED_READER_COLLECTED = ( + * "WebSocketReader was garbage collected while stalled; " # <<<<<<<<<<<<<< + * "callers of set_parser() must hold a strong reference" + * ) +*/ + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STALLED_READER_COLLECTED, __pyx_mstate_global->__pyx_kp_u_WebSocketReader_was_garbage_coll) < (0)) __PYX_ERR(0, 73, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":78 + * ) + * + * cython_int = int # Typed to int in Python, but cython with use a signed int in the pxd # <<<<<<<<<<<<<< + * + * +*/ + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_cython_int, ((PyObject *)(&PyLong_Type))) < (0)) __PYX_ERR(0, 78, __pyx_L1_error) + + /* "aiohttp/_websocket/reader_py.py":102 + * self._stalled_reader: "weakref.ref[WebSocketReader] | None" = None + * + * def is_eof(self) -> bool: # <<<<<<<<<<<<<< + * return self._eof + * +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < (0)) __PYX_ERR(0, 102, __pyx_L1_error) + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_3is_eof, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_WebSocketDataQueue_is_eof, NULL, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, __pyx_mstate_global->__pyx_n_u_is_eof, __pyx_t_5) < (0)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "aiohttp/_websocket/reader_py.py":105 + * return self._eof + * + * def exception(self) -> type[BaseException] | BaseException | None: # <<<<<<<<<<<<<< + * return self._exception + * +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_kp_u_type_BaseException_BaseException) < (0)) __PYX_ERR(0, 105, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_5exception, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_WebSocketDataQueue_exception, NULL, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, __pyx_mstate_global->__pyx_n_u_exception, __pyx_t_4) < (0)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "aiohttp/_websocket/reader_py.py":111 + * self, + * exc: type[BaseException] | BaseException, + * exc_cause: builtins.BaseException = _EXC_SENTINEL, # <<<<<<<<<<<<<< + * ) -> None: + * self._eof = True +*/ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_EXC_SENTINEL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_mstate_global->__pyx_k__2 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "aiohttp/_websocket/reader_py.py":108 + * return self._exception + * + * def set_exception( # <<<<<<<<<<<<<< + * self, + * exc: type[BaseException] | BaseException, +*/ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_EXC_SENTINEL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + { + PyObject* __pyx_temp[1] = {__pyx_t_4}; + __pyx_t_5 = __Pyx_PyTuple_FromArray(__pyx_temp, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_exc, __pyx_mstate_global->__pyx_kp_u_type_BaseException_BaseException_2) < (0)) __PYX_ERR(0, 108, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_exc_cause, __pyx_mstate_global->__pyx_kp_u_builtins_BaseException) < (0)) __PYX_ERR(0, 108, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < (0)) __PYX_ERR(0, 108, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_7set_exception, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_WebSocketDataQueue_set_exception, NULL, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_5); + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, __pyx_mstate_global->__pyx_n_u_set_exception, __pyx_t_2) < (0)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":126 + * waiter.set_result(None) + * + * def feed_eof(self) -> None: # <<<<<<<<<<<<<< + * self._eof = True + * self._release_waiter() +*/ + __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < (0)) __PYX_ERR(0, 126, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_9feed_eof, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_WebSocketDataQueue_feed_eof, NULL, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, __pyx_mstate_global->__pyx_n_u_feed_eof, __pyx_t_4) < (0)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "aiohttp/_websocket/reader_py.py":131 + * self._exception = None # Break cyclic references + * + * def feed_data(self, data: "WSMessage") -> None: # <<<<<<<<<<<<<< + * # Unbox into the typed local before adding, so Cython keeps the sum in + * # C instead of boxing MSG_SIZE_OVERHEAD for a Python-level add. +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_data, __pyx_mstate_global->__pyx_kp_u_WSMessage_2) < (0)) __PYX_ERR(0, 131, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_11feed_data, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_WebSocketDataQueue_feed_data, NULL, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, __pyx_mstate_global->__pyx_n_u_feed_data, __pyx_t_2) < (0)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":141 + * self._protocol.pause_reading() + * + * async def read(self) -> WSMessage: # <<<<<<<<<<<<<< + * if not self._buffer and not self._eof: + * assert not self._waiter +*/ + __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_WSMessage) < (0)) __PYX_ERR(0, 141, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_13read, __Pyx_CYFUNCTION_CCLASS | __Pyx_CYFUNCTION_COROUTINE, __pyx_mstate_global->__pyx_n_u_WebSocketDataQueue_read, NULL, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, __pyx_mstate_global->__pyx_n_u_read, __pyx_t_4) < (0)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_16__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_WebSocketDataQueue___reduce_cyth, NULL, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < (0)) __PYX_ERR(2, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":17 + * else: + * return __pyx_unpickle_WebSocketDataQueue, (type(self), 0x7cbbcf5, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_WebSocketDataQueue__set_state(self, __pyx_state) +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7aiohttp_10_websocket_8reader_c_18WebSocketDataQueue_18__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_WebSocketDataQueue___setstate_cy, NULL, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketDataQueue, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < (0)) __PYX_ERR(2, 17, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "aiohttp/_websocket/reader_py.py":227 + * self._compress = compress + * + * def feed_eof(self) -> None: # <<<<<<<<<<<<<< + * self.queue.feed_eof() + * +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < (0)) __PYX_ERR(0, 227, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7aiohttp_10_websocket_8reader_c_15WebSocketReader_3feed_eof, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_WebSocketReader_feed_eof, NULL, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader, __pyx_mstate_global->__pyx_n_u_feed_eof, __pyx_t_2) < (0)) __PYX_ERR(0, 227, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":233 + * # and asyncio types this to Union[bytes, bytearray, memoryview] so we need + * # coerce data to bytes if it is not + * def feed_data(self, data: bytes | bytearray | memoryview) -> tuple[bool, bytes]: # <<<<<<<<<<<<<< + * if type(data) is not bytes: + * data = bytes(data) +*/ + __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_data, __pyx_mstate_global->__pyx_kp_u_bytes_bytearray_memoryview) < (0)) __PYX_ERR(0, 233, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7aiohttp_10_websocket_8reader_c_15WebSocketReader_5feed_data, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_WebSocketReader_feed_data, NULL, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader, __pyx_mstate_global->__pyx_n_u_feed_data, __pyx_t_4) < (0)) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "aiohttp/_websocket/reader_py.py":249 + * return EMPTY_FRAME + * + * def _handle_frame( # <<<<<<<<<<<<<< + * self, + * fin: bool, +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_fin, __pyx_mstate_global->__pyx_n_u_bool) < (0)) __PYX_ERR(0, 249, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_opcode, __pyx_mstate_global->__pyx_kp_u_int_cython_int) < (0)) __PYX_ERR(0, 249, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_payload, __pyx_mstate_global->__pyx_kp_u_bytes_bytearray) < (0)) __PYX_ERR(0, 249, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_compressed, __pyx_mstate_global->__pyx_kp_u_int_cython_int) < (0)) __PYX_ERR(0, 249, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7aiohttp_10_websocket_8reader_c_15WebSocketReader_7_handle_frame, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_WebSocketReader__handle_frame, NULL, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[10])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader, __pyx_mstate_global->__pyx_n_u_handle_frame, __pyx_t_2) < (0)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "aiohttp/_websocket/reader_py.py":396 + * ) + * + * def _feed_data(self, data: bytes) -> None: # <<<<<<<<<<<<<< + * """Return the next frame from the socket.""" + * self.queue._stalled_reader = None +*/ + __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_data, __pyx_mstate_global->__pyx_n_u_bytes) < (0)) __PYX_ERR(0, 396, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7aiohttp_10_websocket_8reader_c_15WebSocketReader_9_feed_data, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_WebSocketReader__feed_data, NULL, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[11])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader, __pyx_mstate_global->__pyx_n_u_feed_data_2, __pyx_t_4) < (0)) __PYX_ERR(0, 396, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7aiohttp_10_websocket_8reader_c_15WebSocketReader_11__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_WebSocketReader___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[12])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < (0)) __PYX_ERR(2, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":17 + * else: + * return __pyx_unpickle_WebSocketReader, (type(self), 0xd550ae4, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_WebSocketReader__set_state(self, __pyx_state) +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7aiohttp_10_websocket_8reader_c_15WebSocketReader_13__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_WebSocketReader___setstate_cytho, NULL, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[13])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_7aiohttp_10_websocket_8reader_c_WebSocketReader, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < (0)) __PYX_ERR(2, 17, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_WebSocketDataQueue(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x7cbbcf5, 0xf3050d7, 0x7050118, b'_buffer, _eof, _exception, _get_buffer, _limit, _loop, _protocol, _put_buffer, _size, _stalled_reader, _waiter') +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7aiohttp_10_websocket_8reader_c_1__pyx_unpickle_WebSocketDataQueue, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_WebSocketDataQueu, NULL, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[14])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_WebSocketDataQueu, __pyx_t_4) < (0)) __PYX_ERR(2, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":1 + * cdef extern from *: # <<<<<<<<<<<<<< + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7aiohttp_10_websocket_8reader_c_3__pyx_unpickle_WebSocketReader, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_WebSocketReader, NULL, __pyx_mstate_global->__pyx_n_u_aiohttp__websocket_reader_c, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[15])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_WebSocketReader, __pyx_t_4) < (0)) __PYX_ERR(2, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "aiohttp/_websocket/reader_py.py":1 + * """Reader for WebSocket protocol versions 13 and 8.""" # <<<<<<<<<<<<<< + * + * import asyncio +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_4) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + if (__pyx_m) { + if (__pyx_mstate->__pyx_d && stringtab_initialized) { + __Pyx_AddTraceback("init aiohttp._websocket.reader_c", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + #if !CYTHON_USE_MODULE_STATE + Py_CLEAR(__pyx_m); + #else + Py_DECREF(__pyx_m); + if (pystate_addmodule_run) { + PyObject *tp, *value, *tb; + __Pyx_PyErr_FetchException(&tp, &value, &tb); + __Pyx_State_RemoveModule(&__pyx_moduledef); + __Pyx_PyErr_RestoreException(tp, value, tb); + } + #endif + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init aiohttp._websocket.reader_c"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #else + return __pyx_m; + #endif +} +/* #### Code section: pystring_table ### */ +/* #### Code section: cached_builtins ### */ + +static int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate) { + CYTHON_UNUSED_VAR(__pyx_mstate); + + /* Cached unbound methods */ + __pyx_mstate->__pyx_umethod_PyDict_Type_items.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_items.method_name = &__pyx_mstate->__pyx_n_u_items; + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.method_name = &__pyx_mstate->__pyx_n_u_pop; + __pyx_mstate->__pyx_umethod_PyDict_Type_values.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_values.method_name = &__pyx_mstate->__pyx_n_u_values; + return 0; +} +/* #### Code section: cached_constants ### */ + +static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "aiohttp/_websocket/reader_py.py":297 + * if compressed: + * if not self._decompressobj: + * self._decompressobj = ZLibDecompressor(suppress_deflate_header=True) # <<<<<<<<<<<<<< + * # XXX: It's possible that the zlib backend (isal is known to + * # do this, maybe others too?) will return max_length bytes, +*/ + { + PyObject* __pyx_temp[1] = {__pyx_mstate_global->__pyx_n_u_suppress_deflate_header}; + __pyx_mstate_global->__pyx_tuple[0] = __Pyx_PyTuple_FromArray(__pyx_temp, 1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]); + } + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]); + + /* "aiohttp/_websocket/reader_py.py":356 + * payload_len = len(payload) + * if payload_len >= 2: + * close_code = UNPACK_CLOSE_CODE(payload[:2])[0] # <<<<<<<<<<<<<< + * # https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.2 + * if close_code > 4999 or ( +*/ + __pyx_mstate_global->__pyx_slice[0] = PySlice_New(Py_None, __pyx_mstate_global->__pyx_int_2, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_slice[0])) __PYX_ERR(0, 356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + + /* "aiohttp/_websocket/reader_py.py":366 + * ) + * try: + * close_message = payload[2:].decode("utf-8") # <<<<<<<<<<<<<< + * except UnicodeDecodeError as exc: + * raise WebSocketError( +*/ + __pyx_mstate_global->__pyx_slice[1] = PySlice_New(__pyx_mstate_global->__pyx_int_2, Py_None, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_slice[1])) __PYX_ERR(0, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_slice[1]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[1]); + + /* "aiohttp/_websocket/reader_py.py":371 + * WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message" + * ) from exc + * msg = WSMessageClose( # <<<<<<<<<<<<<< + * data=close_code, size=payload_len, extra=close_message + * ) +*/ + { + PyObject* __pyx_temp[3] = {__pyx_mstate_global->__pyx_n_u_data, __pyx_mstate_global->__pyx_n_u_size, __pyx_mstate_global->__pyx_n_u_extra}; + __pyx_mstate_global->__pyx_tuple[1] = __Pyx_PyTuple_FromArray(__pyx_temp, 3); if (unlikely(!__pyx_mstate_global->__pyx_tuple[1])) __PYX_ERR(0, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[1]); + } + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[1]); + + /* "aiohttp/_websocket/reader_py.py":60 + * OP_CODE_PONG = WSMsgType.PONG.value + * + * EMPTY_FRAME_ERROR = (True, b"") # <<<<<<<<<<<<<< + * EMPTY_FRAME = (False, b"") + * +*/ + { + PyObject* __pyx_temp[2] = {Py_True, __pyx_mstate_global->__pyx_kp_b__3}; + __pyx_mstate_global->__pyx_tuple[2] = __Pyx_PyTuple_FromArray(__pyx_temp, 2); if (unlikely(!__pyx_mstate_global->__pyx_tuple[2])) __PYX_ERR(0, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[2]); + } + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[2]); + + /* "aiohttp/_websocket/reader_py.py":61 + * + * EMPTY_FRAME_ERROR = (True, b"") + * EMPTY_FRAME = (False, b"") # <<<<<<<<<<<<<< + * + * COMPRESSED_NOT_SET = -1 +*/ + { + PyObject* __pyx_temp[2] = {Py_False, __pyx_mstate_global->__pyx_kp_b__3}; + __pyx_mstate_global->__pyx_tuple[3] = __Pyx_PyTuple_FromArray(__pyx_temp, 2); if (unlikely(!__pyx_mstate_global->__pyx_tuple[3])) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[3]); + } + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[3]); + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = __pyx_mstate->__pyx_tuple; + for (Py_ssize_t i=0; i<4; ++i) { + #if PY_VERSION_HEX >= 0x030F0000 + PyUnstable_SetImmortal(table[i]); + #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; + #if PY_VERSION_HEX < 0x030E0000 + if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) + #else + if (PyUnstable_Object_IsUniquelyReferenced(table[i])) + #endif + { + Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); + } + #else + if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = __pyx_mstate->__pyx_slice; + for (Py_ssize_t i=0; i<2; ++i) { + #if PY_VERSION_HEX >= 0x030F0000 + PyUnstable_SetImmortal(table[i]); + #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; + #if PY_VERSION_HEX < 0x030E0000 + if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) + #else + if (PyUnstable_Object_IsUniquelyReferenced(table[i])) + #endif + { + Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); + } + #else + if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ + +static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) { + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + CYTHON_UNUSED_VAR(__pyx_mstate); + { + const struct { const unsigned int length: 8; } str_length_index[] = {{0},{1},{15},{11},{15},{1},{1},{47},{42},{53},{40},{26},{20},{21},{13},{179},{33},{42},{56},{18},{105},{8},{26},{25},{21},{25},{15},{11},{15},{31},{22},{17},{30},{7},{6},{2},{16},{9},{35},{42},{5},{16},{6},{12},{5},{12},{14},{9},{5},{12},{15},{4},{4},{4},{14},{24},{4},{12},{19},{4},{17},{11},{11},{9},{15},{14},{13},{13},{13},{18},{9},{19},{18},{36},{38},{28},{28},{27},{25},{23},{32},{14},{15},{33},{35},{26},{29},{25},{24},{16},{13},{20},{12},{9},{8},{8},{12},{8},{10},{8},{7},{12},{14},{12},{11},{10},{33},{30},{14},{12},{10},{17},{13},{12},{12},{19},{8},{5},{10},{13},{13},{15},{27},{6},{7},{18},{13},{4},{8},{5},{5},{18},{5},{11},{8},{10},{17},{13},{10},{4},{6},{11},{15},{5},{4},{3},{9},{9},{5},{9},{8},{3},{7},{6},{5},{4},{5},{3},{4},{12},{7},{6},{4},{6},{13},{7},{3},{7},{8},{5},{4},{3},{14},{6},{4},{4},{13},{10},{10},{4},{5},{7},{23},{3},{5},{6},{12},{5},{6},{6},{7},{7},{14},{9}}; + const struct { const unsigned int length: 11; } bytes_length_index[] = {{0},{586},{77},{11},{11},{57},{58},{371},{526},{820},{60},{12},{14},{27},{12},{92},{74},{1312},{5}}; + #ifndef CYTHON_COMPRESS_STRINGS + #define CYTHON_COMPRESS_STRINGS 90 + #endif + #if (CYTHON_COMPRESS_STRINGS) == 1 /* compression: zlib (3724 bytes) */ +static const char cstring[] = "x\332\215\027\313_\323\350\266/\034T\274R\250\003\010j\252\370\000\005\007\301Qg\356\314\334\322\006(\226\276\021Q\257\271i\373\225\006\332\244MR\n\3528\263d\231e\226Yf\231e\227]\262\314\262\313\376\t\376\t\367\234\244)\024\324\337\364\0479\337\343|\347\375\222\242\310A\236\220\202D\225\271\n\047S\367\2672\033D\222\330\035r\377\201,\022B\025Ev\247Bxyf\376\217\260P\251\212pI\nT\305\306\241J\254D\311\202@UX\376\220*\220b\231\225\t\\VrD\224\302\002/s|\235\2259\201G2\025 &\210\024\017;IfE\371\204\014b\212B\271\213Te\017\313\002[\240\362,\317\0132\225#T\231\025w\210H\311%\226\247\026\236<\245r\2072\221\"$\177^\036G\031\211\373@\272\032E\371}\266\314\025\250\315\354\312\334sJ&\007\262\203\355\334\344\313\202D\250\274P \277P\375g\226@\277P]\213\330T\343\002\250\010\242\310T\370P.\2012\234\004\232\2279P\031\224/\037\202r\"\227\227\035y\223trn\351\371\022\305\362\005J$\273$/\203t\365\\\276\314\202\340\022%\024\251\\\235+\203\241(\371\260J\244y*Z\244\016\205:\305\203\036`Z\260\206\324\367@.\021\260\037\221qA\335\267LdY\230\201\347\034\277s\237*p\"0\341\366\t\276^a\313\022\231O\223<\201\203B\317\231\260\314\237\266\371i\004\360@\203\223K\350\247\271\017D\024@j\211\210x\231\343d)\013\\\205*\332\212\002\221\021\247\3109\336\005C\220\203*0\267%\007\307\341\373G\324\016xq\223\357]\331\317\177\333\"\271\214\220\337#r\232\260\005\260V\003Bi\207\025sh\350\274P.\333\310\215\022W&\030/pP\370\025b\002\240h\231\rl\300TY\021d{0CU\352\222L\225\204r\201b\321\376\002\277\003b\027\211H\370

\341\367X\264\214\300T\017\347\253\207\335\200\220\346\227\201-\r\021]E\007[AO}\262\202\237\025E\366\360\334\001\254!\365\004\361p\237#\215\002\047\261\2712!<~w\362\034/\303u\336\212X\0066\234d\337\0240\352\336\3661\372/ \366\035\374\003\024\330\307\005\236\324\345\342\334\363\320r<\221\336\010\305\230p,\221\331L\323\313""\321x(\275\215\350\311\256\005\361\202\016\047\342\331h|3\224\215&\342a\026\374\204\036\246EQ\020i\241\230\261\014eEo4\376*\024\213F\230,\375:\273Ag2\241U\232\311&\022\314rt\025Y&\243\361\325d\002\376\322\211l\"\234\2101t:\235Hg\262\241X\214\2160i:\024\241\323\014\234\307\350p\226\216 \221,W!B]\266Xe\005a\003J\327\206]\261\354#\261N6\343\311P\370\245\245\000\r\217#t\367 F\307\027\2672a\254\ra\010\220^\255\354-\2269\236\025\017{[\013\263\267KB~\236l\204S\233,T\245\276\3152\372\026N\244\235,\030\177+\303D\350\225X(\013\232\247C\321\030\250\334\313\236\010+\263\251:\251\223\363\047\363\014#\222B=O\230\256\337\231\257\342@\"A~\311\337\305\"\216\243\277rW\204J\305\024`\373\255;\"\024\277r\305I\337\270\300T\370\3121\346\373y1,\227\235)%g\266\3371C\017\341\3336pP\316k\351\334@\225/\224\tc\325\300\263\227\337|\345\030\346M\214\313\235t2Ad\350\327a&Ccj\3201\206I\036\036\300_\004\372\t\023\207\260H\223\"\303tk>a\340\3076XN\306E\001Q\340W\254\363y\204;\216B\360\253\260\034oA\241P/[\047<\210jA\322@P\005.y\266\312\365\326%\222\337\223\352\025{\007\202\325\313\262\275\356\322\304%V\005{U\347\253\\~\017(\237\367\332\267\020l+\330\267\3732\026\"\344]\253\263eG\264\256\313\230s\316\353\035\220\003\334`X8o\244SJ\237\363(\303@J\311\216\251z\216\351s\037\003A\231\027D\250\016\034O\030\014DHY\3502u\2301\276\322$\272E\033LW%|\201\225\016\371<\047t\301|\217\216\324\327=r\002\374u\013\274U\301\363e\250\336\37122\0047\311\"\233\04796\277g\r \335>\010\001/9!r2\364\234\353?y\220\007\024.\326\345:\214\000\275R\217Z\026\010\366\\\373\313\340\014T\350\305\034\203\362\026H\255N\nPN1\303\016\362\240\022\250\334\3136\300\027\331\236\305\234\320\205\306\337\355tv*s2\251H\273\002\307[s\027t\275\262 T+\354\001S\221v\030\034\235`m\001\253\265\"Q{\022\260\314\353\030\273;\374U\205*\374+\223\242\354\330\255\206\341\204H\320\3271\"+\275\047\"\001}y\211\224\213\320\323\n}e\0027v\370\302\n\306S\026W \202\025\031\335f,\325\253\266\035\272\343+S\262\274*\035JrI\024\032\365*\350LPB\047\242`@\254\333\037\t\263""\217\210\rV\344A\216\006a\367@\270^x@\336I{\r\211\001K\300\364\232\211\264\342f:\323\366]>Z\370\372Cs\364\256\366\032\230\260\247^.\031!\363\351\372\361\274\371z\273\373\362\313\240\353\322$^\371\225\200\362F\225\265g\372\264^i.5?\037g\315\324\033\363\315{\363}\321,\356\232\273\373\346\376\207/.\327Gw\324\003 \352\331@\260\341\331D\260\351\331F\260\355\331C\260\347\021\020\010\236\252\247=8\254\374\240\324\324\013jY\017\242 \373G[\n\255\006\324T{pD\001\266cJ\255\003\037Y}\241\255\352O\r\257\261d|j=;\276{,\231\351W\346\253\274\231\007\326\202)\210\246\010\002\374\td?\273i\244N{\326\021\254;r\244\020\244<\357\020\274\363\344\021\344=%\004\2453R}B\360\311\023\366\002\010{\327\020\254y_\"x\351M Hx\377\207\340\177\336\035\004;\3362\202\262W@ x%\004\222\367\023\202O\336\260\017\251\370\">T\256\326\036\274j^]\004\035j\315\037\232\037\217\357\203\047:\375G\3013&\177\247\005\264\367p\373W\253`\256\2775\3372&c\233\273a6>\"\007wW\3158\202\270\347=\202\367\236\034\202\234\247\201\240\341\371\210\340\243g\025EZuTy\207\340\235\243J\025A\325+#\220\275\237\021|\366.\243""\360\313\276\r\004\033\276\024\202\224o\027\301\256\217G\300\373\302\003\250\337\300*\202\325\201\267\010\336\0160\010\230\201\022\202\322@\031Ay@F \017\034 8\030\240/\240\217.D\021D/\254_\370\307\201`N>\324\237\031w\r\2519\335,\266V\217\237\232\311\214\231\3312\267\nfa\317\334\253\232U\311\224\032\310\303\275\214j/{\272\361\3305P7\016\272a\311!\340 \020Q{O\035A\335s\200\340\340L\034\254#Xw\002 \215 \355}\205\340\2257\207 \347\345\020p^\036\001\357\255!\250y\353\010\352\337\t\207\237\014\237\0212\266\232/[\215c\266\323\177R\373;\324\271\362\257\366\260\277\355\037i\007\256}\271\340\2728t\364L\231Vxs\032r\2653t\365\250\241\344\315\211y\275`L\033\\Sj\005\333\303?*\274\026j\007 \343\361\311\240\353\312\360\221\254,t\206G!\307\357\200=\003\343\352em\241=\034P64?\320\356\014]W\247U\026r{\241m\023T\341x\302\262= \275Tk\300wd\364\014\341\366\275\373Z\315\246^k\017Ok\021\375\222q\333\010\341\213\250\372J\003~\323Z\250w?\252,A\016/\000os|\326\234\375\245\0314\177\005\267e\277\014\271P\263\273ZV\277e>_;v\267\307g\365\333z\2503EiWu\321\360\267o\335\001\261\202w\265\024\010\341\0377\307\346\241`\005\256\253\363:\240\342\325\370D{r\312f\360\227V\320\357\350)s\376\367f\256\345k\205\372\361\226[\301\326R\253\326\361_SR\346\2173\372\250\016\302\0065\177\007>\3274V\253u\206F\225E\205Uj\247\254\200d-m\307o\251\237\365-p\013\330o\322\234\204\022\333\036\277\251\362@c\352\276\366\227\301\266oQ\240\313\265IuF[@\337\2544\357\241\010 \264}\326\036\2373\347~k\276B\021P\2231\205C3\3363\357\375l\024\233\221\226\033\016\257\370\225\013\312\256\346\006\257\\\t(a\024\344:zLeQ\242O\352\",\206o\2307\300\004z\303\3105\275\315\205f\010\375\372\253\232\323\006\264\024\272F\004]\n\372C\210\236P\247O}|T\353@$\005\246\241\222.\350a \301\032\340\2321s\014z\315)[\375a\004-\223v\335=\241Ni\233\372\234\261\337Lu\300W}Q\360\020\010\321\206\337x\320\0146\027l\265\340\022\320\357\350\233\306\\s\277\225\352\014\r\237S\252{\002\272\200nD{\252\273\365\353\306SK\235\365V\361\030B\376\037\"\242\315F\225y\304\000""\237<2\037\375\247\345n\371\355\234\031}\004\276\271x\251=8t\264\246\204\020\304\261\246\016\035\255\202\223\013\352,\032\0019\\\206\250\034\232P\375\352\003\355\256V3}\343\252\033\322\0223\306\364]\267_\254(3\352\311\316\246f\016M\251\016U\3237\tD\234G7\301K\203\227\217\226\216j \375\016\344\020\204\325S\325\255\372;\326\351\276\262\005\017\341\354g<\271\330\025\001i]=\372\023o\206\225A\020\301\022iZ-i,\342.@]8\252Y\264\261\006X\t\215\314\327\025\242>\301\0229t\024C\026\047\202!\253\206\222S}\352\032\244\246O\217\030\227\232A$~\t\335l\342<\320A\325\314\021H\255\256\274\355\241\021(-\234\325\344o\353+F\2603\030@e\235\264\300\235%\362\325\243\017\352\010td$\274b\334o\216\300<\000\276\376r\311\005\311\265b^\237\323\263\006V\026\364\017\312\372\334\016\335Q\345\205\272\254\356\352\036\250\360\220R\340\325m\314\273\366\360M\225\323jN\375\000_w\206\307\224\217\332\035-c\241\016c\275Z\324\362\372\010x\354;\233\tuR[\326\330/\343.\177\000,\356U\237j>\215\326\003 L\300H\235)\032\030\254\001k\350\001I\372\377\365\347\r\204\221\236r\260o\253\021\240\031\321\275\300\357<\275\033j\014n\026\365\234\341Fi\246\264\264U!O\275\\\325\237\350\347$\031v0 \253\240\313\235\252+\265\366\324\r\254*\343P;\377\255I\326\344\265\330d\333\343Sj\302|\370{s\027\352\345\304\3653\017:P\337\377\0055\000f\302\316p\300\014\240\177\255Z\037\320R\020Mx4\243\373\361h\335\212\246\323\036\232T\227\324\232\355\2500\346\367\230r\250y\264Y}\031\212.\024\332@P\233\260f\315\300mm\006R\177\035\212\220\033O\375Va\177b\324\1771\322\206\225C\0261\253\0378\204P\331\ts\034\007\246\240\361\002\354\375\356\330o53,\021\360\001\037k>s\372\205\225\3005<\301 ]\321ga\264\200\315\n\370-\336\014\332&\004\343\332\206?Cm\314\352\353\320\036e\3557\343\007\220\0042&j\244\214|\363Z\223m\312-\270\273\007Y.\353\2777\241e\336\326\202\035\370\334\201\026\021\324\227\364Z\333\246\3703\224\213kP\361\240\267B\004\376\251\257\032\020c\017\364\213\320Z\036A\274\333L\314\251\307\330\263 \243&\346,\026,\306aP[\322>cz\203\001:\001\273\222\014\201\374`\352\270\026\304a\347\212\2265g^4\047Z\323-\326\312\210Y,*N\370_\274r\024U\266a\374\371\240\3370v!z\347\315d\312\274\004\026\372?g\3114\301"; + PyObject *data = __Pyx_DecompressString(cstring, 3724, 1); + #define __Pyx_DecompressString_LZSS_UNUSED + if (unlikely(!data)) __PYX_ERR(0, 1, __pyx_L1_error) + const char* const bytes = __Pyx_PyBytes_AsString(data); + #if !CYTHON_ASSUME_SAFE_MACROS + if (likely(bytes)); else { Py_DECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) } + #endif + #elif (CYTHON_COMPRESS_STRINGS) > 0 && (CYTHON_COMPRESS_STRINGS) <= 90 /* compression: lzss (4832 bytes) */ +static const char cstring[] = "\377 exceed\377s limit \377\047WSMessa\377ge\047(tree\377 fragmen\377t).?Comp\275r\032\000ed m\036\003 \377has too \377many def\357late\032\000mbe\377rsContin\277uationC\001m\336J\000or n\013\000st\347art=\007&\001rol\376\036\004payload\377 cannot \377be large\377r than 1\37725 bytes\347Dec~\017\305\005siz\375e\313\004Invali\377d UTF-8 \317text\266\005\022\005cl\377ose code\223: \006\013\372\000m\022\000\213$ \346Q\002No\340\000\210\000t C\267yth\330\000is\367\000l\371i\360\000\372\000ly st\357rict\250\005PEP\377-484 and\377 rejects\377 subclas\377ses of b\367uil\246 typ\377es. If y\317ou n\222@\330 p\374%\000%\tthen s;et\213 e \047\236\"\335\"\375_<\000ing\047 d\273irb\000ive:\001F\377alse.Rec%e\016\000d\304F\277@c\233@\353&\274\025\t\244@with\244A-\357zero\263\000ser\375v\362@bitsTh\357e op\250! in\346\037\002fi\326E\206 exp\314\337\000\236`to\265A<\001, \315g\303@Un\022\0069\003=W\377ebSocket\257Read\333@w\310`ggarb\370`\211@llB\003_while\320 a\016\000\223d;\221`\026\000r\262\"\201 _\367par\231\000() m\377ust hold\273 a\374!ong\352 f\337erenc[\000d_\376\306`eaiohtt\177p._websu\002\377.helpers\352\007\020m\213`l\020\006bas\377e_protoc\363ol@\005\367eion_\347uti$\007G\014log\\s\005\230`eamh\005/\200\007\373/r\200\"_py.p\335y\212ds.Bt\000Exgcep\277\205\001\360\204\002 |\370\204\002\237array\000\016\032\000m\377emoryvie\377wdisable\373en\002\001gcintj9\000c\255\204\002_\n\000is\024\003\025d\362a[\\\n]b\000m\n\000 \376\225\000Noneutf\377-8ABNORM\377AL_CLOSU\377REBINARY\362\310\001P\273$\025\001ECON\377TINUATIO\347NCa\245@\336AErr\177orEofSt\216 \375m\271\204\002INVALI\377D_TEXTME\377SSAGE_TO\337O_BIGo\001PI\357NGPO\001\000ROT\377OCOL_ERR\377ORSTALLE\377D_READER\375_\025\000LECTED\376A\001Timeout\376f\002TooMany\363Me\255\210\002\r\003rueU_NPACK\274\002E:\000\373DE\n\004LEN3W{SC\254\207\001Code\243\211\006~\254\211\006Binary\273\211\006\274%\002\311\211\006Ping\003\007o\236\002\010Text\360\211\006\t\001B\376\336\210\001WSMsgTy\375pe\000_DEFLA=T\367\000RAIL\360\000""\265\205\006\377DataQueu\375e\000\017.__red\257uce_\361D_\017\022s\277etstat\t\032e\374\376eS\020feed_d\334\204\000\004\025eof\212\020is\001_\003\023\207\205\001\272\020\354\206\001u\017\254b\274\207\014\000\313\207\014\354\030\365\207\003\245 \352\027\033\005\324\0175\005\177handle_\247\213\002\360k\r\035\026\260\"\226 ZLib\376\300\214\007or_EXC_\373SE\227\205\001EL__P\373yx\001\000Dict_\377NextRef_\335_\355\212\004e__\t\000wa\313it\005\001d\037\001\017\000fu\313nc\025\001g\315E#\000ma\373in)\001moduln2\002nam\002\003ewB\001\275pc\000capi\003\006h\377ecksum__~\026\001result\006\003\360\243c\022\002\253\214\001\033\003unpi\203ck\200 \203\204\017\t\025\356\212\003Z\003vyt\245\210\001\312\001qual\223\0052\263\204\004_\263\204\016\314\204\006ex\376\001\203\213\001\362\307\005s\352\010\305\204\016__te\321s\250!\246\"\254\204\006_\263I_i\377s_corout\357ine_\220\212\001ing\177_paused\254\213\020\374\256\212\004\270 pendas_yncio\000\004.?\006=s\261\213\nbool\331\212\005\303\220\002\177clearclm\001\376\244@traceba\333ck\220\220\002co\203\215\002io\343ns\345\220\005\353\220\007\357\213\016cre~\303\206\001future\341\212\007\306\227\206\001de\333\220\001\000\003\205 xt\365d\265\221\006_\263\001dequ\337edone\212\223\001xc3_c\357\001\354\206\006ex\224\000\336\206\006\316\263\204\005fin\271\215\004\305\206\003it\177emsjoin\305\223\002\377logloopm\177ax_msg_\215\222\001x\t\000\002\002\326\215\002next\303\217\003\270\332\"\345%\366\222\004pop\000\000lgeft\356\215\005\235\000ue\242\215\001\327ref\216\204\001m\227Fre~\355\000nselfs\203@\330\232\207\n\240\217\001\271\204\003se\360\000fa\307ult\227\223\001\353\210\002\206\216\004su\265p\321\224\002_\270\224\004_h\213\220\002s\377ysthrowu_pdate\376@_\240\211\005_value\000\002s\372\205\001\377erwarnin\237gweak\232\000\325\217\006_\377maskws_l\377oggerPyO}b\372\222\001 *\000\000\000\000\000\334\000\003\010\001int\t\007un\377signed P\277Y_LONG\000\002\000\374\r\006$\005ALLOWE\375D\227\214\010S\000EMPT\177Y_FRAME\000\t\372\213\215\003\000""\262\215\006YPES_\337WITH_\376\215\001EN\377T\000TUPLE_\257NEW\000\347\214\016\000\356\214\010\000\252\327\214\014\000\331\214\013\000\333\214\n\000\334\214\n\000\312\320\214\n\000\331\214\017\000\343\214\006c\000_M/SG_T\245\000_\265\217\003\006\n\376\203\217\001\000COMPRE\377SSED_FAL\373SE\005\tNOT_S\373ET\030\tTRUE\000\003OP\305\216\002L\005\007\005\207\220\002\024\006\211\220\t\000)\006J\005:\005\357\217\001F\006\370\217\001S\006\230\002\377MAX_PAYL\377OAD_LEN\000\376\312\001SIZE_OV\177ERHEAD\000\222\220\001\r_\006\001ER\006\003(\004\000\n8\001\367GTH\006\013MASK\277void (\306g,\361 \000\t\345\222\001\245\212\004kip_\377dispatch\347)\000_\213\204\013\215\217\004\200\001\330\377\004-\250Q\250f\260A\376\007\0010\260\001\260\026\260q\377\200\001\340\004\037\230q\320\377 0\260\013\270;\300k\377\320QR\330\004\023\220?\377\240(\250!\2501\330\004\377\007\200|\2207\230!\330\377\0101\260\021\3202D\300\377N\320RS\330\004\013\210}1#\023\320\023%\240Xb\000\375a/\0104\260A\3205J\337\310.\320XY3\004\360\010\367\000\n\033Q\001\021\220\024\220\377Z\230t\2407\250$\250\377m\2704\270~\310T\320\377QZ\320Z^\320^f\377\320fj\320jv\320v\377z\360\000\000{\001I\002\356\004\000I\002M\003\001M\002U\356\n\001U\002Y\021\001Y\002k\356\030\001k\002o\037\001o\002p\377\002\330\010\020\220\007\220q\277\230\006\230l\250!\277\001v\377\210W\220E\230\024\230Q\357\330\010\022\220\311\000\027\220q\377\340\010\027\220t\2309\240\377G\2505\260\003\2604\260\377|\3007\310%\310s\320\177RV\320Vc\320cx\000\277o\320or\320r~\000}\356~\000~\001E}\001E\002J\352\204\001J\200\005Q\222\001Q\002\\\356\231\001\\\002c\240\001c\002h\352\247\001h\207\014|\274\001|\002C\335\003\313\000C\003H\003\001H\003\335K\n\001K\003O\021\001O\003\335`\030\001`\003g\037\001g\003\335l&\001l\003o-\001o\003\335s4\001s\003|;\001|\003\273C\004B\001\004D\004\234Aq\277\330\010\017\320\0173\301\000q\277\270\007\270{\310\047\300@\340\356\005\013!\200\001\346*\\\240\024\373\240^\362\000\177\300d\320J\277[\320[_\320_\351#w\267\320w{\354 |\001\340""\004N\356\362!N\002^\371!^\002b\356\200Ab\002w\207Aw\002{\256\216A{\002G\316\001G\303\005\\\352\334\001\\\303\005p\352\001p\003t\356\361\001t\003~\370\001~\003B\356\271\001B\004M\300\001M\004Q\356\307\001Q\004j\316\001j\004n\336\325\001n\004C\005\242!\005G\356\003\001G\005[\n\001[\005_\356\021\001_\005h\030\001h\005l\356\037\001l\005t&\001t\005x\336-\001x\005E\006\251`E\006\275I\003\001I\006J\006\340\202&\320\377\033+\2507\260%\260s\377\270$\270f\300G\3105\377\320PS\320SW\320W\377d\320dk\320kp\320\377ps\320sw\360\000\0007x\001B\205\204\001B\002\211\204\004\232$t\201d\220\204\004i\250\204\001i\002p\257\204\001wp\002u\266\204\001u\002x\275\204\001\253x\002\372KJ\213aJ\371ER\356\231aR\003V\240aV\003b\356\247ab\003i\256ai\003n\356\265an\003q\274aq\003u\372\303au\364X0\260\004\260A\377\260W\270K\300w\310a\374\211b\010\007q\200A\340\r\016\377\330\020\021\330\021\022\330\024\377\025\360\006\000\t\014\2107\377\220$\220n\320$4\260\377A\340\014\017\210w\220c\377\320\031.\250d\260$\260\377i\270s\300!\330\020\026\377\220n\240A\330\024\037\230\375q/\001\010\000\r\020\210t\377\2201\340\020\023\2207\230\377#\230Q\330\024\030\230\013\377\2401\330\020\024\220M\240\375\021Y\000\340\014\032\230$\230\247a\230t\022\000K\003\230\024\000\031\334\200\206\002\"\000K\230qu\000\022\023~J\014\330&\047\240q\360Y\002\377q\330\020$\240D\250\n\357\260\"\260AS\001I\230V\335\240m\000$\240A\027\006\023\220\3374\220t\2301y\000\320\030\377*\320*:\270!\320;\336\264@T\360\014\000\326\001%\240\377T\250\037\3208H\310\001\377\330\030*\250\"\250A\340\377\034 \240\017\250r\260\021\367\330\037#\251\000!%\240Q\376\372\000\021\030\320\027.\250a?\330\024\032\230.\250(\000\027\001\277\030\031\330\033\034\330\332\0004\377\220\177\240d\250#\250Q\377\320.>\270b\300\004\300\375A\032\013B\300!\3004\300\377q\340\021\025\220Q\320\026\357)\250\023\250\252\000!\240\021\377\340\020!\240\025\240a\240\377q\340\014\023\2203\220a\307\220q\330\374\007\264\001\303!\330\030\237\037\230~\250W\246@\275 \033\367\320\0331\227\000\030""\036\230n\376A\000\034\047\240\177\260a\330\373\037 \311\000\025\033\230)\240\0351\230AF\270&\177\001\257@\016\003\377\330\030-\320-=\270V\334\177\001\306\001\027\220i\234A&\320\377&6\260f\270D\300\001\376\331@\r\021\220\006\220j\240\275\001\223@\r\024\220C\205\001\032v\256A\230a\216\001|\2303\006\000\357\020\035\320\035\200 \250w\260\177b\270\003\2701\270A\324A\277;\230b\240\005\240\327@\037\273\230r\311\000d\250+\315`A\331\340\232*1\001q\340\307`\024$\277\240G\2501\250C@\000a\375\260\270@\027\320\027-\250Q\316\311(?\260!\316\"\301d\031\230\377\034\240U\250-\260v\270\257Q\340\021\022\321k+F\000E\377\260\021\260(\270!\2701\370\321\003\371`,\000#\250U\260-\177\270v\300Q\340\014\020\304\016\376\013\004\330\020\035\230Q\230e\377\2405\250\001\250\032\2605~\312\002J\300f\310A\340\366\005\374\t\035\260!\023\220.\240\001\330\375\020\221@,\320,@\300\001\333\300\021\256\205\003\023,\335@\t\n\177\330\010\014\210H\220A\003\001\335N\230\215\001\014\210G\342@d\230\365*\201!\330\232\000\013\2301\330\377\014\031\230\021\230(\240%\377\240q\320\004\030\230\001\330\273\010\017\256\205\001\320\004\032,\003F\317\220)\2301\005\006H\003\320\014\373\034\230N\005\320\004\033\2301\372,\006\036\254@\010\013\2104\210\275q\313@g\230Q\330\324`5\337\230\001\230\021\340\021\002v\220)W6\000\350`6\016\001\t|\004H\001w\017\210}\026\001\020\220\010\200\000\336\216\002$\230h\240\371@\023\220\0031\340\220\000\232\000Y\000\200\207\001\314\206\002\326\001\337J\220e\2302\250\215\001\014\210\341L_\001\353\000\222\004}\001w\220b\377\230\004\230H\240D\250\004\277\250D\260\n\270!\354\001\n\352\267\205\001\320\305\217\001\340\230 F\320\022\371%\266`\252\003\330\014\022\220$\373\220i\340\216\002\"\250F\260!\307\340\010\024\267!\217\205\005\n\001\340\010\376\260\000\017\210z\230\022\2309\376T\002F\260\047\270\022\2704\376\350A\360\n\000\021\025\220F?\320\032-\250T\260\326\207\001\320\204\001\372\371\207\0018\265\204\003\023\2209\230B\377\230j\250\002\250!\330\024\365\025\373AY\364\205\001\330\020\036\230\347i""\240q\270\207\005\222`\340\020\027\277\220{\240#\240S&\002\020\376\254\210\0013\240c\250\022\2501\371\330\000\n\014\013\031\230\033\240B\377\240a\360\030\000\021\024\220\3775\230\003\2305\240\004\240wE\250\024\212\000\024\260Q\246\207\014\002\312\207\001\024\252\221\002\207\000\212\000\000\003\007\002\252\205\013v\304`\250Q&\005\"\230DQ\000\337D\250\003\2501=\020\035\230\375L\027\0003\250b\260\001\330e\020\263\205\001R\235\211\002\213\0007\2304\003oG\2502\250y\016\020\000\033\004\177A\330\024\027\220q\330\316\207\007\357q\330\034\035\322\207\001\030\220t\357\230<\240s\365\221\0023\270a\377\330\030\034\230O\320+>\177\270j\310\001\330\031\032\"\014\177\340\024\030\230\016\240d\220\223\001\237\340\020\024\320\024\334A\347\212\002\024s\240Q\313`\017\001)\250\021\373\212\001\367J\230a\223L\033\2304\230\335q\311\211\0019\230C\273\213\001\027\220\377y\240\002\240*\250B\250~r\000\031\330\024!\240\031\347\223\002\377\024\"\240)\2501\250J\257\260b\270\001\022\001\021\324\212\0022\377\260+\270S\300\002\300\"\377\300A\330\025\036\230b\240\370\031\0004\013\213\211\001!\240\013\2501\276\333`*\270A\270Q\356\001z\317\240\022\2401\350\013\324\207\001C\250\337q\260\013\2702O\000\001\300\337\024\300Q\330,\322a\037\300\367\003\3001\337\000\320\0302\260\261!u\002\005\005\371a\024\220\377\212\003$\313\250oW\001\025\342a\261\215\002\025#\342\313`Q\221!\215\212\001\314 \320\0333\377\2603\260d\270/\310\022\375\310e\024\004\3204M\310R\353\310qs\003\021\373\213\001\025\220J\377\320\0363\2604\3207G\373\300q\276\204\034\024\220O\2409\377\250A\250\\\270\032\3002\260\274\000\351\210\001\356$\263\216\001t\220\216\205\004\034\347\230I\240\245`\275\214\002\320\027/\353\250s\324\001 \267!\030\320\030\3733\260\352\000 \240\n\250\"\333\250D\322`\024\030\363\002\340\020\357 \240\004\240\347\215\001\320\024+\317\250:\260R\303\212\001\363\207\001\020\034\345\230\213\213\0024B\004\372\213\001\031\320\030n\255\221\001!\2609\355 \\\310\247@\345\025\274aA\301a\341@\240\004\320\323$9\274\206\002\366`\034\332""\204\002F\250\257*\260A\340\341`F\367@N;\270!\363\217\003\021\024\220\363#?\014\374\230\226\001\273@\037\230t\240=\260\377\007\260q\330\030,\250I\377\260Q\260c\270\025\270a\367\270t\300\327@&\240a\240\377t\250>\270\021\330\030\"\367\240!\340\002\000#\240U\250\337!\2504\250q\214\217\002+\250\1776\260\021\330\025\031\230\304`\376\376a}\250G\2601\330\024\377(\250\t\260\021\260,\270\375a\223\205\001t\2301\320\034/\276\260\214\001\360\010\000\031-^\002a{\330\024M\000\2404\240~\333\206\001\337\036\230a\340\024\304\207\003\014\260\377A\340\020\024\220N\240!\376\351\220\001\r\240T\320)9\270\337\031\300$\300a\215\205\002*\250\375!\365\204\007\t\r\210I\220Y\377\230a\230z\250\035\260j\377\300\002\300.\320PQ\320\017\n\034\230A"; + PyObject *data = __Pyx_DecompressString_LZSS(cstring, 4832, 7046); + #define __Pyx_DecompressString_UNUSED + if (unlikely(!data)) __PYX_ERR(0, 1, __pyx_L1_error) + const char* const bytes = __Pyx_PyBytes_AsString(data); + #if !CYTHON_ASSUME_SAFE_MACROS + if (likely(bytes)); else { Py_DECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) } + #endif + #else /* compression: none (7046 bytes) */ +static const char bytes[] = " exceeds limit \047WSMessage\047(tree fragment).?Compressed message has too many deflate membersContinuation frame for non started messageControl frame payload cannot be larger than 125 bytesDecompressed message exceeds size limit Invalid UTF-8 text messageInvalid close code: Invalid close frame: Message size Note that Cython is deliberately stricter than PEP-484 and rejects subclasses of builtin types. If you need to pass subclasses then set the \047annotation_typing\047 directive to False.Received fragmented control frameReceived frame with non-zero reserved bitsThe opcode in non-fin frame is expected to be zero, got Unexpected opcode=WebSocketReader was garbage collected while stalled; callers of set_parser() must hold a strong referenceadd_noteaiohttp._websocket.helpersaiohttp._websocket.modelsaiohttp.base_protocolaiohttp.compression_utilsaiohttp.helpersaiohttp.logaiohttp.streamsaiohttp/_websocket/reader_py.pybuiltins.BaseExceptionbytes | bytearraybytes | bytearray | memoryviewdisableenablegcint | cython_intisenabledtype[BaseException] | BaseExceptiontype[BaseException] | BaseException | Noneutf-8ABNORMAL_CLOSUREBINARYBaseProtocolCLOSECONTINUATIONCancelledErrorEofStreamFalseINVALID_TEXTMESSAGE_TOO_BIGNonePINGPONGPROTOCOL_ERRORSTALLED_READER_COLLECTEDTEXTTimeoutErrorTooManyMembersErrorTrueUNPACK_CLOSE_CODEUNPACK_LEN3WSCloseCodeWSMessageWSMessageBinaryWSMessageCloseWSMessagePingWSMessagePongWSMessageTextWSMessageTextBytesWSMsgTypeWS_DEFLATE_TRAILINGWebSocketDataQueueWebSocketDataQueue.__reduce_cython__WebSocketDataQueue.__setstate_cython__WebSocketDataQueue.exceptionWebSocketDataQueue.feed_dataWebSocketDataQueue.feed_eofWebSocketDataQueue.is_eofWebSocketDataQueue.readWebSocketDataQueue.set_exceptionWebSocketErrorWebSocketReaderWebSocketReader.__reduce_cython__WebSocketReader.__setstate_cython__WebSocketReader._feed_dataWebSocketReader._handle_frameWebSocketReader.feed_dataWebSocketReader.feed_eofZLibDecompressor_EXC_SENTINEL__Pyx_PyDict_NextRef__annotate____await""____dict____func____getstate____main____module____name____new____pyx_capi____pyx_checksum__pyx_result__pyx_state__pyx_type__pyx_unpickle_WebSocketDataQueue__pyx_unpickle_WebSocketReader__pyx_vtable____qualname____reduce____reduce_cython____reduce_ex____set_name____setstate____setstate_cython____test___dict_feed_data_handle_frame_is_coroutine_reading_pausedaiohttp._websocket.reader_cappendasyncioasyncio.coroutinesbase_protocolboolbuiltinsbytesclearcline_in_tracebackclosecollectionscompresscompressedcompression_utilscreate_futurecython_intdatadecodedecode_textdecompress_syncdequedoneexcexc_causeexceptionextrafeed_datafeed_eoffinhelpersis_eofitemsjoinlimitlogloopmax_msg_sizemaxsizemodelsnextopcodepause_readingpayloadpoppopleftprotocolqueuereadrefresume_readingreturnselfsendset_exceptionset_resultsetdefaultsizestatestreamssuppress_deflate_headersysthrowupdateuse_setstatevaluevalueswaiterwarningweakrefwebsocket_maskws_loggerPyObject *\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000int\000\000\000\000\000\000\000\000\000\000unsigned PY_LONG_LONG\000unsigned int\000\000\000\000\000ALLOWED_CLOSE_CODES\000EMPTY_FRAME\000EMPTY_FRAME_ERROR\000MESSAGE_TYPES_WITH_CONTENT\000TUPLE_NEW\000UNPACK_CLOSE_CODE\000UNPACK_LEN3\000WSMessageBinary\000WSMessageClose\000WSMessagePing\000WSMessagePong\000WSMessageText\000WSMessageTextBytes\000WSMsgType\000WS_MSG_TYPE_BINARY\000WS_MSG_TYPE_TEXT\000COMPRESSED_FALSE\000COMPRESSED_NOT_SET\000COMPRESSED_TRUE\000OP_CODE_BINARY\000OP_CODE_CLOSE\000OP_CODE_CONTINUATION\000OP_CODE_NOT_SET\000OP_CODE_PING\000OP_CODE_PONG\000OP_CODE_TEXT\000MAX_PAYLOAD_LEN\000MSG_SIZE_OVERHEAD\000READ_HEADER\000READ_PAYLOAD\000READ_PAYLOAD_LENGTH\000READ_PAYLOAD_MASKvoid (PyObject *, PyObject *, int __pyx_skip_dispatch)\000_websocket_mask_cython\200\001\330\004-\250Q\250f\260A\200\001\330\0040\260\001\260\026\260q\200\001\340\004\037\230q\320 0\260\013\270;\300k\320QR\330\004\023\220?\240(\250!\2501\330\004\007\200|\2207\230!\330\0101\260\021\3202D\300N""\320RS\330\004\013\2101\200\001\340\004\037\230q\320 0\260\013\270;\300k\320QR\330\004\023\320\023%\240X\250Q\250a\330\004\007\200|\2207\230!\330\0104\260A\3205J\310.\320XY\330\004\013\2101\200\001\360\010\000\n\033\230!\330\010\021\220\024\220Z\230t\2407\250$\250m\2704\270~\310T\320QZ\320Z^\320^f\320fj\320jv\320vz\360\000\000{\001I\002\360\000\000I\002M\002\360\000\000M\002U\002\360\000\000U\002Y\002\360\000\000Y\002k\002\360\000\000k\002o\002\360\000\000o\002p\002\330\010\020\220\007\220q\230\006\230l\250!\330\004\007\200v\210W\220E\230\024\230Q\330\010\022\220!\330\010\027\220q\340\010\027\220t\2309\240G\2505\260\003\2604\260|\3007\310%\310s\320RV\320Vc\320cj\320jo\320or\320rv\320v}\360\000\000~\001E\002\360\000\000E\002J\002\360\000\000J\002M\002\360\000\000M\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002c\002\360\000\000c\002h\002\360\000\000h\002k\002\360\000\000k\002o\002\360\000\000o\002|\002\360\000\000|\002C\003\360\000\000C\003H\003\360\000\000H\003K\003\360\000\000K\003O\003\360\000\000O\003`\003\360\000\000`\003g\003\360\000\000g\003l\003\360\000\000l\003o\003\360\000\000o\003s\003\360\000\000s\003|\003\360\000\000|\003C\004\360\000\000C\004D\004\330\004\007\200q\330\010\017\320\0173\2604\260q\270\007\270{\310\047\320QR\340\010\017\320\0173\2604\260q\270\007\270{\310!\200\001\360\010\000\n\033\230!\330\010\021\220\024\220\\\240\024\240^\2604\260\177\300d\320J[\320[_\320_f\320fj\320jw\320w{\360\000\000|\001J\002\360\000\000J\002N\002\360\000\000N\002^\002\360\000\000^\002b\002\360\000\000b\002w\002\360\000\000w\002{\002\360\000\000{\002G\003\360\000\000G\003K\003\360\000\000K\003\\\003\360\000\000\\\003`\003\360\000\000`\003p\003\360\000\000p\003t\003\360\000\000t\003~\003\360\000\000~\003B\004\360\000\000B\004M\004\360\000\000M\004Q\004\360\000\000Q\004j\004\360\000\000j\004n\004\360\000\000n\004C\005\360\000\000C\005G\005\360\000\000G\005[\005\360\000\000[\005_\005\360\000\000_\005h\005\360\000\000h\005l\005\360\000\000l\005t\005\360\000\000t\005x""\005\360\000\000x\005E\006\360\000\000E\006I\006\360\000\000I\006J\006\330\010\020\220\007\220q\230\006\230l\250!\330\004\007\200v\210W\220E\230\024\230Q\330\010\022\220!\330\010\027\220q\340\010\027\220t\320\033+\2507\260%\260s\270$\270f\300G\3105\320PS\320SW\320Wd\320dk\320kp\320ps\320sw\360\000\000x\001B\002\360\000\000B\002I\002\360\000\000I\002N\002\360\000\000N\002Q\002\360\000\000Q\002U\002\360\000\000U\002i\002\360\000\000i\002p\002\360\000\000p\002u\002\360\000\000u\002x\002\360\000\000x\002|\002\360\000\000|\002C\003\360\000\000C\003J\003\360\000\000J\003O\003\360\000\000O\003R\003\360\000\000R\003V\003\360\000\000V\003b\003\360\000\000b\003i\003\360\000\000i\003n\003\360\000\000n\003q\003\360\000\000q\003u\003\360\000\000u\003|\003\360\000\000|\003C\004\360\000\000C\004D\004\330\004\007\200q\330\010\017\320\0170\260\004\260A\260W\270K\300w\310a\340\010\017\320\0170\260\004\260A\260W\270K\300q\200A\340\r\016\330\020\021\330\021\022\330\024\025\360\006\000\t\014\2107\220$\220n\320$4\260A\340\014\017\210w\220c\320\031.\250d\260$\260i\270s\300!\330\020\026\220n\240A\330\024\037\230q\330\024\025\360\010\000\r\020\210t\2201\340\020\023\2207\230#\230Q\330\024\030\230\013\2401\330\020\024\220M\240\021\330\020\021\340\014\032\230$\230a\230t\2401\330\014\017\210w\220c\230\021\330\020\031\230\024\230Q\330\020\024\220K\230q\360\006\000\022\023\330\020\026\220n\240A\330\024\037\230q\330\024\025\330&\047\240q\360\010\000\r\020\210q\330\020$\240D\250\n\260\"\260A\330\020\024\220I\230V\2401\340\020$\240A\360\010\000\r\020\210q\330\020\023\2204\220t\2301\330\024\030\320\030*\320*:\270!\320;S\320ST\360\014\000\021\022\330\024%\240T\250\037\3208H\310\001\330\030*\250\"\250A\340\034 \240\017\250r\260\021\330\037#\2401\330!%\240Q\360\006\000\021\030\320\027.\250a\330\024\032\230.\250\001\330\030#\2401\330\030\031\330\033\034\330\020\023\2204\220\177\240d\250#\250Q\320.>\270b\300\004\300A\330\024\032\230.\250\001\330\030#\2401\330\030B\300!\3004\300q\340\021\025\220Q\320\026)""\250\023\250A\330\020!\240\021\340\020!\240\025\240a\240q\340\014\023\2203\220a\220q\330\014\017\210w\220c\230\021\330\020\023\2204\220q\330\024\025\330\030\037\230~\250W\260A\260Q\330\024\033\320\0331\260\021\330\030\036\230n\250A\330\034\047\240\177\260a\330\037 \360\014\000\025\033\230)\2401\320$4\260F\270&\300\004\300A\360\006\000\025\033\230)\2401\330\030-\320-=\270V\3004\300q\360\006\000\021\027\220i\230q\330\024&\320&6\260f\270D\300\001\360\006\000\r\021\220\006\220j\240\001\240\021\330\r\024\220C\220q\330\014\032\230#\230Q\230a\330\014\017\210|\2303\230a\330\020\035\320\035.\250a\250w\260b\270\003\2701\270A\340\020\023\220;\230b\240\005\240Q\330\024\037\230r\240\025\240d\250+\260W\270A\340\024\032\230.\250\001\330\030#\2401\330\030.\250a\250q\340\020\021\330\024$\240G\2501\250C\250w\260a\260q\330\020\027\320\027-\250Q\330\024\032\230.\250\001\330\030#\240?\260!\330\033\034\330\020\026\220n\240A\330\024\031\230\034\240U\250-\260v\270Q\340\021\022\330\020\026\220n\240A\330\024\037\230q\330\024+\2501\250E\260\021\260(\270!\2701\360\006\000\021\027\220n\240A\240U\250#\250U\260-\270v\300Q\340\014\020\220\006\220j\240\001\240\021\330\r\024\220C\220q\330\014\020\220\006\220j\240\001\330\020\035\230Q\230e\2405\250\001\250\032\2605\270\003\2701\270J\300f\310A\340\r\024\220C\220q\330\014\020\220\006\220j\240\001\330\020\035\230Q\230e\2405\250\001\250\032\2605\270\003\2701\270J\300f\310A\360\006\000\r\023\220.\240\001\330\020\033\320\033,\320,@\300\001\300\021\200A\340\r\016\330\023,\250A\330\t\n\330\010\014\210H\220A\330\010\014\210N\230!\330\010\014\210G\2203\220d\230*\240G\2501\330\014\020\220\013\2301\330\014\031\230\021\230(\240%\240q\320\004\030\230\001\330\010\017\210t\2201\320\004\032\230!\330\010\014\210F\220)\2301\320\004\032\230!\330\010\014\210H\220A\330\010\014\320\014\034\230A\330\010\014\210N\230!\320\004\033\2301\330\010\017\210t\2201\320\004\036\230a\330\010\013\2104\210q\220\006\220g\230Q\330\014\023\2205\230\001\230\021\340\010\013\2104\210v\220W""\230A\330\014\023\2206\230\021\340\010\t\330\014\020\220\013\2301\230A\330\010\017\210}\230A\330\014\020\220\010\230\001\330\014\031\230\021\230$\230h\240a\330\014\023\2201\340\010\017\210q\320\004\036\230a\360\006\000\t\020\210t\2201\330\010\014\210J\220e\2302\230Q\330\010\014\210L\230\001\230\021\330\010\014\320\014\034\230A\330\010\013\2104\210w\220b\230\004\230H\240D\250\004\250D\260\n\270!\330\014\020\220\n\230.\250\001\320\004\037\230q\340\010\014\210F\320\022%\240Q\330\010\013\2104\210q\330\014\022\220$\220i\230t\2407\250\"\250F\260!\340\010\024\220A\330\010\023\2203\220a\220q\330\010\024\220A\340\010\t\330\014\017\210z\230\022\2309\240D\250\004\250F\260\047\270\022\2704\270v\300Q\360\n\000\021\025\220F\320\032-\250T\260\021\330\020\021\360\006\000\r\020\210t\2208\2303\230a\330\020\023\2209\230B\230j\250\002\250!\330\024\025\330\020\035\230Y\240a\240q\330\020\036\230i\240q\250\n\260\"\260A\330\020\035\230Q\340\020\027\220{\240#\240S\250\002\250!\330\020\030\230\013\2403\240c\250\022\2501\330\020\030\230\013\2403\240c\250\022\2501\330\020\030\230\013\2403\240c\250\022\2501\330\020\031\230\033\240B\240a\360\030\000\021\024\2205\230\003\2305\240\004\240E\250\024\250T\260\024\260Q\330\024\032\230.\250\001\330\030#\2401\330\030\031\360\006\000\021\024\2207\230!\330\024\025\330\024\025\330\024\025\330\024\025\330\024\025\330\024\025\340\024\032\230.\250\001\330\030#\2401\330\030,\250A\250Q\360\006\000\021\024\2207\230\"\230D\240\004\240D\250\003\2501\330\024\032\230.\250\001\330\030#\2401\330\030\031\360\006\000\021\035\230L\250\003\2503\250b\260\001\330\020\031\230\034\240R\240q\360\010\000\021\024\2207\230\"\230D\240\004\240G\2502\250Q\330\024\032\230.\250\001\330\030#\2401\330\030\031\360\020\000\021\024\2207\230\"\230A\330\024\027\220q\330\030\036\230n\250A\330\034\047\240q\330\034\035\360\014\000\025\030\220t\230<\240s\250$\250m\2703\270a\330\030\034\230O\320+>\270j\310\001\330\031\032\330\030\036\230n\250A\330\034\047\240q\330\034\035\340\024\030\230\016\240d""\250!\2501\340\020\024\320\024%\240Q\330\020\024\220M\240\024\240Q\240a\330\020\024\320\024)\250\021\330\020\024\220J\230a\360\006\000\r\020\210t\2208\2303\230a\330\020\033\2304\230q\330\020\023\2209\230C\230q\330\024\027\220y\240\002\240*\250B\250a\330\030\031\330\024!\240\031\250!\2501\330\024\"\240)\2501\250J\260b\270\001\330\024!\240\021\330\024\030\320\0302\260+\270S\300\002\300\"\300A\330\025\036\230b\240\001\330\024\027\220y\240\002\240*\250B\250a\330\030\031\360\006\000\025!\240\013\2501\250F\260*\270A\270Q\330\024\027\220z\240\022\2401\330\030\036\230n\250A\330\034\047\240q\330\034+\2501\250C\250q\260\013\2702\270S\300\001\300\024\300Q\330,-\250T\260\037\300\003\3001\340\024\030\320\0302\260!\330\024!\240\021\340\024\030\320\0302\260!\360\n\000\021\024\2204\220\177\240d\250$\250o\270Q\330\024\025\330\024\025\330\024\025\360\006\000\025#\240#\240Q\240d\250!\360\006\000\025\030\220t\320\0333\2603\260d\270/\310\022\3101\330\030\036\230n\250A\330\034\047\240q\330\034+\2501\250C\250q\260\004\3204M\310R\310q\330,-\250T\260\021\360\006\000\021\025\220J\320\0363\2604\3207G\300q\360\006\000\r\020\210t\2208\2303\230a\330\020\023\2209\230B\230j\250\002\250!\330\024\025\330\020\024\220O\2409\250A\250\\\270\032\3002\300Q\330\020\035\230Q\330\020\024\220J\230a\340\014\017\210t\2208\2303\230a\330\020\034\230I\240R\240q\330\020\023\2204\320\027/\250s\260!\330\024 \240\001\330\024\030\320\0303\2601\340\024 \240\n\250\"\250D\260\001\330\024\030\320\0302\260!\340\020 \240\004\240A\330\020\024\320\024+\250:\260R\260q\330\020\036\230a\330\020\034\230A\340\020\023\2204\320\027/\250s\260!\360\006\000\025\031\320\030+\2507\260!\2609\270A\270\\\310\021\330\024\025\330\030\034\230A\330\030\034\230C\230q\240\004\320$9\270\022\2704\270q\330\030\034\230D\240\004\240F\250*\260A\340\030\034\230F\240*\250N\270!\330\024\025\360\006\000\021\024\2201\340\024\030\320\030+\2507\260!\2609\270A\270\\\310\021\330\024\027\220t\2301\330\030\037\230t\240=\260\007\260q\330\030,\250I\260Q\260c\270""\025\270a\270t\3001\330\030&\240a\240t\250>\270\021\330\030\"\240!\340\030\"\240#\240U\250!\2504\250q\330\024\030\320\030+\2506\260\021\330\025\031\230\021\330\024\033\2304\230}\250G\2601\330\024(\250\t\260\021\260,\270a\330\024\027\220t\2301\320\034/\250w\260a\360\010\000\031-\250I\260Q\260a\330\024\"\240!\2404\240~\260Q\330\024\036\230a\340\024\036\230i\240q\250\014\260A\340\020\024\220N\240!\330\024\030\230\r\240T\320)9\270\031\300$\300a\340\020\024\320\024*\250!\330\020\024\220J\230a\360\006\000\t\r\210I\220Y\230a\230z\250\035\260j\300\002\300.\320PQ\320\n\034\230A"; + PyObject *data = NULL; + #define __Pyx_DecompressString_UNUSED + #define __Pyx_DecompressString_LZSS_UNUSED + #endif + PyObject **stringtab = __pyx_mstate->__pyx_string_tab; + Py_ssize_t pos = 0; + for (int i = 0; i < 194; i++) { + Py_ssize_t bytes_length = str_length_index[i].length; + PyObject *string = PyUnicode_DecodeUTF8(bytes + pos, bytes_length, NULL); + if (likely(string) && i >= 41) PyUnicode_InternInPlace(&string); + if (unlikely(!string)) { + Py_XDECREF(data); + __PYX_ERR(0, 1, __pyx_L1_error) + } + stringtab[i] = string; + pos += bytes_length; + } + for (int i = 194; i < 213; i++) { + Py_ssize_t bytes_length = bytes_length_index[i-194].length; + PyObject *string = PyBytes_FromStringAndSize(bytes + pos, bytes_length); + stringtab[i] = string; + pos += bytes_length; + if (unlikely(!string)) { + Py_XDECREF(data); + __PYX_ERR(0, 1, __pyx_L1_error) + } + } + Py_XDECREF(data); + for (Py_ssize_t i = 0; i < 213; i++) { + if (unlikely(PyObject_Hash(stringtab[i]) == -1)) { + __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = stringtab + 194; + for (Py_ssize_t i=0; i<19; ++i) { + #if PY_VERSION_HEX >= 0x030F0000 + PyUnstable_SetImmortal(table[i]); + #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; + #if PY_VERSION_HEX < 0x030E0000 + if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) + #else + if (PyUnstable_Object_IsUniquelyReferenced(table[i])) + #endif + { + Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); + } + #else + if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif + } + { + PyObject **numbertab = __pyx_mstate->__pyx_number_tab + 0; + int8_t const cint_constants_1[] = {0,2}; + int16_t const cint_constants_2[] = {256,3000,4999}; + int32_t const cint_constants_4[] = {130792693L,223677156L}; + for (int i = 0; i < 7; i++) { + numbertab[i] = PyLong_FromLong((i < 2 ? cint_constants_1[i - 0] : (i < 5 ? cint_constants_2[i - 2] : cint_constants_4[i - 5]))); + if (unlikely(!numbertab[i])) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = __pyx_mstate->__pyx_number_tab; + for (Py_ssize_t i=0; i<7; ++i) { + #if PY_VERSION_HEX >= 0x030F0000 + PyUnstable_SetImmortal(table[i]); + #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; + #if PY_VERSION_HEX < 0x030E0000 + if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) + #else + if (PyUnstable_Object_IsUniquelyReferenced(table[i])) + #endif + { + Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); + } + #else + if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_codeobjects ### */ +#ifdef __cplusplus +namespace { +#endif +typedef struct { + unsigned int argcount : 3; + unsigned int num_posonly_args : 1; + unsigned int num_kwonly_args : 1; + unsigned int nlocals : 3; + unsigned int flags : 10; + unsigned int first_line : 9; +} __Pyx_PyCode_New_function_description; +#ifdef __cplusplus +} /* anonymous namespace */ +#endif +/* NewCodeObj.proto */ +static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + PyObject *line_table, + PyObject *tuple_dedup_map +); + + +static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) { + PyObject* tuple_dedup_map = PyDict_New(); + if (unlikely(!tuple_dedup_map)) return -1; + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_COROUTINE), 141}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_aiohttp__websocket_reader_py_py, __pyx_mstate->__pyx_n_u_read, __pyx_mstate->__pyx_kp_b_iso88591_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 102}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_aiohttp__websocket_reader_py_py, __pyx_mstate->__pyx_n_u_is_eof, __pyx_mstate->__pyx_kp_b_iso88591_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 105}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[2] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_aiohttp__websocket_reader_py_py, __pyx_mstate->__pyx_n_u_exception, __pyx_mstate->__pyx_kp_b_iso88591_1_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[2])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 108}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_exc, __pyx_mstate->__pyx_n_u_exc_cause, __pyx_mstate->__pyx_n_u_waiter}; + __pyx_mstate_global->__pyx_codeobj_tab[3] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_aiohttp__websocket_reader_py_py, __pyx_mstate->__pyx_n_u_set_exception, __pyx_mstate->__pyx_kp_b_iso88591_A_A_HA_N_G3d_G1_1_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[3])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 126}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[4] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_aiohttp__websocket_reader_py_py, __pyx_mstate->__pyx_n_u_feed_eof, __pyx_mstate->__pyx_kp_b_iso88591_HA_A_N, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[4])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 131}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_data}; + __pyx_mstate_global->__pyx_codeobj_tab[5] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_aiohttp__websocket_reader_py_py, __pyx_mstate->__pyx_n_u_feed_data, __pyx_mstate->__pyx_kp_b_iso88591_a_t1_Je2Q_L_A_4wb_HD_D, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[5])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_2, __pyx_mstate->__pyx_n_u_use_setstate}; + __pyx_mstate_global->__pyx_codeobj_tab[6] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_tree_fragment, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_mstate->__pyx_kp_b_iso88591_Zt7_m4_TQZZ_ffjjvvz_I_I_M_M_U_U, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[6])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 17}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[7] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_tree_fragment, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_mstate->__pyx_kp_b_iso88591_0_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[7])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 227}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[8] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_aiohttp__websocket_reader_py_py, __pyx_mstate->__pyx_n_u_feed_eof, __pyx_mstate->__pyx_kp_b_iso88591_F_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[8])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 233}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_data}; + __pyx_mstate_global->__pyx_codeobj_tab[9] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_aiohttp__websocket_reader_py_py, __pyx_mstate->__pyx_n_u_feed_data, __pyx_mstate->__pyx_kp_b_iso88591_a_4q_gQ_5_4vWA_6_1A_A_ha_1_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[9])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 249}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_fin, __pyx_mstate->__pyx_n_u_opcode, __pyx_mstate->__pyx_n_u_payload, __pyx_mstate->__pyx_n_u_compressed}; + __pyx_mstate_global->__pyx_codeobj_tab[10] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_aiohttp__websocket_reader_py_py, __pyx_mstate->__pyx_n_u_handle_frame, __pyx_mstate->__pyx_kp_b_iso88591_A_7_n_4A_wc_d_is_nA_q_t1_7_Q_1_M, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[10])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 396}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_data}; + __pyx_mstate_global->__pyx_codeobj_tab[11] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_aiohttp__websocket_reader_py_py, __pyx_mstate->__pyx_n_u_feed_data_2, __pyx_mstate->__pyx_kp_b_iso88591_q_F_Q_4q_it7_F_A_3aq_A_z_9D_F_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[11])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_2, __pyx_mstate->__pyx_n_u_use_setstate}; + __pyx_mstate_global->__pyx_codeobj_tab[12] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_tree_fragment, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_mstate->__pyx_kp_b_iso88591_4_dJ___ffjjww_J_J_N_N_b_b_w_w_G, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[12])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 17}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[13] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_tree_fragment, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_mstate->__pyx_kp_b_iso88591_QfA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[13])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_result}; + __pyx_mstate_global->__pyx_codeobj_tab[14] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_tree_fragment, __pyx_mstate->__pyx_n_u_pyx_unpickle_WebSocketDataQueu, __pyx_mstate->__pyx_kp_b_iso88591_q_0_kQR_XQa_7_4A5J_XY_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[14])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_result}; + __pyx_mstate_global->__pyx_codeobj_tab[15] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_tree_fragment, __pyx_mstate->__pyx_n_u_pyx_unpickle_WebSocketReader, __pyx_mstate->__pyx_kp_b_iso88591_q_0_kQR_1_7_1_2DNRS_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[15])) goto bad; + } + Py_DECREF(tuple_dedup_map); + return 0; + bad: + Py_DECREF(tuple_dedup_map); + return -1; +} +/* #### Code section: init_globals ### */ + +static int __Pyx_InitGlobals(void) { + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + /* PythonCompatibility.init */ + if (likely(__Pyx_init_co_variables() == 0 && __Pyx_init_tpflags_variables() == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* AssertionsEnabled.init */ + if (likely(__Pyx_init_assertions_enabled() == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* CommonTypesMetaclass.init */ + if (likely(__pyx_CommonTypesMetaclass_init(__pyx_m) == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* Coroutine.init */ + if (likely(__pyx_Coroutine_init(__pyx_m) == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* Coro_CheckExact.init */ + #if CYTHON_COMPILING_IN_LIMITED_API + { + PyObject *typesModule=NULL; + typesModule = PyImport_ImportModule("types"); + if (typesModule) { + __pyx_mstate_global->__Pyx_CachedCoroType = PyObject_GetAttrString(typesModule, "CoroutineType"); + Py_DECREF(typesModule); + } + } // error handling follows + #endif + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* PyFrozenDict.init */ + #if CYTHON_COMPILING_IN_LIMITED_API + { + PyObject *builtins = PyEval_GetBuiltins(); // borrowed + if (likely(builtins)) { + PyObject *type_name = PyUnicode_FromStringAndSize("frozendict", sizeof("frozendict")-1); + if (likely(type_name)) { + PyObject *frozendict_type = PyObject_GetItem(builtins, type_name); + Py_DECREF(type_name); + if (!frozendict_type && PyErr_ExceptionMatches(PyExc_KeyError)) { + PyErr_Clear(); + frozendict_type = (PyObject*) &PyDict_Type; + Py_INCREF(frozendict_type); + } + __pyx_mstate_global->__Pyx_PyFrozenDictType = frozendict_type; + } + } + } // error handling follows + #endif + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* CachedMethodType.init */ + #if CYTHON_COMPILING_IN_LIMITED_API + { + PyObject *typesModule=NULL; + typesModule = PyImport_ImportModule("types"); + if (typesModule) { + __pyx_mstate_global->__Pyx_CachedMethodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + } + } // error handling follows + #endif + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_after_shared_utility ### */ + +static int __Pyx_InitAfterSharedUtility(void) { + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + /* CythonFunctionPerModule.init */ + if (likely(__pyx_CyFunction_init(__pyx_m) == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* CopyObjectArray (used by TupleOrListFromArrayImpl) */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } +} +#endif + +/* TupleOrListFromArrayImpl (used by TupleFromArray) */ +#if !(PY_VERSION_HEX >= 0x030F0000 && !CYTHON_COMPILING_IN_LIMITED_API) +CYTHON_UNUSED static PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) { + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); + } + PyObject *res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + #if CYTHON_COMPILING_IN_CPYTHON + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + #else + Py_ssize_t i; + for (i = 0; i < n; i++) { + Py_INCREF(src[i]); + if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < (0))) { + Py_DECREF(res); + return NULL; + } + } + #endif + return res; +} +#endif + +/* PyObjectCompare (used by UnicodeEquals) */ +#ifndef __Pyx_DEFINED_PyObject_CompareStrStrBoolEq +#define __Pyx_DEFINED_PyObject_CompareStrStrBoolEq +static CYTHON_INLINE int __Pyx_PyObject_CompareStrStrBoolEq(PyObject* s1, PyObject* s2) { + #if __PYX_LIMITED_VERSION_HEX >= 0x030e0000 + int result = PyUnicode_Equal(s1, s2); + #if !CYTHON_COMPILING_IN_CPYTHON + if (unlikely(result == -1)) return -1; + #endif + if (result == 0) goto __pyx_return_false; else goto __pyx_return_true; + #else + int result = PyUnicode_Compare(s1, s2); + if (unlikely((result == -1) && PyErr_Occurred())) return -1; + if (result == 0) goto __pyx_return_true; else goto __pyx_return_false; + #endif +__pyx_return_true: + return 1; +__pyx_return_false: + return 0; +} +#endif +static CYTHON_INLINE int __Pyx_PyObject_CompareBoolEq_str_str(PyObject *op1, PyObject *op2, int pyop) { + CYTHON_UNUSED_VAR(pyop); + if (unlikely(op1 == Py_None)) { + if (op2 == Py_None) goto __pyx_return_true; else goto __pyx_return_false; + } + if (unlikely(op2 == Py_None)) { + if (op1 == Py_None) goto __pyx_return_true; else goto __pyx_return_false; + } + + if (likely(op1 != Py_None)) { + if (op1 == op2) goto __pyx_return_true; + if (likely(op2 != Py_None)) { + return __Pyx_PyObject_CompareStrStrBoolEq(op1, op2); + } + goto __pyx_richcmp; + } + + if ((0)) goto __pyx_richcmp; + if ((0)) goto __pyx_return_true; + if ((0)) goto __pyx_return_false; +__pyx_richcmp: + return __Pyx_PyObject_RichCompareBool(op1, op2, Py_EQ); +__pyx_return_true: + return 1; +__pyx_return_false: + return 0; +} + +/* fastcall */ +#if CYTHON_VECTORCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = __Pyx_PyTuple_GET_SIZE(kwnames); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(n == -1)) return NULL; + #endif + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + if (s == namei) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + int eq = __Pyx_PyUnicode_Equals(s, namei); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs; + PyObject *dict; +#if !CYTHON_ASSUME_SAFE_SIZE + nkwargs = PyTuple_Size(kwnames); + if (unlikely(nkwargs < 0)) return NULL; +#else + nkwargs = PyTuple_GET_SIZE(kwnames); +#endif + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; itp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallMethO (used by PyObjectFastCall) */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectFastCall (used by PyObjectCallOneArg) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) != (0)) goto bad; + } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; +} +#endif +#if CYTHON_VECTORCALL && !(CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY) + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE vectorcallfunc __Pyx_PyVectorcall_Function(PyObject *callable) { + PyTypeObject *tp = Py_TYPE(callable); + #if defined(__Pyx_CyFunction_USED) + if (__Pyx_CyFunction_CheckExact(callable)) { + return __Pyx_CyFunction_func_vectorcall(callable); + } + #endif + if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { + return NULL; + } + assert(PyCallable_Check(callable)); + Py_ssize_t offset = tp->tp_vectorcall_offset; + assert(offset > 0); + vectorcallfunc ptr; + memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); + return ptr; +} + #else + #define __Pyx_PyVectorcall_Function(callable) PyVectorcall_Function(callable) + #endif +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(nargsf); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } +#endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL + #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + return PyObject_Vectorcall(func, args, nargsf, NULL); + #else + vectorcallfunc f = __Pyx_PyVectorcall_Function(func); + if (f) { + return f(func, args, nargsf, NULL); + } + #endif + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_mstate_global->__pyx_empty_tuple, kwargs); + } + #if CYTHON_COMPILING_IN_LIMITED_API + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #elif CYTHON_COMPILING_IN_PYPY + return PyObject_VectorcallDict(func, args, (size_t) nargs, kwargs); + #else + return PyObject_VectorcallDict(func, args, nargsf, kwargs); + #endif +} + +/* PyObjectCallOneArg (used by CallUnboundCMethod0) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* IgnoreException (used by UnpackUnboundCMethod_impl) */ +static CYTHON_INLINE int __Pyx_IgnoreGivenException(PyObject *given_exception, PyObject *ignorable_exception) { + if (PyErr_GivenExceptionMatches(given_exception ? given_exception : PyErr_Occurred(), ignorable_exception)) { + PyErr_Clear(); + return 1; + } + return 0; +} + +/* FastTypeChecks (used by UnpackUnboundCMethod_impl) */ +#if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); +} +#endif + +/* PyObjectGetAttrStr (used by UnpackUnboundCMethod_impl) */ +#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); + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* UnpackUnboundCMethod_impl (used by UnpackUnboundCMethod) */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) { + PyObject *result; + PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args)); + if (unlikely(!selfless_args)) return NULL; + result = PyObject_Call(method, selfless_args, kwargs); + Py_DECREF(selfless_args); + return result; +} +#else +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) { + return PyObject_Vectorcall(method, args ? args+1 : NULL, nargs ? (size_t) nargs-1 : 0, kwnames); +} +#endif +static PyMethodDef __Pyx_UnboundCMethod_Def = { + "CythonUnboundCMethod", + __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall), +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 + METH_VARARGS | METH_KEYWORDS, +#else + METH_FASTCALL | METH_KEYWORDS, +#endif + NULL +}; +static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { + PyObject *method, *result=NULL; + method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); + if (unlikely(!method)) + return -1; + result = method; +#if CYTHON_COMPILING_IN_CPYTHON + if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) + { + PyMethodDescrObject *descr = (PyMethodDescrObject*) method; + target->func = descr->d_method->ml_meth; + target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST); + } else +#endif +#if CYTHON_COMPILING_IN_PYPY +#else + if (PyCFunction_Check(method)) +#endif + { + PyObject *self; + int self_found; +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + self = PyObject_GetAttrString(method, "__self__"); + if (!self && !__Pyx_IgnoreException(PyExc_AttributeError)) { + return -1; + } +#else + self = PyCFunction_GET_SELF(method); +#endif + self_found = (self && self != Py_None); +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + Py_XDECREF(self); +#endif + if (self_found) { + PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method); + if (unlikely(!unbound_method)) return -1; + Py_DECREF(method); + result = unbound_method; + } + } +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if (unlikely(target->method)) { + Py_DECREF(result); + } else +#endif + target->method = result; + return 0; +} + +/* CallUnboundCMethod0 */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + if (likely(was_initialized == 2 && cfunc->func)) { + if (likely(cfunc->flag == METH_NOARGS)) + return __Pyx_CallCFunction(cfunc, self, NULL); + if (likely(cfunc->flag == METH_FASTCALL)) + return __Pyx_CallCFunctionFast(cfunc, self, NULL, 0); + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, NULL, 0, NULL); + if (likely(cfunc->flag == (METH_VARARGS | METH_KEYWORDS))) + return __Pyx_CallCFunctionWithKeywords(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (cfunc->flag == METH_VARARGS) + return __Pyx_CallCFunction(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple); + return __Pyx__CallUnboundCMethod0(cfunc, self); + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod0(&tmp_cfunc, self); + } +#endif + PyObject *result = __Pyx__CallUnboundCMethod0(cfunc, self); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif +static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { + PyObject *result; + if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; + result = __Pyx_PyObject_CallOneArg(cfunc->method, self); + return result; +} + +/* py_dict_items (used by OwnedDictNext) */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) { + return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_items, d); +} + +/* py_dict_values (used by OwnedDictNext) */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d) { + return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_values, d); +} + +/* OwnedDictNext (used by ParseKeywordsImpl) */ +#if CYTHON_AVOID_BORROWED_REFS +static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, PyObject **pvalue) { + PyObject *next = NULL; + if (!*ppos) { + if (pvalue) { + PyObject *dictview = pkey ? __Pyx_PyDict_Items(p) : __Pyx_PyDict_Values(p); + if (unlikely(!dictview)) goto bad; + *ppos = PyObject_GetIter(dictview); + Py_DECREF(dictview); + } else { + *ppos = PyObject_GetIter(p); + } + if (unlikely(!*ppos)) goto bad; + } + next = PyIter_Next(*ppos); + if (!next) { + if (PyErr_Occurred()) goto bad; + return 0; + } + if (pkey && pvalue) { + *pkey = __Pyx_PySequence_ITEM(next, 0); + if (unlikely(*pkey)) goto bad; + *pvalue = __Pyx_PySequence_ITEM(next, 1); + if (unlikely(*pvalue)) goto bad; + Py_DECREF(next); + } else if (pkey) { + *pkey = next; + } else { + assert(pvalue); + *pvalue = next; + } + return 1; + bad: + Py_XDECREF(next); +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 + PyErr_FormatUnraisable("Exception ignored in __Pyx_PyDict_NextRef"); +#else + PyErr_WriteUnraisable(__pyx_mstate_global->__pyx_n_u_Pyx_PyDict_NextRef); +#endif + if (pkey) *pkey = NULL; + if (pvalue) *pvalue = NULL; + return 0; +} +#else // !CYTHON_AVOID_BORROWED_REFS +static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue) { + int result = PyDict_Next(p, ppos, pkey, pvalue); + if (likely(result == 1)) { + if (pkey) Py_INCREF(*pkey); + if (pvalue) Py_INCREF(*pvalue); + } + return result; +} +#endif + +/* RaiseDoubleKeywords (used by ParseKeywordsImpl) */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); +} + +/* CallUnboundCMethod2 */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + if (likely(was_initialized == 2 && cfunc->func)) { + PyObject *args[2] = {arg1, arg2}; + if (cfunc->flag == METH_FASTCALL) { + return __Pyx_CallCFunctionFast(cfunc, self, args, 2); + } + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, 2, NULL); + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod2(&tmp_cfunc, self, arg1, arg2); + } +#endif + PyObject *result = __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){ + if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_COMPILING_IN_CPYTHON + if (cfunc->func && (cfunc->flag & METH_VARARGS)) { + PyObject *result = NULL; + PyObject *args = PyTuple_New(2); + if (unlikely(!args)) return NULL; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + if (cfunc->flag & METH_KEYWORDS) + result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL); + else + result = __Pyx_CallCFunction(cfunc, self, args); + Py_DECREF(args); + return result; + } +#endif + { + PyObject *args[4] = {NULL, self, arg1, arg2}; + return __Pyx_PyObject_FastCall(cfunc->method, args+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } +} + +/* ParseKeywordsImpl (used by ParseKeywords) */ +static int __Pyx_ValidateDuplicatePosArgs( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char* function_name) +{ + PyObject ** const *name = argnames; + while (name != first_kw_arg) { + PyObject *key = **name; + int found = PyDict_Contains(kwds, key); + if (unlikely(found)) { + if (found == 1) __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; + } + name++; + } + return 0; +bad: + return -1; +} +#if CYTHON_USE_UNICODE_INTERNALS +static CYTHON_INLINE int __Pyx_UnicodeKeywordsEqual(PyObject *s1, PyObject *s2) { + int kind; + Py_ssize_t len = PyUnicode_GET_LENGTH(s1); + if (len != PyUnicode_GET_LENGTH(s2)) return 0; + kind = PyUnicode_KIND(s1); + if (kind != PyUnicode_KIND(s2)) return 0; + const void *data1 = PyUnicode_DATA(s1); + const void *data2 = PyUnicode_DATA(s2); + return (memcmp(data1, data2, (size_t) len * (size_t) kind) == 0); +} +#endif +static int __Pyx_MatchKeywordArg_str( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + #if CYTHON_USE_UNICODE_INTERNALS + Py_hash_t key_hash = ((PyASCIIObject*)key)->hash; + if (unlikely(key_hash == -1)) { + key_hash = PyObject_Hash(key); + if (unlikely(key_hash == -1)) + goto bad; + } + #endif + name = first_kw_arg; + while (*name) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (key_hash == ((PyASCIIObject*)name_str)->hash && __Pyx_UnicodeKeywordsEqual(name_str, key)) { + *index_found = (size_t) (name - argnames); + return 1; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + *index_found = (size_t) (name - argnames); + return 1; + } + } + #endif + name++; + } + name = argnames; + while (name != first_kw_arg) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (unlikely(key_hash == ((PyASCIIObject*)name_str)->hash)) { + if (__Pyx_UnicodeKeywordsEqual(name_str, key)) + goto arg_passed_twice; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + if (unlikely(name_str == key)) goto arg_passed_twice; + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + } + #endif + name++; + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +bad: + return -1; +} +static int __Pyx_MatchKeywordArg_nostr( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; + name = first_kw_arg; + while (*name) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (cmp == 1) { + *index_found = (size_t) (name - argnames); + return 1; + } + if (unlikely(cmp == -1)) goto bad; + name++; + } + name = argnames; + while (name != first_kw_arg) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (unlikely(cmp != 0)) { + if (cmp == 1) goto arg_passed_twice; + else goto bad; + } + name++; + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +bad: + return -1; +} +static CYTHON_INLINE int __Pyx_MatchKeywordArg( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + return likely(PyUnicode_CheckExact(key)) ? + __Pyx_MatchKeywordArg_str(key, argnames, first_kw_arg, index_found, function_name) : + __Pyx_MatchKeywordArg_nostr(key, argnames, first_kw_arg, index_found, function_name); +} +static void __Pyx_RejectUnknownKeyword( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char *function_name) +{ + #if CYTHON_AVOID_BORROWED_REFS + PyObject *pos = NULL; + #else + Py_ssize_t pos = 0; + #endif + PyObject *key = NULL; + __Pyx_BEGIN_CRITICAL_SECTION(kwds); + #if CYTHON_AVOID_BORROWED_REFS + while (__Pyx_PyDict_NextRef(kwds, &pos, &key, NULL)) + #else + (void) __Pyx_PyDict_NextRef; + while (PyDict_Next(kwds, &pos, &key, NULL)) + #endif + { + PyObject** const *name = first_kw_arg; + while (*name && (**name != key)) name++; + if (!*name) { + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp != 1) { + if (cmp == 0) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + break; + } + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + } + __Pyx_END_CRITICAL_SECTION(); + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(pos); + #endif + assert(PyErr_Occurred()); +} +static int __Pyx_ParseKeywordDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t extracted = 0; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + name = first_kw_arg; + while (*name && num_kwargs > extracted) { + PyObject * key = **name; + PyObject *value; + int found = 0; + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + found = PyDict_GetItemRef(kwds, key, &value); + #else + value = PyDict_GetItemWithError(kwds, key); + if (value) { + Py_INCREF(value); + found = 1; + } else { + if (unlikely(PyErr_Occurred())) goto bad; + } + #endif + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + extracted++; + } + name++; + } + if (num_kwargs > extracted) { + if (ignore_unknown_kwargs) { + if (unlikely(__Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name) == -1)) + goto bad; + } else { + __Pyx_RejectUnknownKeyword(kwds, argnames, first_kw_arg, function_name); + goto bad; + } + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordDictToDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t len; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + if (PyDict_Update(kwds2, kwds) < 0) goto bad; + name = first_kw_arg; + while (*name) { + PyObject *key = **name; + PyObject *value; +#if !CYTHON_COMPILING_IN_LIMITED_API && (PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop)) + int found = PyDict_Pop(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + } +#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int found = PyDict_GetItemRef(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + if (unlikely(PyDict_DelItem(kwds2, key) < 0)) goto bad; + } +#else + #if CYTHON_COMPILING_IN_CPYTHON + value = _PyDict_Pop(kwds2, key, kwds2); + #else + value = __Pyx_CallUnboundCMethod2(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_pop, kwds2, key, kwds2); + #endif + if (value == kwds2) { + Py_DECREF(value); + } else { + if (unlikely(!value)) goto bad; + values[name-argnames] = value; + } +#endif + name++; + } + len = PyDict_Size(kwds2); + if (len > 0) { + return __Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name); + } else if (unlikely(len == -1)) { + goto bad; + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordsTuple( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject *key = NULL; + PyObject** const * name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + for (Py_ssize_t pos = 0; pos < num_kwargs; pos++) { +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); +#else + key = __Pyx_PyTuple_GET_ITEM(kwds, pos); +#endif +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!key)) goto bad; +#endif + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + PyObject *value = kwvalues[pos]; + values[name-argnames] = __Pyx_NewRef(value); + } else { + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp == 1) { + PyObject *value = kwvalues[pos]; + values[index_found] = __Pyx_NewRef(value); + } else { + if (unlikely(cmp == -1)) goto bad; + if (kwds2) { + PyObject *value = kwvalues[pos]; + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else if (!ignore_unknown_kwargs) { + goto invalid_keyword; + } + } + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + key = NULL; + #endif + } + return 0; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + goto bad; +bad: + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(key); + #endif + return -1; +} + +/* ParseKeywords */ +static int __Pyx_ParseKeywords( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + if (CYTHON_VECTORCALL && likely(PyTuple_Check(kwds))) + return __Pyx_ParseKeywordsTuple(kwds, kwvalues, argnames, kwds2, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); + else if (kwds2) + return __Pyx_ParseKeywordDictToDict(kwds, argnames, kwds2, values, num_pos_args, function_name); + else + return __Pyx_ParseKeywordDict(kwds, argnames, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); +} + +/* RaiseArgTupleInvalid */ +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) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseKeywordRequired */ +static void __Pyx_RaiseKeywordRequired(const char* func_name, PyObject* kw_name) { + PyErr_Format(PyExc_TypeError, + "%s() needs keyword-only argument %U", func_name, kw_name); +} + +/* FormatTypeName (used by pybuiltin_invalid) */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static __Pyx_TypeName +__Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp) +{ + PyObject *module = NULL, *name = NULL, *result = NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_qualname); + #else + name = PyType_GetQualName(tp); + #endif + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) goto bad; + module = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_module); + if (unlikely(module == NULL) || unlikely(!PyUnicode_Check(module))) goto bad; + if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) { + result = name; + name = NULL; + goto done; + } + result = PyUnicode_FromFormat("%U.%U", module, name); + if (unlikely(result == NULL)) goto bad; + done: + Py_XDECREF(name); + Py_XDECREF(module); + return result; + bad: + PyErr_Clear(); + if (name) { + result = name; + name = NULL; + } else { + result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u_); + } + goto done; +} +#endif + +/* pybuiltin_invalid (used by pyint_simplify) */ +static void __Pyx_PyBuiltin_Invalid(PyObject *obj, const char *builtin_type_name, const char *argname) { + __Pyx_TypeName obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 + if (unlikely(!obj_type_name)) return; + #endif + if (argname) { + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.5s, got " __Pyx_FMT_TYPENAME ")", + argname, builtin_type_name, obj_type_name + ); + } else { + PyErr_Format(PyExc_TypeError, + "Expected %.5s, got " __Pyx_FMT_TYPENAME, + builtin_type_name, obj_type_name + ); + } + __Pyx_DECREF_TypeName(obj_type_name); +} + +/* pyint_simplify */ +static int __Pyx__PyInt_FromNumber(PyObject **number_var, const char *argname); +static CYTHON_INLINE int __Pyx_PyInt_FromNumber(PyObject **number_var, const char *argname, int accept_none) { + PyObject *number = *number_var; + if (likely((accept_none && number == Py_None) || PyLong_CheckExact(number))) { + return 0; + } + return __Pyx__PyInt_FromNumber(number_var, argname); +} +static int __Pyx__PyInt_FromNumber(PyObject **number_var, const char *argname) { + PyObject *number = *number_var; + PyObject *int_object; + if (likely(PyNumber_Check(number))) { + int_object = PyNumber_Long(number); + if (unlikely(!int_object)) goto bad; + } else { + __Pyx_PyBuiltin_Invalid(number, "int", argname); + goto bad; + } + *number_var = int_object; + Py_DECREF(number); + return 0; +bad: + *number_var = NULL; + Py_DECREF(number); + return -1; +} + +/* ArgTypeTestError (used by ArgTypeTest) */ +static void __Pyx_ArgTypeError(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + __Pyx_TypeName type_name; + __Pyx_TypeName obj_type_name; + PyObject *extra_info = __pyx_mstate_global->__pyx_empty_unicode; + int from_annotation_subclass = 0; + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return; + } else if (exact == 2) { + if (__Pyx_TypeCheck(obj, type)) { + from_annotation_subclass = 1; + extra_info = __pyx_mstate_global->__pyx_kp_u_Note_that_Cython_is_deliberately; + } + } + type_name = __Pyx_PyType_GetFullyQualifiedName(type); + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 + if (unlikely(!type_name)) return; + #endif + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 + if (unlikely(!obj_type_name)) goto obj_type_name_failed; + #endif + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME ", got " __Pyx_FMT_TYPENAME ")" +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + "%s%U" +#endif + , name, type_name, obj_type_name +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + , (from_annotation_subclass ? ". " : ""), extra_info +#endif + ); +#if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + if (exact == 2 && from_annotation_subclass) { + PyObject *res; + PyObject *vargs[2]; + vargs[0] = PyErr_GetRaisedException(); + vargs[1] = extra_info; + res = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_kp_u_add_note, vargs, 2, NULL); + Py_XDECREF(res); + PyErr_SetRaisedException(vargs[0]); + } +#endif + __Pyx_DECREF_TypeName(obj_type_name); +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 +obj_type_name_failed: +#endif + __Pyx_DECREF_TypeName(type_name); + return; +} + +/* ArgTypeTest */ +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, const char *name, int exact) { + if (likely(Py_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) + return 1; + if (!exact && likely(type) && likely(__Pyx_TypeCheck(obj, type))) + return 1; + __Pyx_ArgTypeError(obj, type, name, exact); + return 0; +} + +/* PyLongBinop */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_Fallback___Pyx_PyLong_MultiplyObjC(PyObject *op1, PyObject *op2, int inplace) { + return (inplace ? PyNumber_InPlaceMultiply : PyNumber_Multiply)(op1, op2); +} +#if CYTHON_USE_PYLONG_INTERNALS +static PyObject* __Pyx_Unpacked___Pyx_PyLong_MultiplyObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(inplace); + CYTHON_UNUSED_VAR(zerodivision_check); + const long b = intval; + long a; + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla; + if (unlikely(__Pyx_PyLong_IsZero(op1))) { + return __Pyx_NewRef(op1); + } + const int is_positive = __Pyx_PyLong_IsPos(op1); + const digit* digits = __Pyx_PyLong_Digits(op1); + const Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); + if (likely(size == 1)) { + a = (long) digits[0]; + if (!is_positive) a *= -1; + } else { + if (size == 2 && 8 * sizeof(long) - 1 > 2 * PyLong_SHIFT+30) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if (!is_positive) a *= -1; + goto calculate_long; + } else if (size == 2 && 8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT+30) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + if (!is_positive) lla *= -1; + goto calculate_long_long; + } else + if (size == 3 && 8 * sizeof(long) - 1 > 3 * PyLong_SHIFT+30) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if (!is_positive) a *= -1; + goto calculate_long; + } else if (size == 3 && 8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT+30) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + if (!is_positive) lla *= -1; + goto calculate_long_long; + } else + if (size == 4 && 8 * sizeof(long) - 1 > 4 * PyLong_SHIFT+30) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if (!is_positive) a *= -1; + goto calculate_long; + } else if (size == 4 && 8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT+30) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + if (!is_positive) lla *= -1; + goto calculate_long_long; + } else + {} + return PyLong_Type.tp_as_number->nb_multiply(op1, op2); + } + calculate_long: + CYTHON_UNUSED_VAR(a); + CYTHON_UNUSED_VAR(b); + lla = a; + goto calculate_long_long; + calculate_long_long: + { + PY_LONG_LONG llx; + llx = lla * llb; + return PyLong_FromLongLong(llx); + } + +} +#endif +static PyObject* __Pyx_Float___Pyx_PyLong_MultiplyObjC(PyObject *float_val, long intval, int zerodivision_check) { + CYTHON_UNUSED_VAR(zerodivision_check); + const long b = intval; + double a = __Pyx_PyFloat_AS_DOUBLE(float_val); + double result; + + result = ((double)a) * (double)b; + return PyFloat_FromDouble(result); +} +static CYTHON_INLINE PyObject* __Pyx_PyLong_MultiplyObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(intval); + CYTHON_UNUSED_VAR(zerodivision_check); + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + return __Pyx_Unpacked___Pyx_PyLong_MultiplyObjC(op1, op2, intval, inplace, zerodivision_check); + } + #endif + if (PyFloat_CheckExact(op1)) { + return __Pyx_Float___Pyx_PyLong_MultiplyObjC(op1, intval, zerodivision_check); + } + return __Pyx_Fallback___Pyx_PyLong_MultiplyObjC(op1, op2, inplace); +} +#endif + +/* PyErrFetchRestore (used by GivenExceptionMatches) */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#endif +} +#endif + +/* GivenExceptionMatches (used by PyErrExceptionMatches) */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } +} +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyObjectGetAttrStrNoError (used by GetBuiltinName) */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} + +/* GetBuiltinName (used by GetModuleGlobalName) */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, + "name '%U' is not defined", name); + } + return result; +} + +/* PyDictVersioning (used by GetModuleGlobalName) */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ +#if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + if (!PyErr_Occurred()) + PyErr_SetNone(PyExc_NameError); + return NULL; + } + result = PyObject_GetAttr(__pyx_m, name); + if (likely(result)) { + return result; + } + if (!__Pyx_IgnoreException(PyExc_Exception)) { + return NULL; // BaseException + } +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + if (unlikely(__Pyx_PyDict_GetItemRef(__pyx_mstate_global->__pyx_d, name, &result) == -1)) { + if (!__Pyx_IgnoreException(PyExc_Exception)) { + return NULL; // BaseException + } + } + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return result; + } +#else + result = _PyDict_GetItem_KnownHash(__pyx_mstate_global->__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyObject *exc = PyErr_Occurred(); + if (unlikely(exc) && !__Pyx_IgnoreGivenException(exc, PyExc_Exception)) { + return NULL; // BaseException + } +#endif + return __Pyx_GetBuiltinName(name); +} + +/* RejectKeywords */ +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds) { + PyObject *key = NULL; + if (CYTHON_VECTORCALL && likely(PyTuple_Check(kwds))) { + key = __Pyx_PySequence_ITEM(kwds, 0); + } else { +#if CYTHON_AVOID_BORROWED_REFS + PyObject *pos = NULL; +#else + Py_ssize_t pos = 0; +#endif +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return; +#endif + __Pyx_PyDict_NextRef(kwds, &pos, &key, NULL); +#if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(pos); +#endif + } + if (likely(key)) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + Py_DECREF(key); + } +} + +/* PyObjectFastCallMethod */ +#if !CYTHON_VECTORCALL +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf) { + PyObject *result; + switch (__Pyx_PyVectorcall_NARGS(nargsf)) { + case 1: + return PyObject_CallMethodObjArgs(args[0], name, NULL); + case 2: + return PyObject_CallMethodObjArgs(args[0], name, args[1], NULL); + case 3: + return PyObject_CallMethodObjArgs(args[0], name, args[1], args[2], NULL); + case 4: + return PyObject_CallMethodObjArgs(args[0], name, args[1], args[2], args[3], NULL); + case 5: + return PyObject_CallMethodObjArgs(args[0], name, args[1], args[2], args[3], args[4], NULL); + } + PyObject *attr = PyObject_GetAttr(args[0], name); + if (unlikely(!attr)) + return NULL; + result = __Pyx_PyObject_FastCall(attr, args+1, nargsf - 1); + Py_DECREF(attr); + return result; +} +#endif + +/* RaiseException */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyException_SetTraceback(value, tb); +#elif CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} + +/* dict_setdefault (used by FetchCommonType) */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value) { + PyObject* value; +#if __PYX_LIMITED_VERSION_HEX >= 0x030F0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4) + PyDict_SetDefaultRef(d, key, default_value, &value); +#elif CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + PyObject *args[] = {d, key, default_value}; + value = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_n_u_setdefault, args, 3 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#elif CYTHON_COMPILING_IN_LIMITED_API + value = PyObject_CallMethodObjArgs(d, __pyx_mstate_global->__pyx_n_u_setdefault, key, default_value, NULL); +#else + value = PyDict_SetDefault(d, key, default_value); + if (unlikely(!value)) return NULL; + Py_INCREF(value); +#endif + return value; +} + +/* AddModuleRef (used by FetchSharedCythonModule) */ +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && PY_VERSION_HEX < 0x030F00a3 + static PyObject *__Pyx_PyImport_AddModuleObjectRef(PyObject *name) { + PyObject *module_dict = PyImport_GetModuleDict(); + PyObject *m; + if (PyMapping_GetOptionalItem(module_dict, name, &m) < 0) { + return NULL; + } + if (m != NULL && PyModule_Check(m)) { + return m; + } + Py_XDECREF(m); + m = PyModule_NewObject(name); + if (m == NULL) + return NULL; + if (PyDict_CheckExact(module_dict)) { + PyObject *new_m; + (void)PyDict_SetDefaultRef(module_dict, name, m, &new_m); + Py_DECREF(m); + return new_m; + } else { + if (PyObject_SetItem(module_dict, name, m) != 0) { + Py_DECREF(m); + return NULL; + } + return m; + } + } + static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + if ((PY_VERSION_HEX >= 0x030E0000) && Py_Version >= 0x030E0100) { + return PyImport_AddModuleRef(name); + } + PyObject *py_name = PyUnicode_FromString(name); + if (!py_name) return NULL; + PyObject *module = __Pyx_PyImport_AddModuleObjectRef(py_name); + Py_DECREF(py_name); + return module; + } +#elif __PYX_LIMITED_VERSION_HEX < 0x030d0000 + static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } +#endif + +/* FetchSharedCythonModule (used by FetchCommonType) */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME); +} + +/* VerifyCachedType (used by FetchCommonType) */ +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t expected_basicsize) { + Py_ssize_t basicsize; + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (expected_basicsize == 0) { + return 0; // size is inherited, nothing useful to check + } +#if CYTHON_COMPILING_IN_LIMITED_API && CYTHON_OPAQUE_OBJECTS + if (expected_basicsize < 0) { + basicsize = PyType_GetTypeDataSize((PyTypeObject*)cached_type); + } else +#endif + { + #if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) return -1; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = NULL; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1; + #else + basicsize = ((PyTypeObject*) cached_type)->tp_basicsize; + #endif + } + if ((expected_basicsize >= 0) ? + (basicsize != expected_basicsize) : + (basicsize < -expected_basicsize)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} + +/* FetchCommonType (used by CommonTypesMetaclass) */ +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 +static PyObject* __Pyx_PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *result = __Pyx_PyType_FromModuleAndSpec(module, spec, bases); + if (result && metaclass) { + PyObject *old_tp = (PyObject*)Py_TYPE(result); + Py_INCREF((PyObject*)metaclass); + Py_SET_TYPE(result, metaclass); + Py_DECREF(old_tp); + PyType_Modified((PyTypeObject*)result); + } + return result; +} +#else +#define __Pyx_PyType_FromMetaclass(me, mo, s, b) PyType_FromMetaclass(me, mo, s, b) +#endif +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name; + int get_item_ref_result; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + py_object_name = PyUnicode_FromString(object_name); + if (!py_object_name) return NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) goto done; + abi_module_dict = PyModule_GetDict(abi_module); + if (!abi_module_dict) goto done; + get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type); + if (get_item_ref_result == 1) { + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else if (unlikely(get_item_ref_result == -1)) { + goto bad; + } + cached_type = __Pyx_PyType_FromMetaclass( + metaclass, + CYTHON_USE_MODULE_STATE ? module : abi_module, + spec, bases); + if (unlikely(!cached_type)) goto bad; + new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type); + if (unlikely(new_cached_type != cached_type)) { + if (unlikely(!new_cached_type)) goto bad; + Py_DECREF(cached_type); + cached_type = new_cached_type; + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else { + Py_DECREF(new_cached_type); + } +done: + Py_XDECREF(abi_module); + Py_DECREF(py_object_name); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +/* CommonTypesMetaclass (used by CoroutineBase) */ +static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) { + return PyUnicode_FromString(__PYX_ABI_MODULE_NAME); +} +#if __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject* __pyx_CommonTypesMetaclass_call(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *args, CYTHON_UNUSED PyObject *kwds) { + PyErr_SetString(PyExc_TypeError, "Cannot instantiate Cython internal types"); + return NULL; +} +static int __pyx_CommonTypesMetaclass_setattr(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *attr, CYTHON_UNUSED PyObject *value) { + PyErr_SetString(PyExc_TypeError, "Cython internal types are immutable"); + return -1; +} +#endif +static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = { + {"__module__", __pyx_CommonTypesMetaclass_get_module, NULL, NULL, NULL}, + {0, 0, 0, 0, 0} +}; +static PyType_Slot __pyx_CommonTypesMetaclass_slots[] = { + {Py_tp_getset, (void *)__pyx_CommonTypesMetaclass_getset}, + #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 + {Py_tp_call, (void*)__pyx_CommonTypesMetaclass_call}, + {Py_tp_new, (void*)__pyx_CommonTypesMetaclass_call}, + {Py_tp_setattro, (void*)__pyx_CommonTypesMetaclass_setattr}, + #endif + {0, 0} +}; +static PyType_Spec __pyx_CommonTypesMetaclass_spec = { + __PYX_TYPE_MODULE_PREFIX "_common_types_metatype", + 0, + 0, + Py_TPFLAGS_IMMUTABLETYPE | + Py_TPFLAGS_DISALLOW_INSTANTIATION | + Py_TPFLAGS_DEFAULT, + __pyx_CommonTypesMetaclass_slots +}; +static int __pyx_CommonTypesMetaclass_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + PyObject *bases = PyTuple_Pack(1, &PyType_Type); + if (unlikely(!bases)) { + return -1; + } + mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases); + Py_DECREF(bases); + if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) { + return -1; + } + return 0; +} + +/* GetTopmostException (used by SaveResetException) */ +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException (used by CoroutineBase) */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + PyObject *exc_value = exc_info->exc_value; + if (exc_value == NULL || exc_value == Py_None) { + *value = NULL; + *type = NULL; + *tb = NULL; + } else { + *value = exc_value; + Py_INCREF(*value); + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + *tb = PyException_GetTraceback(exc_value); + } + #elif CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #endif +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + PyObject *tmp_value = exc_info->exc_value; + exc_info->exc_value = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); + #else + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); + #endif +} +#endif + +/* SwapException (used by CoroutineBase) */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_value = exc_info->exc_value; + exc_info->exc_value = *value; + if (tmp_value == NULL || tmp_value == Py_None) { + Py_XDECREF(tmp_value); + tmp_value = NULL; + tmp_type = NULL; + tmp_tb = NULL; + } else { + tmp_type = (PyObject*) Py_TYPE(tmp_value); + Py_INCREF(tmp_type); + #if CYTHON_COMPILING_IN_CPYTHON + tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback; + Py_XINCREF(tmp_tb); + #else + tmp_tb = PyException_GetTraceback(tmp_value); + #endif + } + #elif CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = *type; + exc_info->exc_value = *value; + exc_info->exc_traceback = *tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; + #endif + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#endif + +/* CallTypeTraverse (used by CoroutineBase) */ +#if !CYTHON_USE_TYPE_SPECS +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg) { + if (!always_call) { + PyTypeObject *base = __Pyx_PyObject_GetSlot(o, tp_base, PyTypeObject*); + unsigned long flags = PyType_GetFlags(base); + if (flags & Py_TPFLAGS_HEAPTYPE) { + return 0; + } + } + Py_VISIT((PyObject*)Py_TYPE(o)); + return 0; +} +#endif + +/* IterNextPlain (used by CoroutineBase) */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject *__Pyx_GetBuiltinNext_LimitedAPI(void) { + if (unlikely(!__pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache)) + __pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache = __Pyx_GetBuiltinName(__pyx_mstate_global->__pyx_n_u_next); + return __pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache; +} +#endif +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next_Plain(PyObject *iterator) { +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + PyObject *result; + PyObject *next = __Pyx_GetBuiltinNext_LimitedAPI(); + if (unlikely(!next)) return NULL; + result = PyObject_CallFunctionObjArgs(next, iterator, NULL); + return result; +#else + (void)__Pyx_GetBuiltinName; // only for early limited API + iternextfunc iternext = __Pyx_PyObject_GetIterNextFunc(iterator); + assert(iternext); + return iternext(iterator); +#endif +} + +/* PyObjectCallMethod1 (used by CoroutineBase) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { +#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || !CYTHON_COMPILING_IN_LIMITED_API) + PyObject *args[2] = {obj, arg}; + return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#elif CYTHON_COMPILING_IN_LIMITED_API + return PyObject_CallMethodObjArgs(obj, method_name, arg, NULL); +#else + return PyObject_CallMethodOneArg(obj, method_name, arg); +#endif +} + +/* PyObjectCallNoArg (used by CoroutineBase) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* RaiseErrorWithObjectType (used by CoroutineBase) */ +static void __Pyx_RaiseErrorWithType(PyObject* exc_type, const char* message, PyTypeObject *type_obj) { + __Pyx_TypeName type_name = __Pyx_PyType_GetFullyQualifiedName(type_obj); + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 + if (unlikely(!type_name)) return; + #endif + PyErr_Format(exc_type, message, type_name); + __Pyx_DECREF_TypeName(type_name); +} + +/* ReturnWithStopIteration (used by CoroutineBase) */ +static void __Pyx__ReturnWithStopIteration(PyObject* value, int async); +static CYTHON_INLINE void __Pyx_ReturnWithStopIteration(PyObject* value, int async, int iternext) { + if (value == Py_None) { + if (async || !iternext) + PyErr_SetNone(async ? PyExc_StopAsyncIteration : PyExc_StopIteration); + return; + } + __Pyx__ReturnWithStopIteration(value, async); +} +static void __Pyx__ReturnWithStopIteration(PyObject* value, int async) { +#if CYTHON_COMPILING_IN_CPYTHON + __Pyx_PyThreadState_declare +#endif + PyObject *exc; + PyObject *exc_type = async ? PyExc_StopAsyncIteration : PyExc_StopIteration; +#if CYTHON_COMPILING_IN_CPYTHON + if ((PY_VERSION_HEX >= (0x030C00A6)) || unlikely(PyTuple_Check(value) || PyExceptionInstance_Check(value))) { + if (PY_VERSION_HEX >= (0x030e00A1)) { + exc = __Pyx_PyObject_CallOneArg(exc_type, value); + } else { + PyObject *args_tuple = PyTuple_New(1); + if (unlikely(!args_tuple)) return; + Py_INCREF(value); + PyTuple_SET_ITEM(args_tuple, 0, value); + exc = PyObject_Call(exc_type, args_tuple, NULL); + Py_DECREF(args_tuple); + } + if (unlikely(!exc)) return; + } else { + Py_INCREF(value); + exc = value; + } + #if CYTHON_FAST_THREAD_STATE + __Pyx_PyThreadState_assign + #if CYTHON_USE_EXC_INFO_STACK + if (!__pyx_tstate->exc_info->exc_value) + #else + if (!__pyx_tstate->exc_type) + #endif + { + Py_INCREF(exc_type); + __Pyx_ErrRestore(exc_type, exc, NULL); + return; + } + #endif +#else + exc = __Pyx_PyObject_CallOneArg(exc_type, value); + if (unlikely(!exc)) return; +#endif + PyErr_SetObject(exc_type, exc); + Py_DECREF(exc); +} + +/* CoroutineBase (used by Coroutine) */ +#if !CYTHON_COMPILING_IN_LIMITED_API +#include +#if PY_VERSION_HEX >= 0x030b00a6 && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +#endif // CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void +__Pyx_Coroutine_Undelegate(__pyx_CoroutineObject *gen) { +#if CYTHON_USE_AM_SEND + gen->yieldfrom_am_send = NULL; +#endif + Py_CLEAR(gen->yieldfrom); +} +static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *__pyx_tstate, PyObject **pvalue) { + PyObject *et, *ev, *tb; + PyObject *value = NULL; + CYTHON_UNUSED_VAR(__pyx_tstate); + __Pyx_ErrFetch(&et, &ev, &tb); + if (!et) { + Py_XDECREF(tb); + Py_XDECREF(ev); + Py_INCREF(Py_None); + *pvalue = Py_None; + return 0; + } + if (likely(et == PyExc_StopIteration)) { + if (!ev) { + Py_INCREF(Py_None); + value = Py_None; + } + else if (likely(Py_IS_TYPE(ev, (PyTypeObject*)PyExc_StopIteration))) { + #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL + value = PyObject_GetAttr(ev, __pyx_mstate_global->__pyx_n_u_value); + if (unlikely(!value)) goto limited_api_failure; + #else + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + #endif + Py_DECREF(ev); + } + else if (unlikely(PyTuple_Check(ev))) { + Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(ev); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(tuple_size < 0)) { + Py_XDECREF(tb); + Py_DECREF(ev); + Py_DECREF(et); + return -1; + } + #endif + if (tuple_size >= 1) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + value = PyTuple_GET_ITEM(ev, 0); + Py_INCREF(value); +#elif CYTHON_ASSUME_SAFE_MACROS + value = PySequence_ITEM(ev, 0); +#else + value = PySequence_GetItem(ev, 0); + if (!value) goto limited_api_failure; +#endif + } else { + Py_INCREF(Py_None); + value = Py_None; + } + Py_DECREF(ev); + } + else if (!__Pyx_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) { + value = ev; + } + if (likely(value)) { + Py_XDECREF(tb); + Py_DECREF(et); + *pvalue = value; + return 0; + } + } else if (!__Pyx_PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + PyErr_NormalizeException(&et, &ev, &tb); + if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + Py_XDECREF(tb); + Py_DECREF(et); +#if CYTHON_COMPILING_IN_LIMITED_API + value = PyObject_GetAttr(ev, __pyx_mstate_global->__pyx_n_u_value); +#else + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); +#endif + Py_DECREF(ev); +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!value)) return -1; +#endif + *pvalue = value; + return 0; +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL || !CYTHON_ASSUME_SAFE_MACROS + limited_api_failure: + Py_XDECREF(et); + Py_XDECREF(tb); + Py_XDECREF(ev); + return -1; +#endif +} +static CYTHON_INLINE +__Pyx_PySendResult __Pyx_Coroutine_status_from_result(PyObject **retval) { + if (*retval) { + return PYGEN_NEXT; + } else if (likely(__Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, retval) == 0)) { + return PYGEN_RETURN; + } else { + return PYGEN_ERROR; + } +} +static CYTHON_INLINE +void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) { +#if PY_VERSION_HEX >= 0x030B00a4 + Py_CLEAR(exc_state->exc_value); +#else + PyObject *t, *v, *tb; + t = exc_state->exc_type; + v = exc_state->exc_value; + tb = exc_state->exc_traceback; + exc_state->exc_type = NULL; + exc_state->exc_value = NULL; + exc_state->exc_traceback = NULL; + Py_XDECREF(t); + Py_XDECREF(v); + Py_XDECREF(tb); +#endif +} +#define __Pyx_Coroutine_AlreadyRunningError(gen) (__Pyx__Coroutine_AlreadyRunningError(gen), (PyObject*)NULL) +static void __Pyx__Coroutine_AlreadyRunningError(__pyx_CoroutineObject *gen) { + const char *msg; + CYTHON_MAYBE_UNUSED_VAR(gen); + if ((0)) { + #ifdef __Pyx_Coroutine_USED + } else if (__Pyx_Coroutine_Check((PyObject*)gen)) { + msg = "coroutine already executing"; + #endif + #ifdef __Pyx_AsyncGen_USED + } else if (__Pyx_AsyncGen_CheckExact((PyObject*)gen)) { + msg = "async generator already executing"; + #endif + } else { + msg = "generator already executing"; + } + PyErr_SetString(PyExc_ValueError, msg); +} +static void __Pyx_Coroutine_AlreadyTerminatedError(PyObject *gen, PyObject *value, int closing) { + CYTHON_MAYBE_UNUSED_VAR(gen); + CYTHON_MAYBE_UNUSED_VAR(closing); + #ifdef __Pyx_Coroutine_USED + if (!closing && __Pyx_Coroutine_Check(gen)) { + PyErr_SetString(PyExc_RuntimeError, "cannot reuse already awaited coroutine"); + } else + #endif + if (value) { + #ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(gen)) + PyErr_SetNone(PyExc_StopAsyncIteration); + else + #endif + PyErr_SetNone(PyExc_StopIteration); + } +} +static +__Pyx_PySendResult __Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, PyObject **result, int closing) { + __Pyx_PyThreadState_declare + PyThreadState *tstate; + __Pyx_ExcInfoStruct *exc_state; + PyObject *retval; + assert(__Pyx_Coroutine_get_is_running(self)); // Callers should ensure is_running + if (unlikely(self->resume_label == -1)) { + __Pyx_Coroutine_AlreadyTerminatedError((PyObject*)self, value, closing); + return PYGEN_ERROR; + } +#if CYTHON_FAST_THREAD_STATE + __Pyx_PyThreadState_assign + tstate = __pyx_tstate; +#else + tstate = __Pyx_PyThreadState_Current; +#endif + exc_state = &self->gi_exc_state; + if (exc_state->exc_value) { + #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + #else + PyObject *exc_tb; + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON + exc_tb = PyException_GetTraceback(exc_state->exc_value); + #elif PY_VERSION_HEX >= 0x030B00a4 + exc_tb = ((PyBaseExceptionObject*) exc_state->exc_value)->traceback; + #else + exc_tb = exc_state->exc_traceback; + #endif + if (exc_tb) { + PyTracebackObject *tb = (PyTracebackObject *) exc_tb; + PyFrameObject *f = tb->tb_frame; + assert(f->f_back == NULL); + #if PY_VERSION_HEX >= 0x030B00A1 + f->f_back = PyThreadState_GetFrame(tstate); + #else + Py_XINCREF(tstate->frame); + f->f_back = tstate->frame; + #endif + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON + Py_DECREF(exc_tb); + #endif + } + #endif + } +#if CYTHON_USE_EXC_INFO_STACK + exc_state->previous_item = tstate->exc_info; + tstate->exc_info = exc_state; +#else + if (exc_state->exc_type) { + __Pyx_ExceptionSwap(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); + } else { + __Pyx_Coroutine_ExceptionClear(exc_state); + __Pyx_ExceptionSave(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); + } +#endif + retval = self->body(self, tstate, value); +#if CYTHON_USE_EXC_INFO_STACK + exc_state = &self->gi_exc_state; + tstate->exc_info = exc_state->previous_item; + exc_state->previous_item = NULL; + __Pyx_Coroutine_ResetFrameBackpointer(exc_state); +#endif + *result = retval; + if (self->resume_label == -1) { + return likely(retval) ? PYGEN_RETURN : PYGEN_ERROR; + } + return PYGEN_NEXT; +} +static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(exc_state); +#else + PyObject *exc_tb; + #if PY_VERSION_HEX >= 0x030B00a4 + if (!exc_state->exc_value) return; + exc_tb = PyException_GetTraceback(exc_state->exc_value); + #else + exc_tb = exc_state->exc_traceback; + #endif + if (likely(exc_tb)) { + PyTracebackObject *tb = (PyTracebackObject *) exc_tb; + PyFrameObject *f = tb->tb_frame; + Py_CLEAR(f->f_back); + #if PY_VERSION_HEX >= 0x030B00a4 + Py_DECREF(exc_tb); + #endif + } +#endif +} +#define __Pyx_Coroutine_MethodReturnFromResult(gen, result, retval, iternext)\ + ((result) == PYGEN_NEXT ? (retval) : __Pyx__Coroutine_MethodReturnFromResult(gen, result, retval, iternext)) +static PyObject * +__Pyx__Coroutine_MethodReturnFromResult(PyObject* gen, __Pyx_PySendResult result, PyObject *retval, int iternext) { + CYTHON_MAYBE_UNUSED_VAR(gen); + if (likely(result == PYGEN_RETURN)) { + int is_async = 0; + #ifdef __Pyx_AsyncGen_USED + is_async = __Pyx_AsyncGen_CheckExact(gen); + #endif + __Pyx_ReturnWithStopIteration(retval, is_async, iternext); + Py_XDECREF(retval); + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE +PyObject *__Pyx_PyGen_Send(PyGenObject *gen, PyObject *arg) { +#if PY_VERSION_HEX <= 0x030A00A1 + return _PyGen_Send(gen, arg); +#else + PyObject *result; + if (PyIter_Send((PyObject*)gen, arg ? arg : Py_None, &result) == PYGEN_RETURN) { + if (PyAsyncGen_CheckExact(gen)) { + assert(result == Py_None); + PyErr_SetNone(PyExc_StopAsyncIteration); + } + else if (result == Py_None) { + PyErr_SetNone(PyExc_StopIteration); + } + else { +#if PY_VERSION_HEX < 0x030d00A1 + _PyGen_SetStopIterationValue(result); +#else + if (!PyTuple_Check(result) && !PyExceptionInstance_Check(result)) { + PyErr_SetObject(PyExc_StopIteration, result); + } else { + PyObject *exc = __Pyx_PyObject_CallOneArg(PyExc_StopIteration, result); + if (likely(exc != NULL)) { + PyErr_SetObject(PyExc_StopIteration, exc); + Py_DECREF(exc); + } + } +#endif + } + Py_DECREF(result); + result = NULL; + } + return result; +#endif +} +#endif +static CYTHON_INLINE __Pyx_PySendResult +__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen, PyObject** retval) { + __Pyx_PySendResult result; + PyObject *val = NULL; + assert(__Pyx_Coroutine_get_is_running(gen)); + __Pyx_Coroutine_Undelegate(gen); + __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, &val); + result = __Pyx_Coroutine_SendEx(gen, val, retval, 0); + Py_XDECREF(val); + return result; +} +#if CYTHON_USE_AM_SEND +static __Pyx_PySendResult +__Pyx_Coroutine_SendToDelegate(__pyx_CoroutineObject *gen, __Pyx_pyiter_sendfunc gen_am_send, PyObject *value, PyObject **retval) { + PyObject *ret = NULL; + __Pyx_PySendResult delegate_result, result; + assert(__Pyx_Coroutine_get_is_running(gen)); + delegate_result = gen_am_send(gen->yieldfrom, value, &ret); + if (delegate_result == PYGEN_NEXT) { + assert (ret != NULL); + *retval = ret; + return PYGEN_NEXT; + } + assert (delegate_result != PYGEN_ERROR || ret == NULL); + __Pyx_Coroutine_Undelegate(gen); + result = __Pyx_Coroutine_SendEx(gen, ret, retval, 0); + Py_XDECREF(ret); + return result; +} +#endif +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_AmSend(self, value, &retval); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 0); +} +static __Pyx_PySendResult +__Pyx_Coroutine_AmSend(PyObject *self, PyObject *value, PyObject **retval) { + __Pyx_PySendResult result; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + *retval = __Pyx_Coroutine_AlreadyRunningError(gen); + return PYGEN_ERROR; + } + #if CYTHON_USE_AM_SEND + if (gen->yieldfrom_am_send) { + result = __Pyx_Coroutine_SendToDelegate(gen, gen->yieldfrom_am_send, value, retval); + } else + #endif + if (gen->yieldfrom) { + PyObject *yf = gen->yieldfrom; + PyObject *ret; + #if !CYTHON_USE_AM_SEND + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_Check(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_PyAsyncGenASend_CheckExact(yf)) { + ret = __Pyx_async_gen_asend_send(yf, value); + } else + #endif + #if CYTHON_COMPILING_IN_CPYTHON + if (PyGen_CheckExact(yf)) { + ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); + } else + if (PyCoro_CheckExact(yf)) { + ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); + } else + #endif + #endif + { + if (value == Py_None && PyIter_Check(yf)) + ret = __Pyx_PyIter_Next_Plain(yf); + else + ret = __Pyx_PyObject_CallMethod1(yf, __pyx_mstate_global->__pyx_n_u_send, value); + } + if (likely(ret)) { + __Pyx_Coroutine_unset_is_running(gen); + *retval = ret; + return PYGEN_NEXT; + } + result = __Pyx_Coroutine_FinishDelegation(gen, retval); + } else { + result = __Pyx_Coroutine_SendEx(gen, value, retval, 0); + } + __Pyx_Coroutine_unset_is_running(gen); + return result; +} +static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { + __Pyx_PySendResult result; + PyObject *retval = NULL; + CYTHON_UNUSED_VAR(gen); + assert(__Pyx_Coroutine_get_is_running(gen)); + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + result = __Pyx_Coroutine_Close(yf, &retval); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_Check(yf)) { + result = __Pyx_Coroutine_Close(yf, &retval); + } else + if (__Pyx_CoroutineAwait_CheckExact(yf)) { + result = __Pyx_CoroutineAwait_Close((__pyx_CoroutineAwaitObject*)yf); + } else + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_PyAsyncGenASend_CheckExact(yf)) { + retval = __Pyx_async_gen_asend_close(yf, NULL); + result = PYGEN_RETURN; + } else + if (__pyx_PyAsyncGenAThrow_CheckExact(yf)) { + retval = __Pyx_async_gen_athrow_close(yf, NULL); + result = PYGEN_RETURN; + } else + #endif + { + PyObject *meth; + result = PYGEN_RETURN; + meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_mstate_global->__pyx_n_u_close); + if (unlikely(!meth)) { + if (unlikely(PyErr_Occurred())) { + PyErr_WriteUnraisable(yf); + } + } else { + retval = __Pyx_PyObject_CallNoArg(meth); + Py_DECREF(meth); + if (unlikely(!retval)) { + result = PYGEN_ERROR; + } + } + } + Py_XDECREF(retval); + return result == PYGEN_ERROR ? -1 : 0; +} +static PyObject *__Pyx_Generator_Next(PyObject *self) { + __Pyx_PySendResult result; + PyObject *retval = NULL; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + return __Pyx_Coroutine_AlreadyRunningError(gen); + } + #if CYTHON_USE_AM_SEND + if (gen->yieldfrom_am_send) { + result = __Pyx_Coroutine_SendToDelegate(gen, gen->yieldfrom_am_send, Py_None, &retval); + } else + #endif + if (gen->yieldfrom) { + PyObject *yf = gen->yieldfrom; + PyObject *ret; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Generator_Next(yf); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, Py_None); + } else + #endif + #if CYTHON_COMPILING_IN_CPYTHON && (PY_VERSION_HEX < 0x030A00A3 || !CYTHON_USE_AM_SEND) + if (PyGen_CheckExact(yf)) { + ret = __Pyx_PyGen_Send((PyGenObject*)yf, NULL); + } else + #endif + ret = __Pyx_PyIter_Next_Plain(yf); + if (likely(ret)) { + __Pyx_Coroutine_unset_is_running(gen); + return ret; + } + result = __Pyx_Coroutine_FinishDelegation(gen, &retval); + } else { + result = __Pyx_Coroutine_SendEx(gen, Py_None, &retval, 0); + } + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 1); +} +static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, PyObject *arg) { + PyObject *retval = NULL; + __Pyx_PySendResult result; + CYTHON_UNUSED_VAR(arg); + result = __Pyx_Coroutine_Close(self, &retval); + if (unlikely(result == PYGEN_ERROR)) + return NULL; + Py_XDECREF(retval); + Py_RETURN_NONE; +} +static __Pyx_PySendResult +__Pyx_Coroutine_Close(PyObject *self, PyObject **retval) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + __Pyx_PySendResult result; + PyObject *yf; + int err = 0; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + *retval = __Pyx_Coroutine_AlreadyRunningError(gen); + return PYGEN_ERROR; + } + yf = gen->yieldfrom; + if (yf) { + Py_INCREF(yf); + err = __Pyx_Coroutine_CloseIter(gen, yf); + __Pyx_Coroutine_Undelegate(gen); + Py_DECREF(yf); + } + if (err == 0) + PyErr_SetNone(PyExc_GeneratorExit); + result = __Pyx_Coroutine_SendEx(gen, NULL, retval, 1); + if (result == PYGEN_ERROR) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_Coroutine_unset_is_running(gen); + if (!__Pyx_PyErr_Occurred()) { + return PYGEN_RETURN; + } else if (likely(__Pyx_PyErr_ExceptionMatches2(PyExc_GeneratorExit, PyExc_StopIteration))) { + __Pyx_PyErr_Clear(); + return PYGEN_RETURN; + } + return PYGEN_ERROR; + } else if (likely(result == PYGEN_RETURN && *retval == Py_None)) { + __Pyx_Coroutine_unset_is_running(gen); + return PYGEN_RETURN; + } else { + const char *msg; + Py_DECREF(*retval); + *retval = NULL; + if ((0)) { + #ifdef __Pyx_Coroutine_USED + } else if (__Pyx_Coroutine_Check(self)) { + msg = "coroutine ignored GeneratorExit"; + #endif + #ifdef __Pyx_AsyncGen_USED + } else if (__Pyx_AsyncGen_CheckExact(self)) { + msg = "async generator ignored GeneratorExit"; + #endif + } else { + msg = "generator ignored GeneratorExit"; + } + PyErr_SetString(PyExc_RuntimeError, msg); + __Pyx_Coroutine_unset_is_running(gen); + return PYGEN_ERROR; + } +} +static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject *val, PyObject *tb, + PyObject *args, int close_on_genexit) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *yf; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) + return __Pyx_Coroutine_AlreadyRunningError(gen); + yf = gen->yieldfrom; + if (yf) { + __Pyx_PySendResult result; + PyObject *ret; + Py_INCREF(yf); + if (__Pyx_PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit) && close_on_genexit) { + int err = __Pyx_Coroutine_CloseIter(gen, yf); + Py_DECREF(yf); + __Pyx_Coroutine_Undelegate(gen); + if (err < 0) + goto propagate_exception; + goto throw_here; + } + if (0 + #ifdef __Pyx_Generator_USED + || __Pyx_Generator_CheckExact(yf) + #endif + #ifdef __Pyx_Coroutine_USED + || __Pyx_Coroutine_Check(yf) + #endif + ) { + ret = __Pyx__Coroutine_Throw(yf, typ, val, tb, args, close_on_genexit); + #ifdef __Pyx_Coroutine_USED + } else if (__Pyx_CoroutineAwait_CheckExact(yf)) { + ret = __Pyx__Coroutine_Throw(((__pyx_CoroutineAwaitObject*)yf)->coroutine, typ, val, tb, args, close_on_genexit); + #endif + } else { + PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_mstate_global->__pyx_n_u_throw); + if (unlikely(!meth)) { + Py_DECREF(yf); + if (unlikely(PyErr_Occurred())) { + __Pyx_Coroutine_unset_is_running(gen); + return NULL; + } + __Pyx_Coroutine_Undelegate(gen); + goto throw_here; + } + if (args) { + ret = __Pyx_PyObject_Call(meth, args, NULL); + } else { + PyObject *cargs[4] = {NULL, typ, val, tb}; + size_t nargs = 1U + (val != NULL) + (tb != NULL); + ret = __Pyx_PyObject_FastCall(meth, cargs+1, nargs | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } + Py_DECREF(meth); + } + Py_DECREF(yf); + if (ret) { + __Pyx_Coroutine_unset_is_running(gen); + return ret; + } + result = __Pyx_Coroutine_FinishDelegation(gen, &ret); + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, ret, 0); + } +throw_here: + __Pyx_Raise(typ, val, tb, NULL); +propagate_exception: + { + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_SendEx(gen, NULL, &retval, 0); + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 0); + } +} +static PyObject *__Pyx_Coroutine_Throw(PyObject *self, +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + PyObject *args +#else + PyObject *const *args, Py_ssize_t nargs +#endif +) { + PyObject *typ; + PyObject *val = NULL; + PyObject *tb = NULL; +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (unlikely(!PyArg_UnpackTuple(args, "throw", 1, 3, &typ, &val, &tb))) + return NULL; +#else + switch (nargs) { + case 3: + tb = args[2]; + CYTHON_FALLTHROUGH; + case 2: + val = args[1]; + CYTHON_FALLTHROUGH; + case 1: + typ = args[0]; + break; + default: + PyErr_SetString(PyExc_TypeError, "throw takes between 1 and 3 positional arguments"); + return NULL; + } +#endif + return __Pyx__Coroutine_Throw(self, typ, val, tb, +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + args, +#else + NULL, +#endif + 1); +} +static CYTHON_INLINE int __Pyx_Coroutine_traverse_excstate(__Pyx_ExcInfoStruct *exc_state, visitproc visit, void *arg) { +#if PY_VERSION_HEX >= 0x030B00a4 + Py_VISIT(exc_state->exc_value); +#else + Py_VISIT(exc_state->exc_type); + Py_VISIT(exc_state->exc_value); + Py_VISIT(exc_state->exc_traceback); +#endif + return 0; +} +static int __Pyx_Coroutine_traverse(__pyx_CoroutineObject *gen, visitproc visit, void *arg) { + { + int e = __Pyx_call_type_traverse((PyObject*)gen, 1, visit, arg); + if (e) return e; + } + Py_VISIT(gen->closure); + Py_VISIT(gen->classobj); + Py_VISIT(gen->yieldfrom); + return __Pyx_Coroutine_traverse_excstate(&gen->gi_exc_state, visit, arg); +} +static int __Pyx_Coroutine_clear(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + Py_CLEAR(gen->closure); + Py_CLEAR(gen->classobj); + __Pyx_Coroutine_Undelegate(gen); + __Pyx_Coroutine_ExceptionClear(&gen->gi_exc_state); +#ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(self)) { + Py_CLEAR(((__pyx_PyAsyncGenObject*)gen)->ag_finalizer); + } +#endif + Py_CLEAR(gen->gi_code); + Py_CLEAR(gen->gi_frame); + Py_CLEAR(gen->gi_name); + Py_CLEAR(gen->gi_qualname); + Py_CLEAR(gen->gi_modulename); + return 0; +} +static void __Pyx_Coroutine_dealloc(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject_GC_UnTrack(gen); + #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + if (gen->gi_weakreflist != NULL) + #endif + PyObject_ClearWeakRefs(self); + if (gen->resume_label >= 0) { +#if CYTHON_USE_TP_FINALIZE + PyObject_GC_Track(self); + if (unlikely(PyObject_CallFinalizerFromDealloc(self))) + { + return; + } + PyObject_GC_UnTrack(self); +#endif + } +#ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(self)) { + /* We have to handle this case for asynchronous generators + right here, because this code has to be between UNTRACK + and GC_Del. */ + Py_CLEAR(((__pyx_PyAsyncGenObject*)self)->ag_finalizer); + } +#endif + __Pyx_Coroutine_clear(self); + __Pyx_PyHeapTypeObject_GC_Del(gen); +} +#if CYTHON_USE_TP_FINALIZE +static void __Pyx_Coroutine_del(PyObject *self) { + PyObject *error_type, *error_value, *error_traceback; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + __Pyx_PyThreadState_declare + if (gen->resume_label < 0) { + return; + } + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); +#ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(self)) { + __pyx_PyAsyncGenObject *agen = (__pyx_PyAsyncGenObject*)self; + PyObject *finalizer = agen->ag_finalizer; + if (finalizer && !agen->ag_closed) { + PyObject *res = __Pyx_PyObject_CallOneArg(finalizer, self); + if (unlikely(!res)) { + PyErr_WriteUnraisable(self); + } else { + Py_DECREF(res); + } + __Pyx_ErrRestore(error_type, error_value, error_traceback); + return; + } + } +#endif + if (unlikely(gen->resume_label == 0 && !error_value)) { +#ifdef __Pyx_Coroutine_USED +#ifdef __Pyx_Generator_USED + if (!__Pyx_Generator_CheckExact(self)) +#endif + { + PyObject_GC_UnTrack(self); + if (unlikely(PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "coroutine '%.50S' was never awaited", gen->gi_qualname) < 0)) + PyErr_WriteUnraisable(self); + PyObject_GC_Track(self); + } +#endif + } else { + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_Close(self, &retval); + if (result == PYGEN_ERROR) { + PyErr_WriteUnraisable(self); + } else { + Py_XDECREF(retval); + } + } + __Pyx_ErrRestore(error_type, error_value, error_traceback); +} +#endif +static PyObject * +__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, void *context) +{ + PyObject *name = self->gi_name; + CYTHON_UNUSED_VAR(context); + if (unlikely(!name)) name = Py_None; + Py_INCREF(name); + return name; +} +static int +__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(self->gi_name, value); + return 0; +} +static PyObject * +__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, void *context) +{ + PyObject *name = self->gi_qualname; + CYTHON_UNUSED_VAR(context); + if (unlikely(!name)) name = Py_None; + Py_INCREF(name); + return name; +} +static int +__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(self->gi_qualname, value); + return 0; +} +#if !CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx__Coroutine_get_frame_locked(__pyx_CoroutineObject *self) { + PyObject *frame; + frame = self->gi_frame; + if (!frame) { + if (unlikely(!self->gi_code)) { + Py_RETURN_NONE; + } + PyObject *globals = PyDict_New(); + if (unlikely(!globals)) return NULL; + frame = (PyObject *) PyFrame_New( + PyThreadState_Get(), /*PyThreadState *tstate,*/ + (PyCodeObject*) self->gi_code, /*PyCodeObject *code,*/ + globals, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + Py_DECREF(globals); + if (unlikely(!frame)) + return NULL; + if (unlikely(self->gi_frame)) { + Py_DECREF(frame); + frame = self->gi_frame; + } else { + self->gi_frame = frame; + } + } + Py_INCREF(frame); + return frame; +} +#endif +static PyObject * +__Pyx__Coroutine_get_frame(__pyx_CoroutineObject *self) +{ +#if !CYTHON_COMPILING_IN_LIMITED_API + PyObject *frame; + __Pyx_BEGIN_CRITICAL_SECTION((PyObject*)self); + frame = __Pyx__Coroutine_get_frame_locked(self); + __Pyx_END_CRITICAL_SECTION(); + return frame; +#else + CYTHON_UNUSED_VAR(self); + Py_RETURN_NONE; +#endif +} +static PyObject * +__Pyx_Coroutine_get_frame(__pyx_CoroutineObject *self, void *context) { + CYTHON_UNUSED_VAR(context); + PyObject *frame = self->gi_frame; + if (frame) + return __Pyx_NewRef(frame); + return __Pyx__Coroutine_get_frame(self); +} +static __pyx_CoroutineObject *__Pyx__Coroutine_New( + PyTypeObject* type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name) { + __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type); + if (unlikely(!gen)) + return NULL; + return __Pyx__Coroutine_NewInit(gen, body, code, closure, name, qualname, module_name); +} +static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( + __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name) { + gen->body = body; + gen->closure = closure; + Py_XINCREF(closure); + gen->is_running = 0; + gen->resume_label = 0; + gen->classobj = NULL; + gen->yieldfrom = NULL; + gen->yieldfrom_am_send = NULL; + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_LIMITED_API + gen->gi_exc_state.exc_value = NULL; + #else + gen->gi_exc_state.exc_type = NULL; + gen->gi_exc_state.exc_value = NULL; + gen->gi_exc_state.exc_traceback = NULL; + #endif +#if CYTHON_USE_EXC_INFO_STACK + gen->gi_exc_state.previous_item = NULL; +#endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + gen->gi_weakreflist = NULL; +#endif + Py_XINCREF(qualname); + gen->gi_qualname = qualname; + Py_XINCREF(name); + gen->gi_name = name; + Py_XINCREF(module_name); + gen->gi_modulename = module_name; + Py_XINCREF(code); + gen->gi_code = code; + gen->gi_frame = NULL; +#if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE) + memset(gen->__pyx_pymonitoring_state, 0, sizeof(gen->__pyx_pymonitoring_state)); + gen->__pyx_pymonitoring_version = 0; +#endif + PyObject_GC_Track(gen); + return gen; +} +static char __Pyx_Coroutine_test_and_set_is_running(__pyx_CoroutineObject *gen) { + char result; + __Pyx_BEGIN_CRITICAL_SECTION((PyObject*)gen); + result = gen->is_running; + gen->is_running = 1; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static void __Pyx_Coroutine_unset_is_running(__pyx_CoroutineObject *gen) { + __Pyx_BEGIN_CRITICAL_SECTION((PyObject*)gen); + assert(gen->is_running); + gen->is_running = 0; + __Pyx_END_CRITICAL_SECTION(); +} +static char __Pyx_Coroutine_get_is_running(__pyx_CoroutineObject *gen) { + char result; + __Pyx_BEGIN_CRITICAL_SECTION((PyObject*)gen); + result = gen->is_running; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyObject *__Pyx_Coroutine_get_is_running_getter(PyObject *gen, void *closure) { + CYTHON_UNUSED_VAR(closure); + char result = __Pyx_Coroutine_get_is_running((__pyx_CoroutineObject*)gen); + if (result) Py_RETURN_TRUE; + else Py_RETURN_FALSE; +} +#if __PYX_HAS_PY_AM_SEND == 2 +static void __Pyx_SetBackportTypeAmSend(PyTypeObject *type, __Pyx_PyAsyncMethodsStruct *static_amsend_methods, __Pyx_pyiter_sendfunc am_send) { + Py_ssize_t ptr_offset = (char*)(type->tp_as_async) - (char*)type; + if (ptr_offset < 0 || ptr_offset > type->tp_basicsize) { + return; + } + memcpy((void*)static_amsend_methods, (void*)(type->tp_as_async), sizeof(*type->tp_as_async)); + static_amsend_methods->am_send = am_send; + type->tp_as_async = __Pyx_SlotTpAsAsync(static_amsend_methods); +} +#endif +static PyObject *__Pyx_Coroutine_fail_reduce_ex(PyObject *self, PyObject *arg) { + CYTHON_UNUSED_VAR(arg); + __Pyx_RaiseTypeErrorWithObjectType( + "cannot pickle '" __Pyx_FMT_TYPENAME "' object", self); + return NULL; +} + +/* Coroutine (used by CoroutineYieldFrom) */ +static void __Pyx_CoroutineAwait_dealloc(PyObject *self) { + PyObject_GC_UnTrack(self); + Py_CLEAR(((__pyx_CoroutineAwaitObject*)self)->coroutine); + __Pyx_PyHeapTypeObject_GC_Del(self); +} +static int __Pyx_CoroutineAwait_traverse(__pyx_CoroutineAwaitObject *self, visitproc visit, void *arg) { + { + int e = __Pyx_call_type_traverse((PyObject*)self, 1, visit, arg); + if (e) return e; + } + Py_VISIT(self->coroutine); + return 0; +} +static int __Pyx_CoroutineAwait_clear(__pyx_CoroutineAwaitObject *self) { + Py_CLEAR(self->coroutine); + return 0; +} +static PyObject *__Pyx_CoroutineAwait_Next(__pyx_CoroutineAwaitObject *self) { + return __Pyx_Generator_Next(self->coroutine); +} +static PyObject *__Pyx_CoroutineAwait_Send(__pyx_CoroutineAwaitObject *self, PyObject *value) { + return __Pyx_Coroutine_Send(self->coroutine, value); +} +#if __PYX_HAS_PY_AM_SEND +static __Pyx_PySendResult __Pyx_CoroutineAwait_AmSend(PyObject *self, PyObject *value, PyObject **retval) { + return __Pyx_Coroutine_AmSend(((__pyx_CoroutineAwaitObject*)self)->coroutine, value, retval); +} +#endif +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject *__Pyx_CoroutineAwait_Throw(__pyx_CoroutineAwaitObject *self, PyObject *args) { + return __Pyx_Coroutine_Throw(self->coroutine, args); +} +#else +static PyObject *__Pyx_CoroutineAwait_Throw(__pyx_CoroutineAwaitObject *self, PyObject *const *args, Py_ssize_t nargs) { + return __Pyx_Coroutine_Throw(self->coroutine, args, nargs); +} +#endif +static __Pyx_PySendResult __Pyx_CoroutineAwait_Close(__pyx_CoroutineAwaitObject *self) { + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_Close(self->coroutine, &retval); + Py_XDECREF(retval); + return result; +} +static PyObject *__Pyx_CoroutineAwait_Close_Method(__pyx_CoroutineAwaitObject *self, PyObject *arg) { + PyObject *retval = NULL; + __Pyx_PySendResult result; + CYTHON_UNUSED_VAR(arg); + result = __Pyx_Coroutine_Close(self->coroutine, &retval); + if (unlikely(result == PYGEN_ERROR)) + return NULL; + Py_XDECREF(retval); + Py_RETURN_NONE; +} +static PyObject *__Pyx_CoroutineAwait_self(PyObject *self) { + Py_INCREF(self); + return self; +} +#if !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_CoroutineAwait_no_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { + CYTHON_UNUSED_VAR(type); + CYTHON_UNUSED_VAR(args); + CYTHON_UNUSED_VAR(kwargs); + PyErr_SetString(PyExc_TypeError, "cannot instantiate type, use 'await coroutine' instead"); + return NULL; +} +#endif +static PyMethodDef __pyx_CoroutineAwait_methods[] = { + {"send", (PyCFunction) __Pyx_CoroutineAwait_Send, METH_O, + PyDoc_STR("send(arg) -> send 'arg' into coroutine,\nreturn next yielded value or raise StopIteration.")}, + {"throw", __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_CoroutineAwait_Throw), +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + METH_VARARGS, +#else + METH_FASTCALL, +#endif + PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in coroutine,\nreturn next yielded value or raise StopIteration.")}, + {"close", (PyCFunction) __Pyx_CoroutineAwait_Close_Method, METH_NOARGS, PyDoc_STR("close() -> raise GeneratorExit inside coroutine.")}, + {"__reduce_ex__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_O, 0}, + {"__reduce__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_NOARGS, 0}, + {0, 0, 0, 0} +}; +static PyType_Slot __pyx_CoroutineAwaitType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CoroutineAwait_dealloc}, + {Py_tp_traverse, (void *)__Pyx_CoroutineAwait_traverse}, + {Py_tp_clear, (void *)__Pyx_CoroutineAwait_clear}, +#if !CYTHON_COMPILING_IN_PYPY + {Py_tp_new, (void *)__Pyx_CoroutineAwait_no_new}, +#endif + {Py_tp_methods, (void *)__pyx_CoroutineAwait_methods}, + {Py_tp_iter, (void *)__Pyx_CoroutineAwait_self}, + {Py_tp_iternext, (void *)__Pyx_CoroutineAwait_Next}, +#if __PYX_HAS_PY_AM_SEND == 1 + {Py_am_send, (void *)__Pyx_CoroutineAwait_AmSend}, +#endif + {0, 0}, +}; +static PyType_Spec __pyx_CoroutineAwaitType_spec = { + __PYX_TYPE_MODULE_PREFIX "coroutine_wrapper", + sizeof(__pyx_CoroutineAwaitObject), + 0, + Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | __Pyx_TPFLAGS_HAVE_AM_SEND, + __pyx_CoroutineAwaitType_slots +}; +#if __PYX_HAS_PY_AM_SEND == 2 // backport +static __Pyx_PyAsyncMethodsStruct __pyx_CoroutineAwait_as_async; +#endif +static CYTHON_INLINE PyObject *__Pyx__Coroutine_await(PyObject *coroutine) { + __pyx_CoroutineAwaitObject *await = PyObject_GC_New(__pyx_CoroutineAwaitObject, __pyx_mstate_global->__pyx_CoroutineAwaitType); + if (unlikely(!await)) return NULL; + Py_INCREF(coroutine); + await->coroutine = coroutine; + PyObject_GC_Track(await); + return (PyObject*)await; +} +static PyObject *__Pyx_Coroutine_await(PyObject *coroutine) { + if (unlikely(!coroutine || !__Pyx_Coroutine_Check(coroutine))) { + PyErr_SetString(PyExc_TypeError, "invalid input, expected coroutine"); + return NULL; + } + return __Pyx__Coroutine_await(coroutine); +} +static PyMethodDef __pyx_Coroutine_methods[] = { + {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, + PyDoc_STR("send(arg) -> send 'arg' into coroutine,\nreturn next iterated value or raise StopIteration.")}, + {"throw", __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_Coroutine_Throw), +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + METH_VARARGS, +#else + METH_FASTCALL, +#endif + PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in coroutine,\nreturn next iterated value or raise StopIteration.")}, + {"close", (PyCFunction) __Pyx_Coroutine_Close_Method, METH_NOARGS, PyDoc_STR("close() -> raise GeneratorExit inside coroutine.")}, + {"__reduce_ex__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_O, 0}, + {"__reduce__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_NOARGS, 0}, + {0, 0, 0, 0} +}; +static PyMemberDef __pyx_Coroutine_memberlist[] = { + {"cr_await", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, + PyDoc_STR("object being awaited, or None")}, + {"cr_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL}, + {"__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0}, +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CoroutineObject, gi_weakreflist), READONLY, 0}, +#endif + {0, 0, 0, 0, 0} +}; +static PyGetSetDef __pyx_Coroutine_getsets[] = { + {"__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, + PyDoc_STR("name of the coroutine"), 0}, + {"__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, + PyDoc_STR("qualified name of the coroutine"), 0}, + {"cr_frame", (getter)__Pyx_Coroutine_get_frame, NULL, + PyDoc_STR("Frame of the coroutine"), 0}, + {"cr_running", __Pyx_Coroutine_get_is_running_getter, NULL, NULL, NULL}, + {0, 0, 0, 0, 0} +}; +static PyType_Slot __pyx_CoroutineType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_Coroutine_dealloc}, + {Py_am_await, (void *)&__Pyx_Coroutine_await}, + {Py_tp_traverse, (void *)__Pyx_Coroutine_traverse}, + {Py_tp_methods, (void *)__pyx_Coroutine_methods}, + {Py_tp_members, (void *)__pyx_Coroutine_memberlist}, + {Py_tp_getset, (void *)__pyx_Coroutine_getsets}, + {Py_tp_getattro, (void *) PyObject_GenericGetAttr}, +#if CYTHON_USE_TP_FINALIZE + {Py_tp_finalize, (void *)__Pyx_Coroutine_del}, +#endif +#if __PYX_HAS_PY_AM_SEND == 1 + {Py_am_send, (void *)__Pyx_Coroutine_AmSend}, +#endif + {0, 0}, +}; +static PyType_Spec __pyx_CoroutineType_spec = { + __PYX_TYPE_MODULE_PREFIX "coroutine", + sizeof(__pyx_CoroutineObject), + 0, +#if PY_VERSION_HEX >= 0x030C0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_TPFLAGS_MANAGED_WEAKREF | +#endif + Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | __Pyx_TPFLAGS_HAVE_AM_SEND, + __pyx_CoroutineType_slots +}; +#if __PYX_HAS_PY_AM_SEND == 2 +static __Pyx_PyAsyncMethodsStruct __pyx_Coroutine_as_async; +#endif +static int __pyx_Coroutine_init(PyObject *module) { + __pyx_mstatetype *mstate; + CYTHON_MAYBE_UNUSED_VAR(module); + mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_CoroutineType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CoroutineType_spec, NULL); + if (unlikely(!mstate->__pyx_CoroutineType)) + return -1; +#if __PYX_HAS_PY_AM_SEND == 2 + __Pyx_SetBackportTypeAmSend(mstate->__pyx_CoroutineType, &__pyx_Coroutine_as_async, &__Pyx_Coroutine_AmSend); +#endif +#ifdef __Pyx_IterableCoroutine_USED + if (unlikely(__pyx_IterableCoroutine_init(module) == -1)) + return -1; +#endif + mstate->__pyx_CoroutineAwaitType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CoroutineAwaitType_spec, NULL); + if (unlikely(!mstate->__pyx_CoroutineAwaitType)) + return -1; +#if __PYX_HAS_PY_AM_SEND == 2 + __Pyx_SetBackportTypeAmSend(mstate->__pyx_CoroutineAwaitType, &__pyx_CoroutineAwait_as_async, &__Pyx_CoroutineAwait_AmSend); +#endif + return 0; +} + +/* CoroutineSetYieldFrom (used by CoroutineYieldFrom) */ +static void +__Pyx_Coroutine_Set_Owned_Yield_From(__pyx_CoroutineObject *gen, PyObject *yf) { + assert (!gen->yieldfrom); +#if CYTHON_USE_AM_SEND + assert (!gen->yieldfrom_am_send); + #if PY_VERSION_HEX < 0x030A00F0 + if (__Pyx_PyType_HasFeature(Py_TYPE(yf), __Pyx_TPFLAGS_HAVE_AM_SEND)) + #endif + { + __Pyx_pyiter_sendfunc am_send; + #if __PYX_LIMITED_VERSION_HEX >= 0x030A0000 + am_send = __Pyx_PyObject_TryGetSubSlot(yf, tp_as_async, am_send, __Pyx_pyiter_sendfunc); + #else + __Pyx_PyAsyncMethodsStruct* tp_as_async = (__Pyx_PyAsyncMethodsStruct*) Py_TYPE(yf)->tp_as_async; + am_send = tp_as_async ? tp_as_async->am_send : NULL; + #endif + if (likely(am_send)) { + gen->yieldfrom_am_send = am_send; + } + } +#endif + gen->yieldfrom = yf; +} + +/* Coro_CheckExact (used by GetAwaitIter) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_PyCoro_CheckExact(PyObject *o) { + return (PyObject*)Py_TYPE(o) == __pyx_mstate_global->__Pyx_CachedCoroType; +} +#endif + +/* PyObjectGetMethod (used by GetAwaitIter) */ +#if !CYTHON_VECTORCALL +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { + PyObject *attr = __Pyx_PyObject_GetAttrStr(obj, name); +#if CYTHON_UNPACK_METHODS + if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { + PyObject *function = PyMethod_GET_FUNCTION(attr); + Py_INCREF(function); + Py_DECREF(attr); + *method = function; + return 1; + } +#endif + *method = attr; + return 0; +} +#endif + +/* GetAwaitIter (used by CoroutineYieldFrom) */ +static CYTHON_INLINE PyObject *__Pyx_Coroutine_GetAwaitableIter(PyObject *o) { +#ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_Check(o)) { + return __Pyx_NewRef(o); + } +#endif + return __Pyx__Coroutine_GetAwaitableIter(o); +} +static void __Pyx_Coroutine_AwaitableIterError(PyObject *source) { +#if (PY_VERSION_HEX < 0x030d0000 || defined(_PyErr_FormatFromCause)) && !CYTHON_COMPILING_IN_LIMITED_API + __Pyx_TypeName source_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(source)); + _PyErr_FormatFromCause(PyExc_TypeError, + "'async for' received an invalid object from __anext__: " __Pyx_FMT_TYPENAME, source_type_name); + __Pyx_DECREF_TypeName(source_type_name); +#else + PyObject *exc, *val, *val2, *tb; + assert(PyErr_Occurred()); + __Pyx_PyErr_FetchException(&exc, &val, &tb); +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + PyErr_NormalizeException(&exc, &val, &tb); + if (tb != NULL) { + PyException_SetTraceback(val, tb); + Py_DECREF(tb); + } + Py_DECREF(exc); +#endif + assert(!PyErr_Occurred()); + __Pyx_RaiseTypeErrorWithObjectType( + "'async for' received an invalid object from __anext__: " __Pyx_FMT_TYPENAME, source); + __Pyx_PyErr_FetchException(&exc, &val2, &tb); +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + PyErr_NormalizeException(&exc, &val2, &tb); +#endif + Py_INCREF(val); + PyException_SetCause(val2, val); + PyException_SetContext(val2, val); + __Pyx_PyErr_RestoreException(exc, val2, tb); +#endif +} +static PyObject *__Pyx__Coroutine_GetAwaitableIter(PyObject *obj) { + PyObject *res; + unaryfunc am_await; + am_await = __Pyx_PyObject_TryGetSubSlot(obj, tp_as_async, am_await, unaryfunc); + if (likely(am_await)) { + res = (*am_await)(obj); + } else +#if CYTHON_COMPILING_IN_CPYTHON && defined(CO_ITERABLE_COROUTINE) +#if PY_VERSION_HEX >= 0x030C00A6 + if (PyGen_CheckExact(obj) && (PyGen_GetCode((PyGenObject*)obj)->co_flags & CO_ITERABLE_COROUTINE)) +#else + if (PyGen_CheckExact(obj) && ((PyGenObject*)obj)->gi_code && ((PyCodeObject *)((PyGenObject*)obj)->gi_code)->co_flags & CO_ITERABLE_COROUTINE) +#endif + { + return __Pyx_NewRef(obj); + } else +#endif + { +#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || !CYTHON_COMPILING_IN_LIMITED_API) + PyObject *args[] = { obj }; + res = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_n_u_await, args, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); + if (unlikely(!res)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyObject *type, *value, *traceback; + __Pyx_PyErr_FetchException(&type, &value, &traceback); + int has_attr = PyObject_HasAttr(obj, __pyx_mstate_global->__pyx_n_u_await); + __Pyx_PyErr_RestoreException(type, value, traceback); + if (!has_attr) goto slot_error; + } + } +#else + PyObject *method = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, __pyx_mstate_global->__pyx_n_u_await, &method); + if (likely(is_method)) { + res = __Pyx_PyObject_CallOneArg(method, obj); + } else if (likely(method)) { + res = __Pyx_PyObject_CallNoArg(method); + } else + goto slot_error; + Py_DECREF(method); +#endif + } + if (unlikely(!res)) { + __Pyx_Coroutine_AwaitableIterError(obj); + goto bad; + } + if (unlikely(!PyIter_Check(res))) { + __Pyx_RaiseTypeErrorWithObjectType( + "__await__() returned non-iterator of type '" __Pyx_FMT_TYPENAME "'", res); + Py_CLEAR(res); + } else { + int is_coroutine = 0; + #ifdef __Pyx_Coroutine_USED + is_coroutine |= __Pyx_Coroutine_Check(res); + #endif + is_coroutine |= __Pyx_PyCoro_CheckExact(res); + if (unlikely(is_coroutine)) { + /* __await__ must return an *iterator*, not + a coroutine or another awaitable (see PEP 492) */ + PyErr_SetString(PyExc_TypeError, + "__await__() returned a coroutine"); + Py_CLEAR(res); + } + } + return res; +slot_error: + __Pyx_RaiseTypeErrorWithObjectType( + "object " __Pyx_FMT_TYPENAME " can't be used in 'await' expression", obj); +bad: + return NULL; +} + +/* CoroutineYieldFrom */ +static __Pyx_PySendResult __Pyx_Coroutine_Yield_From_Coroutine(__pyx_CoroutineObject *gen, PyObject *source, PyObject **retval) { + __Pyx_PySendResult result; + if (unlikely(((__pyx_CoroutineObject*)source)->yieldfrom)) { + PyErr_SetString( + PyExc_RuntimeError, + "coroutine is being awaited already"); + return PYGEN_ERROR; + } + result = __Pyx_Coroutine_AmSend(source, Py_None, retval); + if (result == PYGEN_NEXT) { + Py_INCREF(source); + __Pyx_Coroutine_Set_Owned_Yield_From(gen, source); + } + return result; +} +static __Pyx_PySendResult __Pyx_Coroutine_Yield_From_Generic(__pyx_CoroutineObject *gen, PyObject *source, PyObject **retval) { + __Pyx_PySendResult result; + PyObject *source_gen = NULL; + source_gen = __Pyx_Coroutine_GetAwaitableIter(source); + if (unlikely(!source_gen)) return PYGEN_ERROR; + if (__Pyx_Coroutine_Check(source_gen)) { + result = __Pyx_Coroutine_Yield_From_Coroutine(gen, source_gen, retval); + Py_DECREF(source_gen); + return result; + } + *retval = __Pyx_PyIter_Next_Plain(source_gen); + if (*retval) { + __Pyx_Coroutine_Set_Owned_Yield_From(gen, source_gen); + return PYGEN_NEXT; + } + result = __Pyx_Coroutine_status_from_result(retval); + Py_XDECREF(source_gen); + return result; +} +static CYTHON_INLINE __Pyx_PySendResult __Pyx_Coroutine_Yield_From(__pyx_CoroutineObject *gen, PyObject *source, PyObject **retval) { + if (__Pyx_Coroutine_Check(source)) { + return __Pyx_Coroutine_Yield_From_Coroutine(gen, source, retval); + } +#ifdef __Pyx_AsyncGen_USED + if (__pyx_PyAsyncGenASend_CheckExact(source)) { + *retval = __Pyx_async_gen_asend_iternext(source); + if (*retval) { + Py_INCREF(source); + __Pyx_Coroutine_Set_Owned_Yield_From(gen, source); + return PYGEN_NEXT; + } + return __Pyx_Coroutine_status_from_result(retval); + } +#endif + return __Pyx_Coroutine_Yield_From_Generic(gen, source, retval); +} + +/* GetException */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type = NULL, *local_value, *local_tb = NULL; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if PY_VERSION_HEX >= 0x030C0000 + local_value = tstate->current_exception; + tstate->current_exception = 0; + #else + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + #endif +#elif __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + local_value = PyErr_GetRaisedException(); +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); + } +#else + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } +#endif // __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + #if PY_VERSION_HEX >= 0x030B00a4 + tmp_value = exc_info->exc_value; + exc_info->exc_value = local_value; + tmp_type = NULL; + tmp_tb = NULL; + Py_XDECREF(local_type); + Py_XDECREF(local_tb); + #else + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + #endif + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#elif __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + PyErr_SetHandledException(local_value); + Py_XDECREF(local_value); + Py_XDECREF(local_type); + Py_XDECREF(local_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +#endif +} + +/* pep479 */ +static void __Pyx_Generator_Replace_StopIteration(int in_async_gen) { + PyObject *exc, *val, *tb, *cur_exc, *new_exc; + __Pyx_PyThreadState_declare + int is_async_stopiteration = 0; + CYTHON_MAYBE_UNUSED_VAR(in_async_gen); + __Pyx_PyThreadState_assign + cur_exc = __Pyx_PyErr_CurrentExceptionType(); + if (likely(!__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopIteration))) { + if (in_async_gen && unlikely(__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopAsyncIteration))) { + is_async_stopiteration = 1; + } else { + return; + } + } + __Pyx_GetException(&exc, &val, &tb); + Py_XDECREF(exc); + Py_XDECREF(tb); + new_exc = PyObject_CallFunction(PyExc_RuntimeError, "s", + is_async_stopiteration ? "async generator raised StopAsyncIteration" : + in_async_gen ? "async generator raised StopIteration" : + "generator raised StopIteration"); + if (!new_exc) { + Py_XDECREF(val); + return; + } + PyException_SetCause(new_exc, val); // steals ref to val + PyErr_SetObject(PyExc_RuntimeError, new_exc); + Py_DECREF(new_exc); +} + +/* DivInt[long] */ +static CYTHON_INLINE long __Pyx_div_long(long a, long b, int b_is_constant) { + long q = a / b; + long r = a - q*b; + long adapt_python = (b_is_constant ? + ((r != 0) & ((r < 0) ^ (b < 0))) : + ((r != 0) & ((r ^ b) < 0)) + ); + return q - adapt_python; +} + +/* GetAttr3 */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static PyObject *__Pyx_GetAttr3Default(PyObject *d) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + __Pyx_PyErr_Clear(); + Py_INCREF(d); + return d; +} +#endif +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { + PyObject *r; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int res = PyObject_GetOptionalAttr(o, n, &r); + return (res != 0) ? r : __Pyx_NewRef(d); +#else + #if CYTHON_USE_TYPE_SLOTS + if (likely(PyUnicode_Check(n))) { + r = __Pyx_PyObject_GetAttrStrNoError(o, n); + if (unlikely(!r) && likely(!PyErr_Occurred())) { + r = __Pyx_NewRef(d); + } + return r; + } + #endif + r = PyObject_GetAttr(o, n); + return (likely(r)) ? r : __Pyx_GetAttr3Default(d); +#endif +} + +/* RaiseErrorWithObjectType1 (used by RaiseUnexpectedTypeError) */ +static void __Pyx_RaiseErrorWithType1(PyObject* exc_type, const char* message, const char *arg, PyTypeObject *type_obj) { + __Pyx_TypeName type_name = __Pyx_PyType_GetFullyQualifiedName(type_obj); + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 + if (unlikely(!type_name)) return; + #endif + PyErr_Format(exc_type, message, arg, type_name); + __Pyx_DECREF_TypeName(type_name); +} + +/* RaiseUnexpectedTypeError */ +static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) { + __Pyx_RaiseTypeErrorWithObjectType1( + "Expected %.42s, got " __Pyx_FMT_TYPENAME, + expected, obj); + return 0; +} + +/* PyLongBinop */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_Fallback___Pyx_PyLong_FloorDivideObjC(PyObject *op1, PyObject *op2, int inplace) { + return (inplace ? PyNumber_InPlaceFloorDivide : PyNumber_FloorDivide)(op1, op2); +} +#if CYTHON_USE_PYLONG_INTERNALS +static PyObject* __Pyx_Unpacked___Pyx_PyLong_FloorDivideObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(inplace); + CYTHON_UNUSED_VAR(zerodivision_check); + const long b = intval; + long a; + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla; + if (unlikely(__Pyx_PyLong_IsZero(op1))) { + return __Pyx_NewRef(op1); + } + const int is_positive = __Pyx_PyLong_IsPos(op1); + const digit* digits = __Pyx_PyLong_Digits(op1); + const Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); + if (likely(size == 1)) { + a = (long) digits[0]; + if (!is_positive) a *= -1; + } else { + if (size == 2 && 8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if (!is_positive) a *= -1; + goto calculate_long; + } else if (size == 2 && 8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + if (!is_positive) lla *= -1; + goto calculate_long_long; + } else + if (size == 3 && 8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if (!is_positive) a *= -1; + goto calculate_long; + } else if (size == 3 && 8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + if (!is_positive) lla *= -1; + goto calculate_long_long; + } else + if (size == 4 && 8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if (!is_positive) a *= -1; + goto calculate_long; + } else if (size == 4 && 8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + if (!is_positive) lla *= -1; + goto calculate_long_long; + } else + {} + return PyLong_Type.tp_as_number->nb_floor_divide(op1, op2); + } + calculate_long: + { + long q, r; + q = a / b; + r = a - q*b; + q -= ((r != 0) & ((r ^ b) < 0)); + return PyLong_FromLong(q); + } + calculate_long_long: + { + PY_LONG_LONG q, r; + q = lla / llb; + r = lla - q*llb; + q -= ((r != 0) & ((r ^ llb) < 0)); + return PyLong_FromLongLong(q); + } + +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyLong_FloorDivideObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(intval); + CYTHON_UNUSED_VAR(zerodivision_check); + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + return __Pyx_Unpacked___Pyx_PyLong_FloorDivideObjC(op1, op2, intval, inplace, zerodivision_check); + } + #endif + return __Pyx_Fallback___Pyx_PyLong_FloorDivideObjC(op1, op2, inplace); +} +#endif + +/* PyObjectCompare */ +#ifndef __Pyx_DEFINED_PyObject_CompareIntIntBoolGt +#define __Pyx_DEFINED_PyObject_CompareIntIntBoolGt +static int __Pyx_PyObject_CompareIntIntBoolGt(PyObject *op1, PyObject *op2) { +#if CYTHON_USE_PYLONG_INTERNALS + Py_ssize_t cmp = __Pyx_PyLong_CompareSignAndSize(op1, op2); + if (cmp == 0) { + Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); + if (size > 0) { + const digit* digits1 = __Pyx_PyLong_Digits(op1); + const digit* digits2 = __Pyx_PyLong_Digits(op2); + if (size == 1) { + cmp = (Py_ssize_t) digits1[0] - (Py_ssize_t) digits2[0]; + } else if ((size == 2) && (8 * sizeof(Py_ssize_t) >= 2 * PyLong_SHIFT)) { + cmp = (Py_ssize_t) (((((size_t)digits1[1]) << PyLong_SHIFT) | (size_t)digits1[0])) - (Py_ssize_t) (((((size_t)digits2[1]) << PyLong_SHIFT) | (size_t)digits2[0])); + } else { + for (Py_ssize_t i=size-1; i >= 0 && !cmp; --i) { + cmp = (Py_ssize_t) digits1[i] - (Py_ssize_t) digits2[i]; + } + } + } + if (cmp == 0) goto __pyx_return_false; + if (__Pyx_PyLong_IsNeg(op1)) cmp = -cmp; + } + if (cmp < 0) goto __pyx_return_false; else goto __pyx_return_true; +#else + int overflow1, overflow2; + long long iop1 = PyLong_AsLongLongAndOverflow(op1, &overflow1); + long long iop2 = PyLong_AsLongLongAndOverflow(op2, &overflow2); + if (likely(!(overflow1 | overflow2))) { + if (iop1 > iop2) goto __pyx_return_true; else goto __pyx_return_false; + } else if (overflow1 != overflow2) { + if (overflow1 > overflow2) goto __pyx_return_true; else goto __pyx_return_false; + } else { + return __Pyx_PyObject_RichCompareBool(op1, op2, Py_GT); + } +#endif +__pyx_return_true: + return 1; +__pyx_return_false: + return 0; +} +#endif +static CYTHON_INLINE int __Pyx_PyObject_CompareBoolGt_int_int(PyObject *op1, PyObject *op2, int pyop) { + CYTHON_UNUSED_VAR(pyop); + if (unlikely(op1 == Py_None)) { + goto __pyx_richcmp; + } + if (unlikely(op2 == Py_None)) { + goto __pyx_richcmp; + } + if (op1 == op2) goto __pyx_return_false; + if (likely(op1 != Py_None)) { + if (op1 == op2) goto __pyx_return_false; + if (likely(op2 != Py_None)) { + return __Pyx_PyObject_CompareIntIntBoolGt(op1, op2); + } + goto __pyx_richcmp; + } + if ((0)) goto __pyx_richcmp; + if ((0)) goto __pyx_return_true; + if ((0)) goto __pyx_return_false; +__pyx_richcmp: + return __Pyx_PyObject_RichCompareBool(op1, op2, Py_GT); +__pyx_return_true: + return 1; +__pyx_return_false: + return 0; +} + +/* CIntToDigits (used by CIntToPyUnicode) */ +static const char DIGIT_PAIRS_10[2*10*10+1] = { + "00010203040506070809" + "10111213141516171819" + "20212223242526272829" + "30313233343536373839" + "40414243444546474849" + "50515253545556575859" + "60616263646566676869" + "70717273747576777879" + "80818283848586878889" + "90919293949596979899" +}; +static const char DIGIT_PAIRS_8[2*8*8+1] = { + "0001020304050607" + "1011121314151617" + "2021222324252627" + "3031323334353637" + "4041424344454647" + "5051525354555657" + "6061626364656667" + "7071727374757677" +}; +static const char DIGITS_HEX[2*16+1] = { + "0123456789abcdef" + "0123456789ABCDEF" +}; + +/* BuildPyUnicode (used by COrdinalToPyUnicode) */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength, + int prepend_sign, char padding_char) { + PyObject *uval; + Py_ssize_t uoffset = ulength - clength; +#if CYTHON_USE_UNICODE_INTERNALS + Py_ssize_t i; + void *udata; + uval = PyUnicode_New(ulength, 127); + if (unlikely(!uval)) return NULL; + udata = PyUnicode_DATA(uval); + if (uoffset > 0) { + i = 0; + if (prepend_sign) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); + i++; + } + for (; i < uoffset; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); + } + } + for (i=0; i < clength; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); + } +#else + { + PyObject *sign = NULL, *padding = NULL; + uval = NULL; + if (uoffset > 0) { + prepend_sign = !!prepend_sign; + if (uoffset > prepend_sign) { + padding = PyUnicode_FromOrdinal(padding_char); + if (likely(padding) && uoffset > prepend_sign + 1) { + PyObject *tmp = PySequence_Repeat(padding, uoffset - prepend_sign); + Py_DECREF(padding); + padding = tmp; + } + if (unlikely(!padding)) goto done_or_error; + } + if (prepend_sign) { + sign = PyUnicode_FromOrdinal('-'); + if (unlikely(!sign)) goto done_or_error; + } + } + uval = PyUnicode_DecodeASCII(chars, clength, NULL); + if (likely(uval) && padding) { + PyObject *tmp = PyUnicode_Concat(padding, uval); + Py_DECREF(uval); + uval = tmp; + } + if (likely(uval) && sign) { + PyObject *tmp = PyUnicode_Concat(sign, uval); + Py_DECREF(uval); + uval = tmp; + } +done_or_error: + Py_XDECREF(padding); + Py_XDECREF(sign); + } +#endif + return uval; +} + +/* COrdinalToPyUnicode (used by CIntToPyUnicode) */ +static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value) { + return value <= 1114111; +} +static PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t ulength, char padding_char) { + Py_ssize_t padding_length = ulength - 1; + if (likely((padding_length <= 250) && (value < 0xD800 || value > 0xDFFF))) { + char chars[256]; + if (value <= 255) { + memset(chars, padding_char, (size_t) padding_length); + chars[ulength-1] = (char) value; + return PyUnicode_DecodeLatin1(chars, ulength, NULL); + } + char *cpos = chars + sizeof(chars); + if (value < 0x800) { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xc0 | (value & 0x1f)); + } else if (value < 0x10000) { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xe0 | (value & 0x0f)); + } else { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xf0 | (value & 0x07)); + } + cpos -= padding_length; + memset(cpos, padding_char, (size_t) padding_length); + return PyUnicode_DecodeUTF8(cpos, chars + sizeof(chars) - cpos, NULL); + } + if (value <= 127 && CYTHON_USE_UNICODE_INTERNALS) { + const char chars[1] = {(char) value}; + return __Pyx_PyUnicode_BuildFromAscii(ulength, chars, 1, 0, padding_char); + } + { + PyObject *uchar, *padding_uchar, *padding, *result; + padding_uchar = PyUnicode_FromOrdinal(padding_char); + if (unlikely(!padding_uchar)) return NULL; + padding = PySequence_Repeat(padding_uchar, padding_length); + Py_DECREF(padding_uchar); + if (unlikely(!padding)) return NULL; + uchar = PyUnicode_FromOrdinal(value); + if (unlikely(!uchar)) { + Py_DECREF(padding); + return NULL; + } + result = PyUnicode_Concat(padding, uchar); + Py_DECREF(padding); + Py_DECREF(uchar); + return result; + } +} + +/* CIntToPyUnicode */ +static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!(is_unsigned || value == 0 || value > 0) || + !(sizeof(value) <= 2 || value & ~ (int) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) { + PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)"); + return NULL; + } + if (width <= 1) { + return PyUnicode_FromOrdinal((int) value); + } + return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char); +} +static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char) { + char digits[sizeof(int)*3+2]; + char *dpos, *end = digits + sizeof(int)*3+2; + const char *hex_digits = DIGITS_HEX; + Py_ssize_t length, ulength; + int prepend_sign, last_one_off; + int remaining; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (format_char == 'X') { + hex_digits += 16; + format_char = 'x'; + } + remaining = value; + last_one_off = 0; + dpos = end; + do { + int digit_pos; + switch (format_char) { + case 'o': + digit_pos = abs((int)(remaining % (8*8))); + remaining = (int) (remaining / (8*8)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); + last_one_off = (digit_pos < 8); + break; + case 'd': + digit_pos = abs((int)(remaining % (10*10))); + remaining = (int) (remaining / (10*10)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); + last_one_off = (digit_pos < 10); + break; + case 'x': + *(--dpos) = hex_digits[abs((int)(remaining % 16))]; + remaining = (int) (remaining / 16); + break; + default: + assert(0); + break; + } + } while (unlikely(remaining != 0)); + assert(!last_one_off || *dpos == '0'); + dpos += last_one_off; + length = end - dpos; + ulength = length; + prepend_sign = 0; + if (!is_unsigned && value <= neg_one) { + if (padding_char == ' ' || width <= length + 1) { + *(--dpos) = '-'; + ++length; + } else { + prepend_sign = 1; + } + ++ulength; + } + if (width > ulength) { + ulength = width; + } + if (ulength == 1) { + return PyUnicode_FromOrdinal(*dpos); + } + return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); +} + +/* PyObjectVectorcallKwds */ +#if CYTHON_VECTORCALL +CYTHON_UNUSED static int __Pyx_CheckVectorcallKwarg(PyObject *kwnames, Py_ssize_t i) { + PyObject *key = __Pyx_PyTuple_GET_ITEM(kwnames, i); +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!key)) return -1; +#endif + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return 0; +} +#else +CYTHON_UNUSED static PyObject *__Pyx_MakeKwargDict(PyObject **keys, PyObject **values, Py_ssize_t n) { + PyObject *out = PyDict_New(); + if (unlikely(!out)) return NULL; + for (Py_ssize_t i=0; i= 0x030A0000 +#ifndef __Pyx_DEFINED_BinopTypeError +#define __Pyx_DEFINED_BinopTypeError +static void __Pyx_BinopTypeError(PyObject *op1, PyObject *op2, const char* op, int inplace) { + char opname[4] = {op[0], op[1], 0, 0}; + if (inplace) { + opname[op[1] ? 2 : 1] = '='; + } + __Pyx_RaiseErrorWithObjectTypes1( + PyExc_TypeError, + "unsupported operand type(s) for %.3s: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", + opname, op1, op2); +} +#endif +#endif +#ifndef __Pyx_DEFINED_PyNumber_Add_xfloat_object +#define __Pyx_DEFINED_PyNumber_Add_xfloat_object +static PyObject* __Pyx_PyNumber_Add_xfloat_object(PyObject *op1, PyObject *op2, int inplace) { + if (PyLong_CheckExact(op2)) { + double int_op2; + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(op2)) { + Py_ssize_t compact_op2 = __Pyx_PyLong_CompactValue(op2); + if (compact_op2 == 0) return __Pyx_NewRef(op1); + int_op2 = (double) compact_op2; + } else + #endif + { + int_op2 = PyLong_AsDouble(op2); + if (unlikely((int_op2 == -1.) && PyErr_Occurred())) return NULL; + #if !CYTHON_USE_PYLONG_INTERNALS + if (int_op2 == 0.) return __Pyx_NewRef(op1); + #endif + } + double float_op1 = __Pyx_PyFloat_AS_DOUBLE(op1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((float_op1 == -1.) && PyErr_Occurred())) return NULL; + #endif + return PyFloat_FromDouble(float_op1 + int_op2); + } + if (PyLong_Check(op2)) { + binaryfunc slot_func = __Pyx_PyType_GetSubSlot(&PyFloat_Type, tp_as_number, nb_add, binaryfunc); + if (likely(slot_func)) { + return slot_func(op1, op2); + } + } + #if CYTHON_USE_TYPE_SLOTS || __PYX_LIMITED_VERSION_HEX >= 0x030A0000 + { + PyTypeObject *type_op2 = Py_TYPE(op2); + binaryfunc slot_func = __Pyx_PyType_GetSubSlot(type_op2, tp_as_number, nb_add, binaryfunc); + if (likely(slot_func)) { + PyObject *result = slot_func(op1, op2); + if (likely(result != Py_NotImplemented)) { + return result; + } + Py_DECREF(result); + } + __Pyx_BinopTypeError(op1, op2, "+", inplace); + return NULL; + } + #else + return (inplace) ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2); + #endif +} +#endif +#ifndef __Pyx_DEFINED_PyNumber_Add_xint_object +#define __Pyx_DEFINED_PyNumber_Add_xint_object +static PyObject* __Pyx_PyNumber_Add_xint_object(PyObject *op1, PyObject *op2, int inplace) { + if (PyFloat_CheckExact(op2)) { + double int_op1; + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(op1)) { + Py_ssize_t compact_op1 = __Pyx_PyLong_CompactValue(op1); + if (compact_op1 == 0) return __Pyx_NewRef(op2); + int_op1 = (double) compact_op1; + } else + #endif + { + int_op1 = PyLong_AsDouble(op1); + if (unlikely((int_op1 == -1.) && PyErr_Occurred())) return NULL; + #if !CYTHON_USE_PYLONG_INTERNALS + if (int_op1 == 0.) return __Pyx_NewRef(op2); + #endif + } + double float_op2 = __Pyx_PyFloat_AS_DOUBLE(op2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((float_op2 == -1.) && PyErr_Occurred())) return NULL; + #endif + return PyFloat_FromDouble(int_op1 + float_op2); + } + #if CYTHON_USE_TYPE_SLOTS || __PYX_LIMITED_VERSION_HEX >= 0x030A0000 + { + PyTypeObject *type_op2 = Py_TYPE(op2); + binaryfunc slot_func = __Pyx_PyType_GetSubSlot(type_op2, tp_as_number, nb_add, binaryfunc); + if (likely(slot_func)) { + PyObject *result = slot_func(op1, op2); + if (likely(result != Py_NotImplemented)) { + return result; + } + Py_DECREF(result); + } + __Pyx_BinopTypeError(op1, op2, "+", inplace); + return NULL; + } + #else + return (inplace) ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2); + #endif +} +#endif +static CYTHON_INLINE PyObject* __Pyx__PyNumber_Add_object_object(PyObject *op1, PyObject *op2, int inplace) { + if (PyFloat_CheckExact(op1)) { + if (PyFloat_CheckExact(op2)) { + double float_op2 = __Pyx_PyFloat_AS_DOUBLE(op2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((float_op2 == -1.) && PyErr_Occurred())) return NULL; + #endif + double float_op1 = __Pyx_PyFloat_AS_DOUBLE(op1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((float_op1 == -1.) && PyErr_Occurred())) return NULL; + #endif + return PyFloat_FromDouble(float_op1 + float_op2); + } + return __Pyx_PyNumber_Add_xfloat_object(op1, op2, inplace); + } + if (PyLong_CheckExact(op1)) { + if (PyLong_CheckExact(op2)) { + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(op1)) { + Py_ssize_t int_op1 = __Pyx_PyLong_CompactValue(op1); + if (int_op1 == 0) return __Pyx_NewRef(op2); + if (__Pyx_PyLong_IsCompact(op2)) { + Py_ssize_t int_op2 = __Pyx_PyLong_CompactValue(op2); + if (int_op2 == 0) return __Pyx_NewRef(op1); + return PyLong_FromSsize_t(int_op1 + int_op2); + } + } + else if (__Pyx_PyLong_IsZero(op2)) return __Pyx_NewRef(op1); + #endif + binaryfunc slot_func = __Pyx_PyType_GetSubSlot(&PyLong_Type, tp_as_number, nb_add, binaryfunc); + if (likely(slot_func)) { + return slot_func(op1, op2); + } + } + return __Pyx_PyNumber_Add_xint_object(op1, op2, inplace); + } + return (inplace) ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2); +} +#endif + +/* CIntToPyUnicode */ +static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_unsigned_int(unsigned int value, Py_ssize_t width, char padding_char) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!(is_unsigned || value == 0 || value > 0) || + !(sizeof(value) <= 2 || value & ~ (unsigned int) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) { + PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)"); + return NULL; + } + if (width <= 1) { + return PyUnicode_FromOrdinal((int) value); + } + return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char); +} +static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_unsigned_int(unsigned int value, Py_ssize_t width, char padding_char, char format_char) { + char digits[sizeof(unsigned int)*3+2]; + char *dpos, *end = digits + sizeof(unsigned int)*3+2; + const char *hex_digits = DIGITS_HEX; + Py_ssize_t length, ulength; + int prepend_sign, last_one_off; + unsigned int remaining; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (format_char == 'X') { + hex_digits += 16; + format_char = 'x'; + } + remaining = value; + last_one_off = 0; + dpos = end; + do { + int digit_pos; + switch (format_char) { + case 'o': + digit_pos = abs((int)(remaining % (8*8))); + remaining = (unsigned int) (remaining / (8*8)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); + last_one_off = (digit_pos < 8); + break; + case 'd': + digit_pos = abs((int)(remaining % (10*10))); + remaining = (unsigned int) (remaining / (10*10)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); + last_one_off = (digit_pos < 10); + break; + case 'x': + *(--dpos) = hex_digits[abs((int)(remaining % 16))]; + remaining = (unsigned int) (remaining / 16); + break; + default: + assert(0); + break; + } + } while (unlikely(remaining != 0)); + assert(!last_one_off || *dpos == '0'); + dpos += last_one_off; + length = end - dpos; + ulength = length; + prepend_sign = 0; + if (!is_unsigned && value <= neg_one) { + if (padding_char == ' ' || width <= length + 1) { + *(--dpos) = '-'; + ++length; + } else { + prepend_sign = 1; + } + ++ulength; + } + if (width > ulength) { + ulength = width; + } + if (ulength == 1) { + return PyUnicode_FromOrdinal(*dpos); + } + return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); +} + +/* decode_c_bytes (used by decode_bytes) */ +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)) { + if (unlikely((start < 0) | (stop < 0))) { + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + } + if (stop > length) + stop = length; + if (unlikely(stop <= start)) + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_unicode); + length = stop - start; + cstring += start; + if (decode_func) { + return decode_func(cstring, length, errors); + } else { + return PyUnicode_Decode(cstring, length, encoding, errors); + } +} + +/* SliceObject */ +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, CYTHON_UNUSED int wraparound) { +#if CYTHON_USE_TYPE_SLOTS + PyMappingMethods* mp = Py_TYPE(obj)->tp_as_mapping; + if (likely(mp && mp->mp_subscript)) +#else + if ((1)) +#endif + { + PyObject* result; + PyObject *py_slice, *py_start, *py_stop; + if (_py_slice) { + py_slice = *_py_slice; + } else { + PyObject* owned_start = NULL; + PyObject* owned_stop = NULL; + if (_py_start) { + py_start = *_py_start; + } else { + if (has_cstart) { + owned_start = py_start = PyLong_FromSsize_t(cstart); + if (unlikely(!py_start)) goto bad; + } else + py_start = Py_None; + } + if (_py_stop) { + py_stop = *_py_stop; + } else { + if (has_cstop) { + owned_stop = py_stop = PyLong_FromSsize_t(cstop); + if (unlikely(!py_stop)) { + Py_XDECREF(owned_start); + goto bad; + } + } else + py_stop = Py_None; + } + py_slice = PySlice_New(py_start, py_stop, Py_None); + Py_XDECREF(owned_start); + Py_XDECREF(owned_stop); + if (unlikely(!py_slice)) goto bad; + } +#if CYTHON_USE_TYPE_SLOTS + result = mp->mp_subscript(obj, py_slice); +#else + result = PyObject_GetItem(obj, py_slice); +#endif + if (!_py_slice) { + Py_DECREF(py_slice); + } + return result; + } else { + __Pyx_RaiseTypeErrorWithObjectType( + "'" __Pyx_FMT_TYPENAME "' object is unsliceable", obj); + } +bad: + return NULL; +} + +/* PyFrozenDict (used by GetItemInt) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE PyObject* __Pyx__PyFrozenDict_New(PyObject* frozendict_type, PyObject* it) { + return PyObject_CallFunctionObjArgs(frozendict_type, it, NULL); +} +#endif + +/* GettItemInt_wraparound (used by GetItemInt) */ +#if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY +static int __Pyx_GetItemInt_wraparound(PyObject *o, PySequenceMethods *sm, Py_ssize_t *i) { + assert(*i < 0); + if (likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); + if (likely(l >= 0)) { + *i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return -1; + PyErr_Clear(); + } + } + return 0; +} +#endif + +/* GetItemInt */ +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (unlikely(!j)) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static PyObject *__Pyx_GetItemInt_Generic_size(PyObject *o, Py_ssize_t i) { + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_AVOID_BORROWED_REFS + CYTHON_UNUSED_VAR(boundscheck); + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + Py_ssize_t size = __Pyx_PyList_GET_SIZE(o); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(size < 0)) return NULL; + #endif + wrapped_i += size; + } + return __Pyx_PyList_GetItemRef(o, wrapped_i); +#elif CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS + Py_ssize_t wrapped_i = i; + Py_ssize_t size = (wraparound | boundscheck) ? PyList_GET_SIZE(o) : -1; + if (wraparound & unlikely(i < 0)) { + wrapped_i += size; + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, size))) { + return __Pyx_PyList_GET_ITEM_REF(o, wrapped_i, unsafe_shared); + } + return __Pyx_GetItemInt_Generic_size(o, i); +#else + (void)wraparound; + (void)boundscheck; + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_AVOID_BORROWED_REFS + CYTHON_UNUSED_VAR(boundscheck); + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(o); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(size < 0)) return NULL; + #endif + wrapped_i += size; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_COMPILING_IN_LIMITED_API + return PySequence_ITEM(o, wrapped_i); + #else + if (unlikely(wrapped_i < 0)) { + PyErr_SetString(PyExc_IndexError, "tuple index out of range"); + return NULL; + } + return PySequence_GetItem(o, wrapped_i); + #endif +#elif CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS + Py_ssize_t wrapped_i = i; + Py_ssize_t size = (wraparound | boundscheck) ? PyTuple_GET_SIZE(o) : -1; + if (wraparound & unlikely(i < 0)) { + wrapped_i += size; + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, size))) { + return __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(o, wrapped_i)); + } + return __Pyx_GetItemInt_Generic_size(o, i); +#else + (void)wraparound; + (void)boundscheck; + return PySequence_GetItem(o, i); +#endif +} +#if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast_mapping(PyObject *o, binaryfunc getitem, Py_ssize_t i) { + PyObject *r, *key = PyLong_FromSsize_t(i); + if (unlikely(!key)) return NULL; + r = getitem(o, key); + Py_DECREF(key); + return r; +} +#endif +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_ASSUME_SAFE_SIZE + if (PyList_CheckExact(o)) { + return __Pyx_GetItemInt_List_Fast(o, i, wraparound, boundscheck, unsafe_shared); + } else + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (PyTuple_CheckExact(o)) { + return __Pyx_GetItemInt_Tuple_Fast(o, i, wraparound, boundscheck, unsafe_shared); + } else + #endif +#else + if ((!wraparound || i >= 0) & PyList_CheckExact(o)) { + return boundscheck ? __Pyx_PyList_GetItemRef(o, i) : __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared); + } else +#endif +#if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY + if (PyDict_CheckExact(o)) { + return __Pyx_GetItemInt_Fast_mapping(o, PyDict_Type.tp_as_mapping->mp_subscript, i); + #if defined(PyFrozenDict_CheckExact) + } else if (PyFrozenDict_CheckExact(o)) { + return __Pyx_GetItemInt_Fast_mapping(o, PyFrozenDict_Type.tp_as_mapping->mp_subscript, i); + #endif + } else + { + PyTypeObject *obj_type = Py_TYPE(o); + int seq_or_mapping = __Pyx_PyType_GetFlags(obj_type) & (Py_TPFLAGS_SEQUENCE|Py_TPFLAGS_MAPPING); + if (seq_or_mapping != Py_TPFLAGS_SEQUENCE) { + PyMappingMethods *mm = obj_type->tp_as_mapping; + if (mm && mm->mp_subscript) + return __Pyx_GetItemInt_Fast_mapping(o, mm->mp_subscript, i); + } + PySequenceMethods *sm = obj_type->tp_as_sequence; + if (likely(sm && sm->sq_item)) { + if (wraparound && (i < 0) && unlikely(__Pyx_GetItemInt_wraparound(o, sm, &i) == -1)) + return NULL; + return sm->sq_item(o, i); + } + if (seq_or_mapping == Py_TPFLAGS_SEQUENCE) { + PyMappingMethods *mm = obj_type->tp_as_mapping; + if (likely(mm && mm->mp_subscript)) + return __Pyx_GetItemInt_Fast_mapping(o, mm->mp_subscript, i); + } + } +#else + if (!PyMapping_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + (void)wraparound; + (void)boundscheck; + return __Pyx_GetItemInt_Generic_size(o, i); +} + +/* PyObjectCompare */ +#ifndef __Pyx_DEFINED_PyObject_CompareFloatIntBoolGt +#define __Pyx_DEFINED_PyObject_CompareFloatIntBoolGt +static int __Pyx_PyObject_CompareFloatIntBoolGt(PyObject *op1, PyObject *op2) { + double float_op1 = __Pyx_PyFloat_AS_DOUBLE(op1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(float_op1 == -1. && PyErr_Occurred())) return -1; + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(op2)) { + Py_ssize_t iop2 = __Pyx_PyLong_CompactValue(op2); + if (float_op1 > ((double)iop2)) goto __pyx_return_true; else goto __pyx_return_false; + } + if (unlikely(!isfinite(float_op1))) { + if (float_op1 > 0.0) goto __pyx_return_true; else goto __pyx_return_false; + } else { + int sign2 = __Pyx_PyLong_Sign(op2); + if (float_op1 >= 0.) { + if (sign2 < 0) goto __pyx_return_true; + if (float_op1 < (double) (1L << PyLong_SHIFT)) goto __pyx_return_false; + } else { + if (sign2 > 0) goto __pyx_return_false; + if (float_op1 > -(double) (1L << PyLong_SHIFT)) goto __pyx_return_true; + } + } + #else + if (unlikely(!isfinite(float_op1))) { + if (float_op1 > 0.0) goto __pyx_return_true; else goto __pyx_return_false; + } else { + int overflow2; + long iop2 = PyLong_AsLongAndOverflow(op2, &overflow2); + if (likely(!overflow2)) { + if ((long long) iop2 >= (1LL << 53)) { + overflow2 = 1; + } else if ((long long) iop2 <= - (1LL << 53)) { + overflow2 = -1; + } else { + if (float_op1 > ((double) iop2)) goto __pyx_return_true; else goto __pyx_return_false; + } + } + if (overflow2 > 0) { + if (float_op1 < ((double) (1LL << 53))) goto __pyx_return_false; + } else { + if (float_op1 > - ((double) (1LL << 53))) goto __pyx_return_true; + } + } + #endif + return __Pyx_PyObject_RichCompareBool(op1, op2, Py_GT); +__pyx_return_true: + return 1; +__pyx_return_false: + return 0; +} +#endif +#ifndef __Pyx_DEFINED_PyObject_CompareIntIntBoolGt +#define __Pyx_DEFINED_PyObject_CompareIntIntBoolGt +static int __Pyx_PyObject_CompareIntIntBoolGt(PyObject *op1, PyObject *op2) { +#if CYTHON_USE_PYLONG_INTERNALS + Py_ssize_t cmp = __Pyx_PyLong_CompareSignAndSize(op1, op2); + if (cmp == 0) { + Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); + if (size > 0) { + const digit* digits1 = __Pyx_PyLong_Digits(op1); + const digit* digits2 = __Pyx_PyLong_Digits(op2); + if (size == 1) { + cmp = (Py_ssize_t) digits1[0] - (Py_ssize_t) digits2[0]; + } else if ((size == 2) && (8 * sizeof(Py_ssize_t) >= 2 * PyLong_SHIFT)) { + cmp = (Py_ssize_t) (((((size_t)digits1[1]) << PyLong_SHIFT) | (size_t)digits1[0])) - (Py_ssize_t) (((((size_t)digits2[1]) << PyLong_SHIFT) | (size_t)digits2[0])); + } else { + for (Py_ssize_t i=size-1; i >= 0 && !cmp; --i) { + cmp = (Py_ssize_t) digits1[i] - (Py_ssize_t) digits2[i]; + } + } + } + if (cmp == 0) goto __pyx_return_false; + if (__Pyx_PyLong_IsNeg(op1)) cmp = -cmp; + } + if (cmp < 0) goto __pyx_return_false; else goto __pyx_return_true; +#else + int overflow1, overflow2; + long long iop1 = PyLong_AsLongLongAndOverflow(op1, &overflow1); + long long iop2 = PyLong_AsLongLongAndOverflow(op2, &overflow2); + if (likely(!(overflow1 | overflow2))) { + if (iop1 > iop2) goto __pyx_return_true; else goto __pyx_return_false; + } else if (overflow1 != overflow2) { + if (overflow1 > overflow2) goto __pyx_return_true; else goto __pyx_return_false; + } else { + return __Pyx_PyObject_RichCompareBool(op1, op2, Py_GT); + } +#endif +__pyx_return_true: + return 1; +__pyx_return_false: + return 0; +} +#endif +static CYTHON_INLINE int __Pyx_PyObject_CompareBoolGt_object_int(PyObject *op1, PyObject *op2, int pyop) { + CYTHON_UNUSED_VAR(pyop); + if (unlikely(op2 == Py_None)) { + goto __pyx_richcmp; + } + if (op1 == op2) goto __pyx_return_false; + if (PyFloat_CheckExact(op1)) { + if (likely(op2 != Py_None)) { + return __Pyx_PyObject_CompareFloatIntBoolGt(op1, op2); + } + goto __pyx_richcmp; + } + if (likely(PyLong_CheckExact(op1))) { + if (op1 == op2) goto __pyx_return_false; + if (likely(op2 != Py_None)) { + return __Pyx_PyObject_CompareIntIntBoolGt(op1, op2); + } + goto __pyx_richcmp; + } + if ((0)) goto __pyx_richcmp; + if ((0)) goto __pyx_return_true; + if ((0)) goto __pyx_return_false; +__pyx_richcmp: + return __Pyx_PyObject_RichCompareBool(op1, op2, Py_GT); +__pyx_return_true: + return 1; +__pyx_return_false: + return 0; +} + +/* PyObjectCompare */ +#ifndef __Pyx_DEFINED_PyObject_CompareFloatIntBoolLt +#define __Pyx_DEFINED_PyObject_CompareFloatIntBoolLt +static int __Pyx_PyObject_CompareFloatIntBoolLt(PyObject *op1, PyObject *op2) { + double float_op1 = __Pyx_PyFloat_AS_DOUBLE(op1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(float_op1 == -1. && PyErr_Occurred())) return -1; + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(op2)) { + Py_ssize_t iop2 = __Pyx_PyLong_CompactValue(op2); + if (float_op1 < ((double)iop2)) goto __pyx_return_true; else goto __pyx_return_false; + } + if (unlikely(!isfinite(float_op1))) { + if (float_op1 < 0.0) goto __pyx_return_true; else goto __pyx_return_false; + } else { + int sign2 = __Pyx_PyLong_Sign(op2); + if (float_op1 >= 0.) { + if (sign2 < 0) goto __pyx_return_false; + if (float_op1 < (double) (1L << PyLong_SHIFT)) goto __pyx_return_true; + } else { + if (sign2 > 0) goto __pyx_return_true; + if (float_op1 > -(double) (1L << PyLong_SHIFT)) goto __pyx_return_false; + } + } + #else + if (unlikely(!isfinite(float_op1))) { + if (float_op1 < 0.0) goto __pyx_return_true; else goto __pyx_return_false; + } else { + int overflow2; + long iop2 = PyLong_AsLongAndOverflow(op2, &overflow2); + if (likely(!overflow2)) { + if ((long long) iop2 >= (1LL << 53)) { + overflow2 = 1; + } else if ((long long) iop2 <= - (1LL << 53)) { + overflow2 = -1; + } else { + if (float_op1 < ((double) iop2)) goto __pyx_return_true; else goto __pyx_return_false; + } + } + if (overflow2 > 0) { + if (float_op1 < ((double) (1LL << 53))) goto __pyx_return_true; + } else { + if (float_op1 > - ((double) (1LL << 53))) goto __pyx_return_false; + } + } + #endif + return __Pyx_PyObject_RichCompareBool(op1, op2, Py_LT); +__pyx_return_true: + return 1; +__pyx_return_false: + return 0; +} +#endif +#ifndef __Pyx_DEFINED_PyObject_CompareIntIntBoolLt +#define __Pyx_DEFINED_PyObject_CompareIntIntBoolLt +static int __Pyx_PyObject_CompareIntIntBoolLt(PyObject *op1, PyObject *op2) { +#if CYTHON_USE_PYLONG_INTERNALS + Py_ssize_t cmp = __Pyx_PyLong_CompareSignAndSize(op1, op2); + if (cmp == 0) { + Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); + if (size > 0) { + const digit* digits1 = __Pyx_PyLong_Digits(op1); + const digit* digits2 = __Pyx_PyLong_Digits(op2); + if (size == 1) { + cmp = (Py_ssize_t) digits1[0] - (Py_ssize_t) digits2[0]; + } else if ((size == 2) && (8 * sizeof(Py_ssize_t) >= 2 * PyLong_SHIFT)) { + cmp = (Py_ssize_t) (((((size_t)digits1[1]) << PyLong_SHIFT) | (size_t)digits1[0])) - (Py_ssize_t) (((((size_t)digits2[1]) << PyLong_SHIFT) | (size_t)digits2[0])); + } else { + for (Py_ssize_t i=size-1; i >= 0 && !cmp; --i) { + cmp = (Py_ssize_t) digits1[i] - (Py_ssize_t) digits2[i]; + } + } + } + if (cmp == 0) goto __pyx_return_false; + if (__Pyx_PyLong_IsNeg(op1)) cmp = -cmp; + } + if (cmp < 0) goto __pyx_return_true; else goto __pyx_return_false; +#else + int overflow1, overflow2; + long long iop1 = PyLong_AsLongLongAndOverflow(op1, &overflow1); + long long iop2 = PyLong_AsLongLongAndOverflow(op2, &overflow2); + if (likely(!(overflow1 | overflow2))) { + if (iop1 < iop2) goto __pyx_return_true; else goto __pyx_return_false; + } else if (overflow1 != overflow2) { + if (overflow1 < overflow2) goto __pyx_return_true; else goto __pyx_return_false; + } else { + return __Pyx_PyObject_RichCompareBool(op1, op2, Py_LT); + } +#endif +__pyx_return_true: + return 1; +__pyx_return_false: + return 0; +} +#endif +static CYTHON_INLINE int __Pyx_PyObject_CompareBoolLt_object_int(PyObject *op1, PyObject *op2, int pyop) { + CYTHON_UNUSED_VAR(pyop); + if (unlikely(op2 == Py_None)) { + goto __pyx_richcmp; + } + if (op1 == op2) goto __pyx_return_false; + if (PyFloat_CheckExact(op1)) { + if (likely(op2 != Py_None)) { + return __Pyx_PyObject_CompareFloatIntBoolLt(op1, op2); + } + goto __pyx_richcmp; + } + if (likely(PyLong_CheckExact(op1))) { + if (op1 == op2) goto __pyx_return_false; + if (likely(op2 != Py_None)) { + return __Pyx_PyObject_CompareIntIntBoolLt(op1, op2); + } + goto __pyx_richcmp; + } + if ((0)) goto __pyx_richcmp; + if ((0)) goto __pyx_return_true; + if ((0)) goto __pyx_return_false; +__pyx_richcmp: + return __Pyx_PyObject_RichCompareBool(op1, op2, Py_LT); +__pyx_return_true: + return 1; +__pyx_return_false: + return 0; +} + +/* pyfrozenset_new (used by PySetContains) */ +static PyObject* __Pyx_PyFrozenSet_New(PyObject* it) { + PyObject* result; + if (PyFrozenSet_CheckExact(it)) { + Py_INCREF(it); + return it; + } + result = PyFrozenSet_New(it); + if (unlikely(!result)) { + return NULL; + } + if ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000) +#if CYTHON_COMPILING_IN_LIMITED_API + || likely(__Pyx_get_runtime_version() >= 0x030A0000) +#endif + ) + return result; + Py_ssize_t size = __Pyx_PySet_GET_SIZE(result); + if (likely(size > 0)) + return result; +#if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(size < 0)) { + Py_DECREF(result); + return NULL; + } +#endif + Py_DECREF(result); + return PyFrozenSet_New(NULL); +} + +/* PySetContains */ +static int __Pyx_PySet_ContainsUnhashable(PyObject *set, PyObject *key) { + int result = -1; + if (PySet_Check(key) && PyErr_ExceptionMatches(PyExc_TypeError)) { + PyObject *tmpkey; + PyErr_Clear(); + tmpkey = __Pyx_PyFrozenSet_New(key); + if (tmpkey != NULL) { + result = PySet_Contains(set, tmpkey); + Py_DECREF(tmpkey); + } + } + return result; +} +static CYTHON_INLINE int __Pyx_PySet_ContainsTF(PyObject* key, PyObject* set, int eq) { + int result = PySet_Contains(set, key); + if (unlikely(result < 0)) { + result = __Pyx_PySet_ContainsUnhashable(set, key); + } + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/* PyObjectFormatAndDecref */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) { + if (unlikely(!s)) return NULL; + if (likely(PyUnicode_CheckExact(s))) return s; + return __Pyx_PyObject_FormatAndDecref(s, f); +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f) { + PyObject *result; + if (unlikely(!s)) return NULL; + result = PyObject_Format(s, f); + Py_DECREF(s); + return result; +} + +/* JoinPyUnicode */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, int kind) { +#if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH && CYTHON_USE_UNICODE_INTERNALS + PyObject *result_uval; + int result_ukind, kind_shift; + Py_ssize_t i, char_pos; + void *result_udata; + static const Py_UCS4 max_char[5] = {0x7fU, 0xffU, 0xffffU, 0xffffU, 0x10ffffU}; + assert (kind >= 0); + if (kind > PyUnicode_4BYTE_KIND) kind = PyUnicode_4BYTE_KIND; + result_uval = PyUnicode_New(result_ulength, max_char[kind]); + if (unlikely(!result_uval)) return NULL; + kind_shift = kind >> 1; // 0, 1, 2 + result_ukind = 1 << kind_shift; // 1, 2, 4 + result_udata = PyUnicode_DATA(result_uval); + assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - result_ulength < 0)) + goto overflow; + char_pos = 0; + for (i=0; i < value_count; i++) { + int ukind; + Py_ssize_t ulength; + void *udata; + PyObject *uval = values[i]; + if (__Pyx_PyUnicode_READY(uval) == (-1)) + goto bad; + ulength = __Pyx_PyUnicode_GET_LENGTH(uval); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(ulength < 0)) goto bad; + #endif + if (unlikely(!ulength)) + continue; + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) + goto overflow; + ukind = __Pyx_PyUnicode_KIND(uval); + udata = __Pyx_PyUnicode_DATA(uval); + if (ukind == result_ukind) { + memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); + } else { + #if PY_VERSION_HEX >= 0x030d0000 + if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; + #elif CYTHON_COMPILING_IN_CPYTHON || defined(_PyUnicode_FastCopyCharacters) + _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); + #else + Py_ssize_t j; + for (j=0; j < ulength; j++) { + Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); + __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); + } + #endif + } + char_pos += ulength; + } + return result_uval; +overflow: + PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); +bad: + Py_DECREF(result_uval); + return NULL; +#else + Py_ssize_t i; + PyObject *result = NULL; + PyObject *value_tuple = PyTuple_New(value_count); + if (unlikely(!value_tuple)) return NULL; + CYTHON_UNUSED_VAR(kind); + CYTHON_UNUSED_VAR(result_ulength); + for (i=0; i__pyx_empty_unicode, value_tuple); +bad: + Py_DECREF(value_tuple); + return result; +#endif +} + +/* CIntToPyUnicode */ +static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_long(long value, Py_ssize_t width, char padding_char) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!(is_unsigned || value == 0 || value > 0) || + !(sizeof(value) <= 2 || value & ~ (long) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) { + PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)"); + return NULL; + } + if (width <= 1) { + return PyUnicode_FromOrdinal((int) value); + } + return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char); +} +static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_long(long value, Py_ssize_t width, char padding_char, char format_char) { + char digits[sizeof(long)*3+2]; + char *dpos, *end = digits + sizeof(long)*3+2; + const char *hex_digits = DIGITS_HEX; + Py_ssize_t length, ulength; + int prepend_sign, last_one_off; + long remaining; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (format_char == 'X') { + hex_digits += 16; + format_char = 'x'; + } + remaining = value; + last_one_off = 0; + dpos = end; + do { + int digit_pos; + switch (format_char) { + case 'o': + digit_pos = abs((int)(remaining % (8*8))); + remaining = (long) (remaining / (8*8)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); + last_one_off = (digit_pos < 8); + break; + case 'd': + digit_pos = abs((int)(remaining % (10*10))); + remaining = (long) (remaining / (10*10)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); + last_one_off = (digit_pos < 10); + break; + case 'x': + *(--dpos) = hex_digits[abs((int)(remaining % 16))]; + remaining = (long) (remaining / 16); + break; + default: + assert(0); + break; + } + } while (unlikely(remaining != 0)); + assert(!last_one_off || *dpos == '0'); + dpos += last_one_off; + length = end - dpos; + ulength = length; + prepend_sign = 0; + if (!is_unsigned && value <= neg_one) { + if (padding_char == ' ' || width <= length + 1) { + *(--dpos) = '-'; + ++length; + } else { + prepend_sign = 1; + } + ++ulength; + } + if (width > ulength) { + ulength = width; + } + if (ulength == 1) { + return PyUnicode_FromOrdinal(*dpos); + } + return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); +} + +/* PyNumberBinop */ +#if !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_GRAAL || CYTHON_COMPILING_IN_LIMITED_API) +#if CYTHON_USE_TYPE_SLOTS || __PYX_LIMITED_VERSION_HEX >= 0x030A0000 +#ifndef __Pyx_DEFINED_BinopTypeError +#define __Pyx_DEFINED_BinopTypeError +static void __Pyx_BinopTypeError(PyObject *op1, PyObject *op2, const char* op, int inplace) { + char opname[4] = {op[0], op[1], 0, 0}; + if (inplace) { + opname[op[1] ? 2 : 1] = '='; + } + __Pyx_RaiseErrorWithObjectTypes1( + PyExc_TypeError, + "unsupported operand type(s) for %.3s: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", + opname, op1, op2); +} +#endif +#endif +#ifndef __Pyx_DEFINED_PyNumber_Add_xint_int +#define __Pyx_DEFINED_PyNumber_Add_xint_int +static PyObject* __Pyx_PyNumber_Add_xint_int(PyObject *op1, PyObject *op2, int inplace) { + #if CYTHON_USE_TYPE_SLOTS || __PYX_LIMITED_VERSION_HEX >= 0x030A0000 + { + PyTypeObject *type_op2 = Py_TYPE(op2); + binaryfunc slot_func = __Pyx_PyType_GetSubSlot(type_op2, tp_as_number, nb_add, binaryfunc); + if (likely(slot_func)) { + PyObject *result = slot_func(op1, op2); + if (likely(result != Py_NotImplemented)) { + return result; + } + Py_DECREF(result); + } + __Pyx_BinopTypeError(op1, op2, "+", inplace); + return NULL; + } + #else + return (inplace) ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2); + #endif +} +#endif +static CYTHON_INLINE PyObject* __Pyx__PyNumber_Add_int_int(PyObject *op1, PyObject *op2, int inplace) { + if (likely(op1 != Py_None)) { + if (likely(op2 != Py_None)) { + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(op1)) { + Py_ssize_t int_op1 = __Pyx_PyLong_CompactValue(op1); + if (int_op1 == 0) return __Pyx_NewRef(op2); + if (__Pyx_PyLong_IsCompact(op2)) { + Py_ssize_t int_op2 = __Pyx_PyLong_CompactValue(op2); + if (int_op2 == 0) return __Pyx_NewRef(op1); + return PyLong_FromSsize_t(int_op1 + int_op2); + } + } + else if (__Pyx_PyLong_IsZero(op2)) return __Pyx_NewRef(op1); + #endif + binaryfunc slot_func = __Pyx_PyType_GetSubSlot(&PyLong_Type, tp_as_number, nb_add, binaryfunc); + if (likely(slot_func)) { + return slot_func(op1, op2); + } + } + return __Pyx_PyNumber_Add_xint_int(op1, op2, inplace); + } + return (inplace) ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2); +} +#endif + +/* CIntToPyUnicode */ +static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_unsigned_PY_LONG_LONG(unsigned PY_LONG_LONG value, Py_ssize_t width, char padding_char) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const unsigned PY_LONG_LONG neg_one = (unsigned PY_LONG_LONG) -1, const_zero = (unsigned PY_LONG_LONG) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!(is_unsigned || value == 0 || value > 0) || + !(sizeof(value) <= 2 || value & ~ (unsigned PY_LONG_LONG) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) { + PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)"); + return NULL; + } + if (width <= 1) { + return PyUnicode_FromOrdinal((int) value); + } + return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char); +} +static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_unsigned_PY_LONG_LONG(unsigned PY_LONG_LONG value, Py_ssize_t width, char padding_char, char format_char) { + char digits[sizeof(unsigned PY_LONG_LONG)*3+2]; + char *dpos, *end = digits + sizeof(unsigned PY_LONG_LONG)*3+2; + const char *hex_digits = DIGITS_HEX; + Py_ssize_t length, ulength; + int prepend_sign, last_one_off; + unsigned PY_LONG_LONG remaining; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const unsigned PY_LONG_LONG neg_one = (unsigned PY_LONG_LONG) -1, const_zero = (unsigned PY_LONG_LONG) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (format_char == 'X') { + hex_digits += 16; + format_char = 'x'; + } + remaining = value; + last_one_off = 0; + dpos = end; + do { + int digit_pos; + switch (format_char) { + case 'o': + digit_pos = abs((int)(remaining % (8*8))); + remaining = (unsigned PY_LONG_LONG) (remaining / (8*8)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); + last_one_off = (digit_pos < 8); + break; + case 'd': + digit_pos = abs((int)(remaining % (10*10))); + remaining = (unsigned PY_LONG_LONG) (remaining / (10*10)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); + last_one_off = (digit_pos < 10); + break; + case 'x': + *(--dpos) = hex_digits[abs((int)(remaining % 16))]; + remaining = (unsigned PY_LONG_LONG) (remaining / 16); + break; + default: + assert(0); + break; + } + } while (unlikely(remaining != 0)); + assert(!last_one_off || *dpos == '0'); + dpos += last_one_off; + length = end - dpos; + ulength = length; + prepend_sign = 0; + if (!is_unsigned && value <= neg_one) { + if (padding_char == ' ' || width <= length + 1) { + *(--dpos) = '-'; + ++length; + } else { + prepend_sign = 1; + } + ++ulength; + } + if (width > ulength) { + ulength = width; + } + if (ulength == 1) { + return PyUnicode_FromOrdinal(*dpos); + } + return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); +} + +/* ListAppendAndDecrefInternal (used by ListAppend) */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE +static CYTHON_INLINE void __Pyx__ListComp_AppendAndDecref(PyObject* list, Py_ssize_t len, PyObject* x) { + PyList_SET_ITEM(list, len, x); + Py_SET_SIZE(list, len + 1); +} +#endif + +/* ListAppend */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE +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); + __Pyx__ListComp_AppendAndDecref(list, len, x); + return 0; + } + return PyList_Append(list, x); +} +#endif + +/* StringJoin */ +static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values) { + (void) __Pyx_PyObject_CallMethod1; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030e0000 || defined(PyBytes_Join) + return PyBytes_Join(sep, values); +#elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyBytes_Join) + return _PyBytes_Join(sep, values); +#else + return __Pyx_PyObject_CallMethod1(sep, __pyx_mstate_global->__pyx_n_u_join, values); +#endif +} + +/* ExtTypeTest */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + __Pyx_RaiseTypeErrorWithTypes( + "Cannot convert " __Pyx_FMT_TYPENAME " to " __Pyx_FMT_TYPENAME, + Py_TYPE(obj), type); + return 0; +} + +/* AllocateExtensionType */ +static PyObject *__Pyx_AllocateExtensionType(PyTypeObject *t, int is_final) { + if (is_final || likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + allocfunc alloc_func = __Pyx_PyType_GetSlot(t, tp_alloc, allocfunc); + return alloc_func(t, 0); + } else { + newfunc tp_new = __Pyx_PyType_TryGetSlot(&PyBaseObject_Type, tp_new, newfunc); + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (!tp_new) { + PyObject *new_str = PyUnicode_FromString("__new__"); + if (likely(new_str)) { + PyObject *o = PyObject_CallMethodObjArgs((PyObject *)&PyBaseObject_Type, new_str, t, NULL); + Py_DECREF(new_str); + return o; + } else + return NULL; + } else + #endif + return tp_new(t, __pyx_mstate_global->__pyx_empty_tuple, 0); + } +} + +/* CallSlotAsVectorcallUnpackDict (used by CallSlotAsVectorcall) */ +static CYTHON_INLINE int __Pyx_CallSlotAsVectorcallUnpackDict(Py_ssize_t args_size, PyObject *keys_dict, PyObject **args, PyObject *kwnames) { + Py_ssize_t pos = 0, i = 0; + PyObject *key, *value; + while (PyDict_Next(keys_dict, &pos, &key, &value)) { + Py_INCREF(value); + args[args_size+i] = value; + Py_INCREF(key); + if (unlikely(__Pyx_PyTuple_SET_ITEM(kwnames, i, key) == -1)) { + return -1; + } + ++i; + } + return 0; +} + +/* CallSlotAsVectorcall */ +#if CYTHON_VECTORCALL_TPNEW +static PyObject * __Pyx_CallTpnewAsVectorcall(__Pyx_tpnewvectorcallfunc f, PyTypeObject* o, PyObject *a, PyObject *k) { + Py_ssize_t k_size = k ? __Pyx_PyDict_GET_SIZE(k) : 0; +#if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(k_size < 0)) return NULL; +#endif + Py_ssize_t a_size = __Pyx_PyTuple_GET_SIZE(a); +#if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(a_size < 0)) return NULL; +#endif +#if CYTHON_ASSUME_SAFE_MACROS + if (k_size == 0) { + return f(o, &PyTuple_GET_ITEM(a, 0), a_size, NULL); + } +#else + if (k_size == 0 && a_size == 0) { + return f(o, NULL, 0, NULL); + } +#endif + PyObject *stack_args[5]; + PyObject **args = stack_args; + Py_ssize_t maxnargs = PY_SSIZE_T_MAX / sizeof(PyObject*) - 1; + if (a_size > maxnargs - k_size) { + PyErr_NoMemory(); + return NULL; + } + Py_ssize_t total_size = a_size + k_size; + if (total_size > 5) { + args = (PyObject**)PyMem_Malloc(((size_t)total_size)*sizeof(PyObject*)); + if (unlikely(!args)) { + PyErr_NoMemory(); + return NULL; + } + } + PyObject * result = NULL; + PyObject *kwnames = NULL; + int unpack_dict_result; + Py_ssize_t i = 0; + for (; i < a_size; ++i) { + args[i] = __Pyx_PyTuple_GET_ITEM(a, i); +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!args[i])) goto cleanup; +#endif + } +#if !CYTHON_ASSUME_SAFE_MACROS + if (k) // There's a specific shortcut earlier for ASSUME_SAFE_MACROS with no keywords +#endif + { + kwnames = PyTuple_New(k_size); + if (unlikely(!kwnames)) goto cleanup; + __Pyx_BEGIN_CRITICAL_SECTION(k); + unpack_dict_result = __Pyx_CallSlotAsVectorcallUnpackDict(a_size, k, args, kwnames); + __Pyx_END_CRITICAL_SECTION(); + if (unlikely(unpack_dict_result == -1)) goto cleanup; + } + result = f(o, args, a_size, kwnames); + cleanup: + Py_XDECREF(kwnames); + for (i=a_size; i__pyx_empty_tuple); + } + result = tp_new(t, args_tuple, kwds_dict); + if (unlikely(!result)) { + goto end; + } + if (PyObject_TypeCheck(result, t)) { + initproc tp_init = __Pyx_PyObject_GetSlot(result, tp_init, initproc); + if (tp_init && unlikely(tp_init(result, args_tuple, kwds_dict) < 0)) { + Py_CLEAR(result); + } + } + end: + Py_XDECREF(args_tuple); + Py_XDECREF(kwds_dict); + return result; +} +#endif + +/* CallSlotAsVectorcall */ +#if CYTHON_VECTORCALL_TPNEW +static int __Pyx_CallTpinitAsVectorcall(__Pyx_tpinitvectorcallfunc f, PyObject* o, PyObject *a, PyObject *k) { + Py_ssize_t k_size = k ? __Pyx_PyDict_GET_SIZE(k) : 0; +#if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(k_size < 0)) return -1; +#endif + Py_ssize_t a_size = __Pyx_PyTuple_GET_SIZE(a); +#if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(a_size < 0)) return -1; +#endif +#if CYTHON_ASSUME_SAFE_MACROS + if (k_size == 0) { + return f(o, &PyTuple_GET_ITEM(a, 0), a_size, NULL); + } +#else + if (k_size == 0 && a_size == 0) { + return f(o, NULL, 0, NULL); + } +#endif + PyObject *stack_args[5]; + PyObject **args = stack_args; + Py_ssize_t maxnargs = PY_SSIZE_T_MAX / sizeof(PyObject*) - 1; + if (a_size > maxnargs - k_size) { + PyErr_NoMemory(); + return -1; + } + Py_ssize_t total_size = a_size + k_size; + if (total_size > 5) { + args = (PyObject**)PyMem_Malloc(((size_t)total_size)*sizeof(PyObject*)); + if (unlikely(!args)) { + PyErr_NoMemory(); + return -1; + } + } + int result = -1; + PyObject *kwnames = NULL; + int unpack_dict_result; + Py_ssize_t i = 0; + for (; i < a_size; ++i) { + args[i] = __Pyx_PyTuple_GET_ITEM(a, i); +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!args[i])) goto cleanup; +#endif + } +#if !CYTHON_ASSUME_SAFE_MACROS + if (k) // There's a specific shortcut earlier for ASSUME_SAFE_MACROS with no keywords +#endif + { + kwnames = PyTuple_New(k_size); + if (unlikely(!kwnames)) goto cleanup; + __Pyx_BEGIN_CRITICAL_SECTION(k); + unpack_dict_result = __Pyx_CallSlotAsVectorcallUnpackDict(a_size, k, args, kwnames); + __Pyx_END_CRITICAL_SECTION(); + if (unlikely(unpack_dict_result == -1)) goto cleanup; + } + result = f(o, args, a_size, kwnames); + cleanup: + Py_XDECREF(kwnames); + for (i=a_size; i__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_capi, &d) == -1) + return NULL; + if (!d) { + d = PyDict_New(); + if (!d) + goto bad; + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_pyx_capi, d) < 0) + goto bad; + } + return d; +bad: + Py_XDECREF(d); + return NULL; +} + +/* PyObjectCallMethod0 (used by PyType_Ready) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { +#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || !CYTHON_COMPILING_IN_LIMITED_API) + return PyObject_VectorcallMethod(method_name, &obj, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#elif CYTHON_COMPILING_IN_LIMITED_API + return PyObject_CallMethodObjArgs(obj, method_name, NULL); +#else + return PyObject_CallMethodNoArgs(obj, method_name); +#endif +} + +/* GetTypeDictOffset (used by ValidateBasesTuple) */ +#if !CYTHON_USE_TYPE_SLOTS +CYTHON_UNUSED static Py_ssize_t __Pyx_GetTypeDictOffset(PyObject *tp, int require_cython_valid_result) { + PyObject *tp_dictoffset_o; + Py_ssize_t tp_dictoffset; + tp_dictoffset_o = PyObject_GetAttrString(tp, "__dictoffset__"); + if (unlikely(!tp_dictoffset_o)) return -1; + tp_dictoffset = PyLong_AsSsize_t(tp_dictoffset_o); + Py_DECREF(tp_dictoffset_o); + if (unlikely(require_cython_valid_result && tp_dictoffset == 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' doesn't have a dictoffset"); + return -1; + } else if (unlikely(require_cython_valid_result && tp_dictoffset < 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' has an unexpected negative dictoffset. " + "Please report this as Cython bug"); + return -1; + } + return tp_dictoffset; +} +#endif + +/* ValidateBasesTuple (used by PyType_Ready) */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, int has_dictoffset, PyObject *bases) { + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_SIZE + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (unlikely(n < 0)) return -1; +#endif + if (!has_dictoffset) { + PyObject *b; +#if CYTHON_AVOID_BORROWED_REFS + b = PySequence_GetItem(bases, 0); + if (!b) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + b = PyTuple_GET_ITEM(bases, 0); +#else + b = PyTuple_GetItem(bases, 0); + if (!b) return -1; +#endif +#if CYTHON_USE_TYPE_SLOTS + has_dictoffset = ((PyTypeObject*)b)->tp_dictoffset != 0; +#else + Py_ssize_t dictoffset = __Pyx_GetTypeDictOffset(b, 0); + has_dictoffset = dictoffset != 0; +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b); +#endif +#if !CYTHON_USE_TYPE_SLOTS + if (dictoffset == -1 && PyErr_Occurred()) return -1; +#endif + } + for (i = 1; i < n; i++) + { + PyTypeObject *b; +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_RaiseErrorWithType( + PyExc_TypeError, "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + if (!has_dictoffset) + { + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS + b_dictoffset = b->tp_dictoffset; +#else + b_dictoffset = __Pyx_GetTypeDictOffset((PyObject*)b, 0); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + __Pyx_RaiseErrorWithType1( + PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b); +#if !CYTHON_USE_TYPE_SLOTS + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + } + return 0; +} +#endif + +/* PyType_Ready */ +CYTHON_UNUSED static int __Pyx_PyType_HasMultipleInheritance(PyTypeObject *t) { + while (t) { + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases) { + return 1; + } + t = __Pyx_PyType_GetSlot(t, tp_base, PyTypeObject*); + } + return 0; +} +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !CYTHON_COMPILING_IN_CPYTHON + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; +#endif + return PyType_Ready(t); +#else + int r; + if (!__Pyx_PyType_HasMultipleInheritance(t)) { + return PyType_Ready(t); + } + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset != 0, bases) == -1)) + return -1; + { + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) &&\ + !CYTHON_COMPILING_IN_GRAAL + gc = PyImport_GetModule(__pyx_mstate_global->__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_mstate_global->__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; + } + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; + } + #endif + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; +#endif + r = PyType_Ready(t); + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } + } + Py_DECREF(gc); + #endif + } + return r; +#endif +} + +/* GetVTable (used by MergeVTables) */ +static int __Pyx_GetVtable(PyTypeObject *type, void** table) { + void* ptr; + *table = NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_mstate_global->__pyx_n_u_pyx_vtable); +#else + PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_mstate_global->__pyx_n_u_pyx_vtable); +#endif + if (!ob) + goto no_attr; + ptr = PyCapsule_GetPointer(ob, 0); + if (!ptr && !PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); + Py_DECREF(ob); + *table = ptr; + return 1; +no_attr: + if (PyErr_ExceptionMatches(CYTHON_COMPILING_IN_LIMITED_API ? PyExc_AttributeError : PyExc_KeyError)) { + return 0; + } + Py_XDECREF(ob); + return -1; +} + +/* MergeVTables (used by SetVTable) */ +static int __Pyx_MergeVtables(PyTypeObject *type) { + int i=0; + Py_ssize_t size; + void** base_vtables; + void* unknown = (void*)-1; + PyObject* bases = __Pyx_PyType_GetSlot(type, tp_bases, PyObject*); + int base_depth = 0; + { + PyTypeObject* base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + while (base) { + base_depth += 1; + base = __Pyx_PyType_TryGetSlot(base, tp_base, PyTypeObject*); + } + } + base_vtables = (void**) PyMem_Malloc(sizeof(void*) * (size_t)(base_depth + 1)); + if (unlikely(!base_vtables)) { + PyErr_NoMemory(); + return -1; + } + base_vtables[0] = unknown; +#if CYTHON_COMPILING_IN_LIMITED_API + size = PyTuple_Size(bases); + if (size < 0) goto other_failure; +#else + size = PyTuple_GET_SIZE(bases); +#endif + for (i = 1; i < size; i++) { + PyObject *basei; + void* base_vtable; +#if CYTHON_AVOID_BORROWED_REFS + basei = PySequence_GetItem(bases, i); + if (unlikely(!basei)) goto other_failure; +#elif !CYTHON_ASSUME_SAFE_MACROS + basei = PyTuple_GetItem(bases, i); + if (unlikely(!basei)) goto other_failure; +#else + basei = PyTuple_GET_ITEM(bases, i); +#endif + int get_vtable_result = __Pyx_GetVtable((PyTypeObject*)basei, &base_vtable); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(basei); +#endif + if (get_vtable_result != 1) { + if (get_vtable_result == -1) { + goto other_failure; + } + PyErr_Clear(); // Class doesn't have a vtable. + } else { + assert(base_vtable != NULL); + int j; + PyTypeObject* base = __Pyx_PyType_TryGetSlot(type, tp_base, PyTypeObject*); +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (!base) goto bad; +#endif + for (j = 0; j < base_depth; j++) { + if (base_vtables[j] == unknown) { + switch (__Pyx_GetVtable(base, &base_vtables[j])) { + case 1: + assert(base_vtables[j] == NULL); + break; + case 0: + goto bad; + case -1: + default: + goto other_failure; + } + base_vtables[j + 1] = unknown; + } + if (base_vtables[j] == base_vtable) { + break; + } + base = __Pyx_PyType_TryGetSlot(base, tp_base, PyTypeObject*); +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (!base) goto bad; +#endif + } + } + } + PyMem_Free(base_vtables); + return 0; +bad: + { + PyTypeObject* tp_base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + PyTypeObject* basei; +#if CYTHON_AVOID_BORROWED_REFS + basei = (PyTypeObject*)PySequence_GetItem(bases, i); + if (unlikely(!basei)) goto other_failure; +#elif !CYTHON_ASSUME_SAFE_MACROS + basei = (PyTypeObject*)PyTuple_GetItem(bases, i); + if (unlikely(!basei)) goto other_failure; +#else + basei = (PyTypeObject*)PyTuple_GET_ITEM(bases, i); +#endif + __Pyx_RaiseTypeErrorWithTypes( + "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base, basei); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(basei); +#endif + } +other_failure: + PyMem_Free(base_vtables); + return -1; +} + +/* SetVTable */ +static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { + PyObject *ob = PyCapsule_New(vtable, 0, 0); + if (unlikely(!ob)) + goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_mstate_global->__pyx_n_u_pyx_vtable, ob) < 0)) +#else + if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_mstate_global->__pyx_n_u_pyx_vtable, ob) < 0)) +#endif + goto bad; + Py_DECREF(ob); + return __Pyx_MergeVtables(type); +bad: + Py_XDECREF(ob); + return -1; +} + +/* LimitedApiGetTypeTypeDict (used by DelItemOnTypeDict) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_GetTypeTypeDict(PyTypeObject *tp) { + static Py_ssize_t tp_dictoffset = 0; + if (unlikely(tp_dictoffset == 0)) { + tp_dictoffset = __Pyx_GetTypeDictOffset((PyObject*)(&PyType_Type), 1); + if (unlikely(tp_dictoffset == -1 && PyErr_Occurred())) { + tp_dictoffset = 0; // try again next time? + return NULL; + } + } + return *(PyObject**)((char*)tp + tp_dictoffset); +} +#endif + +/* DelItemOnTypeDict (used by SetupReduce) */ +static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k) { + int result; + PyObject *tp_dict; +#if CYTHON_COMPILING_IN_LIMITED_API + tp_dict = __Pyx_GetTypeTypeDict(tp); + if (unlikely(!tp_dict)) return -1; +#else + tp_dict = tp->tp_dict; +#endif + result = PyDict_DelItem(tp_dict, k); + if (likely(!result)) PyType_Modified(tp); + return result; +} + +/* SetItemOnTypeDict (used by SetupReduce) */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v) { + int result; + PyObject *tp_dict; +#if CYTHON_COMPILING_IN_LIMITED_API + tp_dict = __Pyx_GetTypeTypeDict(tp); + if (unlikely(!tp_dict)) return -1; +#else + tp_dict = tp->tp_dict; +#endif + result = PyDict_SetItem(tp_dict, k, v); + if (likely(!result)) { + PyType_Modified(tp); + if (unlikely(PyObject_HasAttr(v, __pyx_mstate_global->__pyx_n_u_set_name))) { + PyObject *setNameResult = PyObject_CallMethodObjArgs(v, __pyx_mstate_global->__pyx_n_u_set_name, (PyObject *) tp, k, NULL); + if (!setNameResult) return -1; + Py_DECREF(setNameResult); + } + } + return result; +} + +/* SetupReduce */ +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_mstate_global->__pyx_n_u_name); + if (likely(name_attr)) { + ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); + } else { + ret = -1; + } + if (unlikely(ret < 0) && __Pyx_IgnoreException(PyExc_Exception)) { + ret = 0; // But BaseException is still propagated. + } + Py_XDECREF(name_attr); + return ret; +} +static PyObject *__Pyx_setup_reduce_get_reduce_attribute(PyObject *type_obj, PyObject *name, int allow_not_present) { +#if CYTHON_USE_PYTYPE_LOOKUP + CYTHON_UNUSED_VAR(allow_not_present); + return _PyType_Lookup((PyTypeObject*)type_obj, name); +#else + if (allow_not_present) { + return __Pyx_PyObject_GetAttrStrNoError(type_obj, name); + } else { + return __Pyx_PyObject_GetAttrStr(type_obj, name); + } +#endif +} +static int __Pyx_setup_reduce(PyObject* type_obj) { + int ret = 0; + PyObject *object_reduce = NULL; + PyObject *object_getstate = NULL; + PyObject *object_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; + PyObject *getstate = NULL; + getstate = __Pyx_setup_reduce_get_reduce_attribute(type_obj, __pyx_mstate_global->__pyx_n_u_getstate, 1); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } + if (getstate) { + object_getstate = __Pyx_setup_reduce_get_reduce_attribute((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_getstate, 1); + if (!object_getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } + if (object_getstate != getstate) { + goto __PYX_GOOD; + } + } + object_reduce_ex = __Pyx_setup_reduce_get_reduce_attribute((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce_ex, 0); + if (unlikely(!object_reduce_ex)) goto __PYX_BAD; + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; + if (reduce_ex == object_reduce_ex) { + object_reduce = __Pyx_setup_reduce_get_reduce_attribute((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce, 0); + if (!object_reduce) goto __PYX_BAD; + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + int try_to_replace_reduce = (reduce == object_reduce); + if (!try_to_replace_reduce) { + try_to_replace_reduce = __Pyx_setup_reduce_is_named(reduce, __pyx_mstate_global->__pyx_n_u_reduce_cython); + if (unlikely(try_to_replace_reduce < 0)) { + goto __PYX_BAD; + } + } + if (try_to_replace_reduce) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); + if (likely(reduce_cython)) { + ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (reduce == object_reduce || PyErr_Occurred()) { + goto __PYX_BAD; + } + setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate); + int try_to_replace_setstate; + if (!setstate) { + PyObject *exc = PyErr_Occurred(); + if (exc && !__Pyx_IgnoreGivenException(exc, PyExc_Exception)) { + goto __PYX_BAD; + } + try_to_replace_setstate = 1; + } else { + try_to_replace_setstate = __Pyx_setup_reduce_is_named(setstate, __pyx_mstate_global->__pyx_n_u_setstate_cython); + if (unlikely(try_to_replace_setstate < 0)) { + goto __PYX_BAD; + } + } + if (try_to_replace_setstate) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython); + if (likely(setstate_cython)) { + ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (!setstate || PyErr_Occurred()) { + goto __PYX_BAD; + } + } + PyType_Modified((PyTypeObject*)type_obj); + } + } + goto __PYX_GOOD; +__PYX_BAD: + if (!PyErr_Occurred()) { + __Pyx_RaiseErrorWithType( + PyExc_RuntimeError, + "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, + (PyTypeObject*)type_obj); + } + ret = -1; +__PYX_GOOD: +#if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); + Py_XDECREF(object_getstate); + Py_XDECREF(getstate); +#endif + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; +} + +/* PxdImportShared (used by FunctionImport) */ +#ifndef __PYX_HAVE_RT_ImportFromPxd_3_3_0 +#define __PYX_HAVE_RT_ImportFromPxd_3_3_0 +static int __Pyx_ImportFromPxd_3_3_0(PyObject *module, const char *name, void **p, const char *sig, const char *what, int optional) { + PyObject *d = 0; + PyObject *cobj = 0; + d = PyObject_GetAttrString(module, "__pyx_capi__"); + if (!d) + goto bad; +#if (defined(Py_LIMITED_API) && Py_LIMITED_API >= 0x030d0000) || (!defined(Py_LIMITED_API) && PY_VERSION_HEX >= 0x030d0000) + PyDict_GetItemStringRef(d, name, &cobj); +#else + cobj = PyDict_GetItemString(d, name); + Py_XINCREF(cobj); +#endif + if (!cobj) { + if (optional && !PyErr_Occurred()) { + PyErr_Clear(); + *p = NULL; + goto allowed_failure; + } else { + PyErr_Format(PyExc_ImportError, + "%.200s does not export expected C %.8s %.200s", + PyModule_GetName(module), what, name); + goto bad; + } + } + if (!PyCapsule_IsValid(cobj, sig)) { + PyErr_Format(PyExc_TypeError, + "C %.8s %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", + what, PyModule_GetName(module), name, sig, PyCapsule_GetName(cobj)); + goto bad; + } + *p = PyCapsule_GetPointer(cobj, sig); + if (!(*p)) + goto bad; + Py_DECREF(cobj); +allowed_failure: + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(d); + Py_XDECREF(cobj); + return -1; +} +#endif + +/* FunctionImport */ +#ifndef __PYX_HAVE_RT_ImportFunction_3_3_0 +#define __PYX_HAVE_RT_ImportFunction_3_3_0 +static int __Pyx_ImportFunction_3_3_0(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { + if (*f) { + return 0; // already imported under a different name + } + union { + void (*fp)(void); + void *p; + } tmp; + int result = __Pyx_ImportFromPxd_3_3_0(module, funcname, &tmp.p, sig, "function", 0); + if (result == 0) { + *f = tmp.fp; + } + return result; +} +#endif + +/* HasAttr (used by ImportImpl) */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { + PyObject *r; + if (unlikely(!PyUnicode_Check(n))) { + PyErr_SetString(PyExc_TypeError, + "hasattr(): attribute name must be string"); + return -1; + } + r = __Pyx_PyObject_GetAttrStrNoError(o, n); + if (!r) { + return (unlikely(PyErr_Occurred())) ? -1 : 0; + } else { + Py_DECREF(r); + return 1; + } +} +#endif + +/* TupleOrListFromArrayImpl (used by ListFromArray) */ +CYTHON_UNUSED static PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) { + PyObject *res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + #if CYTHON_COMPILING_IN_CPYTHON + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + #else + Py_ssize_t i; + for (i = 0; i < n; i++) { + Py_INCREF(src[i]); + if (unlikely(__Pyx_PyList_SET_ITEM(res, i, src[i]) < (0))) { + Py_DECREF(res); + return NULL; + } + } + #endif + return res; +} + +/* ImportImpl (used by Import) */ +static int __Pyx__Import_GetModule(PyObject *qualname, PyObject **module) { + PyObject *imported_module = PyImport_GetModule(qualname); + if (unlikely(!imported_module)) { + *module = NULL; + if (PyErr_Occurred()) { + return -1; + } + return 0; + } + *module = imported_module; + return 1; +} +static int __Pyx__Import_Lookup(PyObject *qualname, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject **module) { + PyObject *imported_module; + PyObject *top_level_package_name; + Py_ssize_t i; + int status, module_found; + Py_ssize_t dot_index; + module_found = __Pyx__Import_GetModule(qualname, &imported_module); + if (unlikely(!module_found || module_found == -1)) { + *module = NULL; + return module_found; + } + if (imported_names) { + for (i = 0; i < len_imported_names; i++) { + PyObject *imported_name = imported_names[i]; +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 + int has_imported_attribute = PyObject_HasAttr(imported_module, imported_name); +#else + int has_imported_attribute = PyObject_HasAttrWithError(imported_module, imported_name); + if (unlikely(has_imported_attribute == -1)) goto error; +#endif + if (!has_imported_attribute) { + goto not_found; + } + } + *module = imported_module; + return 1; + } + dot_index = PyUnicode_FindChar(qualname, '.', 0, PY_SSIZE_T_MAX, 1); + if (dot_index == -1) { + *module = imported_module; + return 1; + } + if (unlikely(dot_index == -2)) goto error; + top_level_package_name = PyUnicode_Substring(qualname, 0, dot_index); + if (unlikely(!top_level_package_name)) goto error; + Py_DECREF(imported_module); + status = __Pyx__Import_GetModule(top_level_package_name, module); + Py_DECREF(top_level_package_name); + return status; +error: + Py_DECREF(imported_module); + *module = NULL; + return -1; +not_found: + Py_DECREF(imported_module); + *module = NULL; + return 0; +} +static PyObject *__Pyx__Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, PyObject *moddict, int level) { + PyObject *module = 0; + PyObject *empty_dict = 0; + PyObject *from_list = 0; + int module_found; + if (!qualname) { + qualname = name; + } + module_found = __Pyx__Import_Lookup(qualname, imported_names, len_imported_names, &module); + if (likely(module_found == 1)) { + return module; + } else if (unlikely(module_found == -1)) { + return NULL; + } + #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030f00a6 + empty_dict = PyFrozenDict_New(NULL); + #else + empty_dict = PyDict_New(); + #endif + if (unlikely(!empty_dict)) + goto bad; + if (imported_names) { + from_list = __Pyx_PyList_FromArray(imported_names, len_imported_names); + if (unlikely(!from_list)) + goto bad; + } + if (level == -1) { + const char* package_sep = strchr(__Pyx_MODULE_NAME, '.'); + if (package_sep != (0)) { + module = PyImport_ImportModuleLevelObject( + name, moddict, empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + if (!module) { + module = PyImport_ImportModuleLevelObject( + name, moddict, empty_dict, from_list, level); + } +bad: + Py_XDECREF(from_list); + Py_XDECREF(empty_dict); + return module; +} + +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, int level) { + return __Pyx__Import(name, imported_names, len_imported_names, qualname, __pyx_mstate_global->__pyx_d, level); +} + +/* ImportFrom */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + const char* module_name_str = 0; + PyObject* module_name = 0; + PyObject* module_dot = 0; + PyObject* full_name = 0; + PyErr_Clear(); + module_name_str = PyModule_GetName(module); + if (unlikely(!module_name_str)) { goto modbad; } + module_name = PyUnicode_FromString(module_name_str); + if (unlikely(!module_name)) { goto modbad; } + module_dot = PyUnicode_Concat(module_name, __pyx_mstate_global->__pyx_kp_u__5); + if (unlikely(!module_dot)) { goto modbad; } + full_name = PyUnicode_Concat(module_dot, name); + if (unlikely(!full_name)) { goto modbad; } + #if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) ||\ + CYTHON_COMPILING_IN_GRAAL + { + PyObject *modules = PyImport_GetModuleDict(); + if (unlikely(!modules)) + goto modbad; + value = PyObject_GetItem(modules, full_name); + } + #else + value = PyImport_GetModule(full_name); + #endif + modbad: + Py_XDECREF(full_name); + Py_XDECREF(module_dot); + Py_XDECREF(module_name); + } + if (unlikely(!value)) { + PyErr_Format(PyExc_ImportError, "cannot import name %S", name); + } + return value; +} + +/* CythonFunctionPerModule (used by CythonFunctionShared) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) { + if (__Pyx_CyFunction_Check(func)) { + return __Pyx_as_CyFunctionObject(func)->func_methoddef->ml_meth == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + } + return 0; +} +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if ((PyObject*)Py_TYPE(func) == __pyx_mstate_global->__Pyx_CachedMethodType) { + int result; + PyObject *newFunc = PyObject_GetAttr(func, __pyx_mstate_global->__pyx_n_u_func); + if (unlikely(!newFunc)) { + PyErr_Clear(); // It's only an optimization, so don't throw an error + return 0; + } + result = __Pyx__IsSameCyOrCFunctionNoMethod(newFunc, cfunc); + Py_DECREF(newFunc); + return result; + } + return __Pyx__IsSameCyOrCFunctionNoMethod(func, cfunc); +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if (PyMethod_Check(func)) { + func = PyMethod_GET_FUNCTION(func); + } + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +} +#endif +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +#if CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx__CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#else + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) { + __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(func); + m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type); + if (unlikely(!m->defaults)) + return NULL; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(func); + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(func); + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(func); + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* PyMethodNew (used by CythonFunctionShared) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *result; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + { + PyObject *args[] = {func, self}; + result = PyObject_Vectorcall(__pyx_mstate_global->__Pyx_CachedMethodType, args, 2, NULL); + } + #else + result = PyObject_CallFunctionObjArgs(__pyx_mstate_global->__Pyx_CachedMethodType, func, self, NULL); + #endif + return result; +} +#else +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#endif + +/* PyVectorcallFastCallDict (used by CythonFunctionShared) */ +#if CYTHON_VECTORCALL +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i; + #if CYTHON_AVOID_BORROWED_REFS + PyObject *pos; + #else + Py_ssize_t pos; + #endif + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + #if !CYTHON_ASSUME_SAFE_SIZE + Py_ssize_t nkw = PyDict_Size(kw); + if (unlikely(nkw == -1)) return NULL; + #else + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + #endif + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); + return NULL; + } + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); + return NULL; + } + kwvalues = newargs + nargs; + pos = 0; + i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (__Pyx_PyDict_NextRef(kw, &pos, &key, &value)) { + keys_are_strings &= + #if CYTHON_COMPILING_IN_LIMITED_API + PyType_GetFlags(Py_TYPE(key)); + #else + Py_TYPE(key)->tp_flags; + #endif + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(PyTuple_SetItem(kwnames, i, key) < 0)) goto cleanup; + #else + PyTuple_SET_ITEM(kwnames, i, key); + #endif + kwvalues[i] = value; + i++; + } + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + res = vc(func, newargs, nargs, kwnames); +cleanup: + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(pos); + #endif + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; +} +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + Py_ssize_t kw_size = + likely(kw == NULL) ? + 0 : +#if !CYTHON_ASSUME_SAFE_SIZE + PyDict_Size(kw); +#else + PyDict_GET_SIZE(kw); +#endif + if (kw_size == 0) { + return vc(func, args, nargs, NULL); + } +#if !CYTHON_ASSUME_SAFE_SIZE + else if (unlikely(kw_size == -1)) { + return NULL; + } +#endif + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); +} +#endif + +/* CythonFunctionShared (used by CythonFunction) */ +static PyObject * +__Pyx_CyFunction_get_doc_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + const char *doc = op->func_methoddef->ml_doc; +#else + const char *doc = ((PyCFunctionObject*)op)->m_ml->ml_doc; +#endif + if (doc) { + op->func_doc = PyUnicode_FromString(doc); + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static PyObject * +__Pyx_CyFunction_get_doc(PyObject *op_in, void *closure) { + PyObject *result; + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + CYTHON_UNUSED_VAR(closure); + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + result = __Pyx_CyFunction_get_doc_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_doc(PyObject *op_in, PyObject *value, void *context) +{ + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + const char *name = op->func_methoddef->ml_name; +#else + const char *name = ((PyCFunctionObject*)op)->m_ml->ml_name; +#endif + op->func_name = PyUnicode_InternFromString(name); + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static PyObject * +__Pyx_CyFunction_get_name(PyObject *op, void *context) +{ + PyObject *result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_name_locked(__Pyx_as_CyFunctionObject(op)); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_name(PyObject *op_in, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + __Pyx_Py_XDECREF_SET(op->func_name, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(PyObject *op_in, void *context) +{ + CYTHON_UNUSED_VAR(context); + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + Py_INCREF(op->func_qualname); + result = op->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_qualname(PyObject *op_in, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +#endif +static PyObject * +__Pyx_CyFunction_get_globals(PyObject *op_in, void *context) +{ + CYTHON_UNUSED_VAR(context); + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(PyObject *op, void *context) +{ + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(PyObject *op_in, void *context) +{ + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op, PyObject *op_obj) { + int result = 0; + PyObject *res = op->defaults_getter(op_obj); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(PyObject *op_in, PyObject* value, void *context) { + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults_locked(PyObject *op_in) { + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op, op_in) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_defaults(PyObject *op, void *context) { + PyObject* result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_defaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(PyObject *op_in, PyObject* value, void *context) { + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults_locked(PyObject *op_in) { + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op, op_in) < 0)) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(PyObject *op, void *context) { + PyObject* result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_kwdefaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int __Pyx_CyFunction_set_annotate_in_dict_if_exists(PyObject *op_in, PyObject *value); +static int +__Pyx_CyFunction_set_annotations(PyObject *op_in, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + Py_XINCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + __Pyx_END_CRITICAL_SECTION(); + if (unlikely(__Pyx_CyFunction_set_annotate_in_dict_if_exists(op_in, Py_None) < 0)) return -1; + return 0; +} +static int +__Pyx_CyFunction_get_dict_if_exists(PyObject *op_in, PyObject **dict) { + /* Return 1 if the function dict exists, 0 otherwise. This cannot fail: + * _PyObject_GetDictPtr() may clear errors internally, but never reports them. */ +#if CYTHON_COMPILING_IN_PYPY + *dict = PyObject_GenericGetDict(op_in, NULL); +#elif CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030C0000 + *dict = __Pyx_as_CyFunctionObject(op_in)->func_dict; +#else + PyObject **dictptr = _PyObject_GetDictPtr(op_in); + *dict = likely(dictptr) ? *dictptr : NULL; +#endif + return *dict ? 1 : 0; +} +static int +__Pyx_CyFunction_get_annotate_from_dict_if_exists(PyObject *op_in, PyObject **annotate) { + PyObject *dict; + int dict_found; + *annotate = NULL; + dict_found = __Pyx_CyFunction_get_dict_if_exists(op_in, &dict); + if (!dict_found) return 0; + return __Pyx_PyDict_GetItemRef(dict, __pyx_mstate_global->__pyx_n_u_annotate, annotate); +} +static int +__Pyx_CyFunction_set_annotate_in_dict_if_exists(PyObject *op_in, PyObject *value) { + PyObject *dict; + int dict_found; + dict_found = __Pyx_CyFunction_get_dict_if_exists(op_in, &dict); + if (!dict_found) return 0; + if (value) { + return PyDict_SetItem(dict, __pyx_mstate_global->__pyx_n_u_annotate, value); + } else { +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 + return PyDict_Pop(dict, __pyx_mstate_global->__pyx_n_u_annotate, NULL); +#else + int result = PyDict_Contains(dict, __pyx_mstate_global->__pyx_n_u_annotate); + if (result == 1) { + result = PyDict_DelItem(dict, __pyx_mstate_global->__pyx_n_u_annotate); + } + return result; +#endif + } +} +static int +__Pyx_CyFunction_set_annotate_in_dict(PyObject *op_in, PyObject *value) { + PyObject *dict; + int result; +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + dict = __Pyx_CyFunction_get_dict(__Pyx_as_CyFunctionObject(op_in), NULL); +#else + dict = PyObject_GenericGetDict(op_in, NULL); +#endif + if (unlikely(!dict)) return -1; + result = PyDict_SetItem(dict, __pyx_mstate_global->__pyx_n_u_annotate, value); + Py_DECREF(dict); + return result; +} +static PyObject * +__Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->func_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_annotations(PyObject *op_in, void *context) { + PyObject *annotate = NULL; + PyObject *result = NULL; + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + result = __Pyx_XNewRef(op->func_annotations); + __Pyx_END_CRITICAL_SECTION(); + if (result) return result; + if (unlikely(__Pyx_CyFunction_get_annotate_from_dict_if_exists(op_in, &annotate) < 0)) return NULL; + if (!annotate || annotate == Py_None) { + Py_XDECREF(annotate); + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + result = __Pyx_CyFunction_get_annotations_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; + } + PyObject *format = PyLong_FromLong(1L); // annotationlib.Format.VALUE + if (likely(format)) { + if (!Py_EnterRecursiveCall(" cyfunction __annotations__.__get__")) { + result = __Pyx_PyObject_CallOneArg(annotate, format); + Py_LeaveRecursiveCall(); + Py_DECREF(format); + } + } + Py_DECREF(annotate); + if (unlikely(!result)) return NULL; + if (unlikely(!PyDict_Check(result))) { + PyErr_SetString(PyExc_TypeError, "__annotate__ must return a dict"); + Py_DECREF(result); + return NULL; + } + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + __Pyx_Py_XDECREF_SET(op->func_annotations, __Pyx_NewRef(result)); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyObject *__Pyx_CyFunction_annotate_impl(PyObject *self, PyObject *arg) { + CYTHON_UNUSED_VAR(arg); + if (unlikely(!self)) { + PyErr_SetString(PyExc_SystemError, "cython __annotate__ called without 'self' argument"); + return NULL; + } + PyObject *result; + if (Py_EnterRecursiveCall(" in cyfunction annotate")) { + return NULL; + } + result = __Pyx_CyFunction_get_annotations(self, NULL); + Py_LeaveRecursiveCall(); + return result; +} +static PyObject * +__Pyx_CyFunction_get_annotate(PyObject *op_in, void *context); +static int +__Pyx_CyFunction_set_annotate(PyObject *op_in, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, "__annotate__ cannot be deleted"); + return -1; + } + if (unlikely(value != Py_None && !PyCallable_Check(value))) { + PyErr_SetString(PyExc_TypeError, "__annotate__ must be callable or None"); + return -1; + } + if (unlikely(__Pyx_TypeCheck(value, &PyCFunction_Type))) { +#if !CYTHON_ASSUME_SAFE_MACROS && !CYTHON_COMPILING_IN_PYPY + PyCFunction cfunction = PyCFunction_GetFunction(value); + if (unlikely(!cfunction)) return -1; + PyObject *value_self = PyCFunction_GetSelf(value); + if (unlikely(!value_self && PyErr_Occurred())) return -1; +#else + PyCFunction cfunction = PyCFunction_GET_FUNCTION(value); + PyObject *value_self = PyCFunction_GET_SELF(value); +#endif + if (cfunction == __Pyx_CyFunction_annotate_impl && value_self == op_in) { + return __Pyx_CyFunction_set_annotate_in_dict_if_exists(op_in, NULL); + } + } + if (value != Py_None) { + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + Py_CLEAR(op->func_annotations); + __Pyx_END_CRITICAL_SECTION(); + } + return __Pyx_CyFunction_set_annotate_in_dict(op_in, value); +} +#if __PYX_LIMITED_VERSION_HEX < 0x030B0000 +static PyObject * +__Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) { + int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; + if (is_coroutine) { + PyObject *is_coroutine_value, *module, *fromlist, *marker = __pyx_mstate_global->__pyx_n_u_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); +#else + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(fromlist); + return NULL; + } +#endif + module = PyImport_ImportModuleLevelObject(__pyx_mstate_global->__pyx_n_u_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) { + goto ignore_or_error; + } + is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(is_coroutine_value)) { + return is_coroutine_value; + } +ignore_or_error: + if (!__Pyx_IgnoreException(PyExc_Exception)) { + return NULL; + } + } + return __Pyx_PyBool_FromLong(is_coroutine); +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine(PyObject *op_in, void *context) { + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + PyObject *result; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + result = __Pyx_CyFunction_get_is_coroutine_value(op); + if (unlikely(!result)) + return NULL; + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + if (op->func_is_coroutine) { + Py_DECREF(result); + result = __Pyx_NewRef(op->func_is_coroutine); + } else { + op->func_is_coroutine = __Pyx_NewRef(result); + } + __Pyx_END_CRITICAL_SECTION(); + return result; +} +#endif +static void __Pyx_CyFunction_raise_argument_count_error(PyObject *func, const char* message, Py_ssize_t size) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, message, size); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + name, message, size); +#endif +} +static void __Pyx_CyFunction_raise_type_error(PyObject *func, const char* message) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s", + py_name, message); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s", + name, message); +#endif +} +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(PyObject *op_in, void *context) { + CYTHON_UNUSED_VAR(context); + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + Py_INCREF(op->func_module); + return op->func_module; +} +static int +__Pyx_CyFunction_set_module(PyObject *op_in, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + PyObject *old = op->func_module; + op->func_module = value; + Py_DECREF(old); + return 0; +} +#endif +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {"func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)PyObject_GenericSetDict, 0, 0}, + {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)PyObject_GenericSetDict, 0, 0}, +#else + {"func_dict", (getter)PyObject_GenericGetDict, (setter)PyObject_GenericSetDict, 0, 0}, + {"__dict__", (getter)PyObject_GenericGetDict, (setter)PyObject_GenericSetDict, 0, 0}, +#endif + {"func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {"__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {"__annotate__", (getter)__Pyx_CyFunction_get_annotate, (setter)__Pyx_CyFunction_set_annotate, 0, 0}, +#if __PYX_LIMITED_VERSION_HEX < 0x030B0000 + {"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, +#endif + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), + __PYX_SHARED_RELATIVE_OFFSET | READONLY, 0}, +#endif +#if CYTHON_VECTORCALL +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), + __PYX_SHARED_RELATIVE_OFFSET | READONLY, 0}, +#else + {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), + __PYX_SHARED_RELATIVE_OFFSET | READONLY, 0}, +#else + {"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, +#endif +#endif + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(PyObject *m_in, PyObject *args) +{ + PyObject *result = NULL; + __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(m_in); + CYTHON_UNUSED_VAR(args); + __Pyx_BEGIN_CRITICAL_SECTION(m_in); + Py_INCREF(m->func_qualname); + result = m->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__annotate_cython__", __Pyx_CyFunction_annotate_impl, METH_O, + "Placeholder __annotate__ function to allow 'functools.wraps' to work " + "on Cython functions."}, + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_NOARGS, 0}, + {0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_get_annotate(PyObject *op_in, void *context) { + PyObject *annotate = NULL; + CYTHON_UNUSED_VAR(context); + if (unlikely(__Pyx_CyFunction_get_annotate_from_dict_if_exists(op_in, &annotate) < 0)) return NULL; + if (annotate) return annotate; + PyObject *method = PyCFunction_New( + &__pyx_CyFunction_methods[0], + op_in); + return method; +} +#if CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_Init(PyObject *op_in, + PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + __pyx_CyFunctionObject* op = __Pyx_as_CyFunctionObject(op_in); +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_methoddef = ml; + Py_INCREF(module); + op->func_module = module; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + op->func_dict = NULL; +#endif + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; +#else + ((PyCMethodObject*)op)->mm_class = NULL; +#endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; +#if __PYX_LIMITED_VERSION_HEX < 0x030B0000 + op->func_is_coroutine = NULL; +#endif +#if CYTHON_VECTORCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op_in); + return NULL; + } +#endif + return op_in; +} +static int __Pyx__CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func_module); +#else + Py_CLEAR(((PyCFunctionObject*)m)->m_module); +#endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func_dict); +#elif PY_VERSION_HEX < 0x030d0000 + _PyObject_ClearManagedDict((PyObject*)m); +#else + PyObject_ClearManagedDict((PyObject*)m); +#endif + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func_classobj); +#else + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); + } +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); +#if __PYX_LIMITED_VERSION_HEX < 0x030B0000 + Py_CLEAR(m->func_is_coroutine); +#endif + Py_CLEAR(m->defaults); + return 0; +} +static int +__Pyx_CyFunction_clear(PyObject *m) +{ + return __Pyx__CyFunction_clear(__Pyx_as_CyFunctionObject(m)); +} +static void __Pyx__CyFunction_dealloc(PyObject *m) +{ + __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(m); + if (__Pyx_CyFunction_weakreflist(cyfunc) != NULL) + PyObject_ClearWeakRefs(m); + __Pyx__CyFunction_clear(cyfunc); + __Pyx_PyHeapTypeObject_GC_Del(m); +} +static void __Pyx_CyFunction_dealloc(PyObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); +} +static int __Pyx_CyFunction_traverse(PyObject *m_in, visitproc visit, void *arg) +{ + __pyx_CyFunctionObject *m = __Pyx_as_CyFunctionObject(m_in); + { + int e = __Pyx_call_type_traverse(m_in, 1, visit, arg); + if (e) return e; + } + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func_module); +#else + Py_VISIT(((PyCFunctionObject*)m)->m_module); +#endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func_dict); +#else + { + int e = +#if PY_VERSION_HEX < 0x030d0000 + _PyObject_VisitManagedDict +#else + PyObject_VisitManagedDict +#endif + ((PyObject*)m, visit, arg); + if (e != 0) return e; + } +#endif + __Pyx_VISIT_CONST(m->func_name); + __Pyx_VISIT_CONST(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + __Pyx_VISIT_CONST(m->func_code); + Py_VISIT(__Pyx__CyFunction_GetClassObj(m)); + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_annotations); +#if __PYX_LIMITED_VERSION_HEX < 0x030B0000 + Py_VISIT(m->func_is_coroutine); +#endif + Py_VISIT(m->defaults); + return 0; +} +static PyObject* +__Pyx_CyFunction_repr(PyObject *op_in) +{ + __pyx_CyFunctionObject *op = __Pyx_as_CyFunctionObject(op_in); + PyObject *repr; + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + repr = PyUnicode_FromFormat("", + op->func_qualname, (void *)op); + __Pyx_END_CRITICAL_SECTION(); + return repr; +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); + PyCFunction meth = cyfunc->func_methoddef->ml_meth; + int flags = cyfunc->func_methoddef->ml_flags; +#else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; +#endif + Py_ssize_t size; + switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void(*)(void))meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); + __Pyx_CyFunction_raise_argument_count_error( + func, + "takes no arguments", size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } + __Pyx_CyFunction_raise_argument_count_error( + func, + "takes exactly one argument", size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; + } + __Pyx_CyFunction_raise_type_error( + func, "takes no keyword arguments"); + return NULL; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + result = __Pyx_CyFunction_CallMethod(func, func, arg, kw); + return result; +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); +#if CYTHON_VECTORCALL + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); +#else + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); +#endif + } +#endif + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; +#if CYTHON_ASSUME_SAFE_SIZE + argc = PyTuple_GET_SIZE(args); +#else + argc = PyTuple_Size(args); + if (unlikely(argc < 0)) return NULL; +#endif + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} +#if CYTHON_VECTORCALL +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(PyObject *func, __pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + __Pyx_CyFunction_raise_type_error( + func, "needs an argument"); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) { + __Pyx_CyFunction_raise_type_error( + func, "takes no keyword arguments"); + return -1; + } + return ret; +} +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = cyfunc->func_methoddef->ml_meth; + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(func, cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = func; + break; + default: + return NULL; + } + if (unlikely(nargs != 0)) { + __Pyx_CyFunction_raise_argument_count_error( + func, "takes no arguments", nargs); + return NULL; + } + return meth(self, NULL); +} +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = cyfunc->func_methoddef->ml_meth; + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(func, cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = func; + break; + default: + return NULL; + } + if (unlikely(nargs != 1)) { + __Pyx_CyFunction_raise_argument_count_error( + func, "takes exactly one argument", nargs); + return NULL; + } + return meth(self, args[0]); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = cyfunc->func_methoddef->ml_meth; + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(func, cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = func; + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))meth)(self, args, nargs, kwnames); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = __Pyx_as_CyFunctionObject(func); + PyTypeObject *cls = (PyTypeObject *) __Pyx__CyFunction_GetClassObj(cyfunc); + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = cyfunc->func_methoddef->ml_meth; + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(func, cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = func; + break; + default: + return NULL; + } + #if PY_VERSION_HEX < 0x030e00A6 + size_t nargs_value = (size_t) nargs; + #else + Py_ssize_t nargs_value = nargs; + #endif + return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, nargs_value, kwnames); +} +#endif +static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, +}; +static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + __PYX_SHARED_SIZEOF(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if CYTHON_VECTORCALL +#if defined(Py_TPFLAGS_HAVE_VECTORCALL) + Py_TPFLAGS_HAVE_VECTORCALL | +#elif defined(_Py_TPFLAGS_HAVE_VECTORCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif +#endif // CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x030C0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_TPFLAGS_MANAGED_DICT | +#endif + Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; +static int __pyx_CyFunction_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CyFunctionType_spec, NULL); + if (unlikely(mstate->__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; +} + +/* CythonFunction */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + (void)&__Pyx_Get_CyFunction_Type; + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(PyObject, __pyx_mstate_global->__pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; +} +static PyTypeObject *__Pyx_Get_CyFunction_Type(void) { + PyTypeObject *tp = __pyx_mstate_global->__pyx_CyFunctionType; + Py_INCREF((PyObject*)tp); + return tp; +} + +/* CLineInTraceback (used by AddTraceback) */ +#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +#define __Pyx_PyProbablyModule_GetDict(o) __Pyx_XNewRef(PyModule_GetDict(o)) +#elif !CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_PyProbablyModule_GetDict(o) PyObject_GenericGetDict(o, NULL); +#else +PyObject* __Pyx_PyProbablyModule_GetDict(PyObject *o) { + PyObject **dict_ptr = _PyObject_GetDictPtr(o); + return dict_ptr ? __Pyx_XNewRef(*dict_ptr) : NULL; +} +#endif +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { + PyObject *use_cline = NULL; + PyObject *ptype, *pvalue, *ptraceback; + PyObject *cython_runtime_dict; + CYTHON_MAYBE_UNUSED_VAR(tstate); + if (unlikely(!__pyx_mstate_global->__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); + cython_runtime_dict = __Pyx_PyProbablyModule_GetDict(__pyx_mstate_global->__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, cython_runtime_dict, + __Pyx_PyDict_SetDefault(cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False)) + } + if (use_cline == NULL || use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + Py_XDECREF(use_cline); + Py_XDECREF(cython_runtime_dict); + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache (used by AddTraceback) */ +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static __Pyx_CachedCodeObjectType *__pyx__find_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line) { + __Pyx_CachedCodeObjectType* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!code_cache->entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if (unlikely(pos >= code_cache->count) || unlikely(code_cache->entries[pos].code_line != code_line)) { + return NULL; + } + code_object = code_cache->entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__find_code_object; + return NULL; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just miss. +#else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type old_count = __pyx_atomic_incr_acq_rel(&code_cache->accessor_count); + if (old_count < 0) { + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); + return NULL; + } +#endif + __Pyx_CachedCodeObjectType *result = __pyx__find_code_object(code_cache, code_line); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); +#endif + return result; +#endif +} +static void __pyx__insert_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line, __Pyx_CachedCodeObjectType* code_object) +{ + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = code_cache->entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + code_cache->entries = entries; + code_cache->max_count = 64; + code_cache->count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if ((pos < code_cache->count) && unlikely(code_cache->entries[pos].code_line == code_line)) { + __Pyx_CachedCodeObjectType* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_INCREF(code_object); + Py_DECREF(tmp); + return; + } + if (code_cache->count == code_cache->max_count) { + int new_max = code_cache->max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + code_cache->entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + code_cache->entries = entries; + code_cache->max_count = new_max; + } + for (i=code_cache->count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + code_cache->count++; + Py_INCREF(code_object); +} +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__insert_code_object; + return; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just fail. +#else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type expected = 0; + if (!__pyx_atomic_int_cmp_exchange(&code_cache->accessor_count, &expected, INT_MIN)) { + return; + } +#endif + __pyx__insert_code_object(code_cache, code_line, code_object); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_sub(&code_cache->accessor_count, INT_MIN); +#endif +#endif +} + +/* AddTraceback */ +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result = PyObject_Call(replace, __pyx_mstate_global->__pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + c_line = __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + __Pyx_PyErr_FetchException(&exc_type, &exc_value, &exc_traceback); + code_object = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!code_object) { + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + if (c_line) { + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + } else { + py_funcname = PyUnicode_FromString(funcname); + } + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, code_object); + } else { + dict = PyDict_New(); + } + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + __Pyx_PyErr_RestoreException(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; + if (c_line) { + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; + } + py_code = PyCode_NewEmpty(filename, funcname, py_line); + Py_XDECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject *ptype, *pvalue, *ptraceback; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) { + /* If the code object creation fails, then we should clear the + fetched exception references and propagate the new exception */ + Py_XDECREF(ptype); + Py_XDECREF(pvalue); + Py_XDECREF(ptraceback); + goto bad; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_mstate_global->__pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} +#endif + +/* CIntFromPyVerify */ +#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* CheckUnpickleChecksumError */ +static void __Pyx_RaiseUnpickleChecksumError(long checksum, long checksum1, long checksum2, long checksum3, const char *members) { + PyObject *pickle_module = PyImport_ImportModule("pickle"); + if (unlikely(!pickle_module)) return; + PyObject *pickle_error = PyObject_GetAttrString(pickle_module, "PickleError"); + Py_DECREF(pickle_module); + if (unlikely(!pickle_error)) return; + if (checksum2 == checksum1) { + PyErr_Format(pickle_error, "Incompatible checksums (0x%x vs (0x%x) = (%s))", + checksum, checksum1, members); + } else if (checksum3 == checksum2) { + PyErr_Format(pickle_error, "Incompatible checksums (0x%x vs (0x%x, 0x%x) = (%s))", + checksum, checksum1, checksum2, members); + } else { + PyErr_Format(pickle_error, "Incompatible checksums (0x%x vs (0x%x, 0x%x, 0x%x) = (%s))", + checksum, checksum1, checksum2, checksum3, members); + } + Py_DECREF(pickle_error); +} + +/* PyObjectVectorcallMethodKwds (used by CIntToPy) */ +#if !CYTHON_VECTORCALL +static PyObject *__Pyx_Object_VectorcallMethodKwds(PyObject *name, PyObject *const *args, size_t nargsf, PyObject *kwnames) { + PyObject *result; + PyObject *obj = PyObject_GetAttr(args[0], name); + if (unlikely(!obj)) + return NULL; + result = __Pyx_Object_VectorcallKwds(obj, args+1, nargsf-1, kwnames); + Py_DECREF(obj); + return result; +} +#endif + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_unsigned_int(unsigned int value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(unsigned int) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(unsigned int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#if !CYTHON_COMPILING_IN_PYPY + } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(unsigned int) <= sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(unsigned int), + little, !is_unsigned); +#else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL, *from_bytes_str = NULL;; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned int)); + if (!py_bytes) goto limited_bad; + from_bytes_str = PyUnicode_FromStringAndSize("from_bytes", 10); + if (!from_bytes_str) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[] = { (PyObject*)&PyLong_Type, py_bytes, order_str, Py_True }; + if (!is_unsigned) { + PyObject *signed_str = PyUnicode_FromStringAndSize("signed", 6); + if (!signed_str) goto limited_bad; +#if CYTHON_VECTORCALL + kwds = PyTuple_Pack(1, signed_str); +#else + { + PyObject *keys[] = {signed_str}; + PyObject *values[] = {Py_True}; + kwds = __Pyx_MakeKwargDict(keys, values, 1); + } +#endif + Py_DECREF(signed_str); + if (unlikely(!kwds)) goto limited_bad; + } + result = __Pyx_Object_VectorcallMethodKwds(from_bytes_str, args, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes_str); + return result; +#endif + } +} + +/* CIntFromPy */ +static unsigned int __Pyx_LargePyLong___Pyx_PyLong_As_unsigned_int(PyObject *x); +static unsigned int __Pyx_raise_neg_overflow___Pyx_PyLong_As_unsigned_int(void) { + const char* type_name = "unsigned int"; + PyErr_Format(PyExc_OverflowError, + "can't convert negative value to %.200s", type_name); + return (unsigned int) -1; +} +static unsigned int __Pyx_raise_overflow___Pyx_PyLong_As_unsigned_int(void) { + const char* type_name = "unsigned int"; + PyErr_Format(PyExc_OverflowError, + "value too large to convert to %.200s", type_name); + return (unsigned int) -1; +} +static CYTHON_INLINE unsigned int __Pyx_PyULong___Pyx_PyLong_As_unsigned_int(PyObject *x) { + const int is_unsigned = 1; +#if CYTHON_USE_PYLONG_INTERNALS + { + const digit* digits = __Pyx_PyLong_Digits(x); + const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); + if (size == 2 && (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT)) { + return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } else + if (size == 3 && (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT)) { + return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } else + if (size == 4 && (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT)) { + return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } else + {} + } +#elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (unsigned int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if ((sizeof(unsigned int) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + return __Pyx_LargePyLong___Pyx_PyLong_As_unsigned_int(x); +raise_neg_overflow: + return __Pyx_raise_neg_overflow___Pyx_PyLong_As_unsigned_int(); +raise_overflow: + return __Pyx_raise_overflow___Pyx_PyLong_As_unsigned_int(); +} +static CYTHON_INLINE unsigned int __Pyx_PySLong___Pyx_PyLong_As_unsigned_int(PyObject *x) { + const int is_unsigned = 0; +#if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsNeg(x)) { + const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); + const digit* digits = __Pyx_PyLong_Digits(x); + if (size == 2 && (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + long ival = - (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + __PYX_VERIFY_RETURN_INT(unsigned int, long, ival) + } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { + return (unsigned int) (((unsigned int) -1) * (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } else + if (size == 3 && (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + long ival = - (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + __PYX_VERIFY_RETURN_INT(unsigned int, long, ival) + } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { + return (unsigned int) (((unsigned int) -1) * (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } else + if (size == 4 && (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 4 * PyLong_SHIFT)) { + long ival = - (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + __PYX_VERIFY_RETURN_INT(unsigned int, long, ival) + } else if ((8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT)) { + return (unsigned int) (((unsigned int) -1) * (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } else + {} + } else { + const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); + const digit* digits = __Pyx_PyLong_Digits(x); + if (size == 2 && (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { + return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } else + if (size == 3 && (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { + return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } else + if (size == 4 && (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT)) { + return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } else + {} + } +#endif + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + if ((sizeof(unsigned int) <= sizeof(int)) && (sizeof(int) < sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, int, PyLong_AsInt(x)) + } else + #endif + if ((sizeof(unsigned int) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x)) + } else if ((sizeof(unsigned int) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + return __Pyx_LargePyLong___Pyx_PyLong_As_unsigned_int(x); +raise_neg_overflow: + return __Pyx_raise_neg_overflow___Pyx_PyLong_As_unsigned_int(); +raise_overflow: + return __Pyx_raise_overflow___Pyx_PyLong_As_unsigned_int(); +} +static unsigned int __Pyx_LargePyLong___Pyx_PyLong_As_unsigned_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + unsigned int val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); + if ((0)) goto raise_overflow; +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (unsigned int) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (unsigned int) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to unsigned int"); + return (unsigned int) -1; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (unsigned int) -1; + } else { + stepval = v; + } + v = NULL; + val = (unsigned int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(unsigned int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((unsigned int) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(unsigned int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((unsigned int) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((unsigned int) 1) << (sizeof(unsigned int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; +done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + if (unlikely(ret)) + return (unsigned int) -1; + return val; +raise_overflow: + return __Pyx_raise_overflow___Pyx_PyLong_As_unsigned_int(); +} +static CYTHON_INLINE unsigned int __Pyx_PyLong___Pyx_PyLong_As_unsigned_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + #if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else + #endif + { + return __Pyx_PyULong___Pyx_PyLong_As_unsigned_int(x); + } + } else { + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else + #endif + { + return __Pyx_PySLong___Pyx_PyLong_As_unsigned_int(x); + } + } +#if CYTHON_USE_PYLONG_INTERNALS +raise_neg_overflow: + return __Pyx_raise_neg_overflow___Pyx_PyLong_As_unsigned_int(); +raise_overflow: + return __Pyx_raise_overflow___Pyx_PyLong_As_unsigned_int(); +#endif +} +static unsigned int __Pyx_NonPyLong___Pyx_PyLong_As_unsigned_int(PyObject *x) { + unsigned int val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (unsigned int) -1; + val = __Pyx_PyLong_As_unsigned_int(tmp); + Py_DECREF(tmp); + return val; +} +static CYTHON_INLINE unsigned int __Pyx_PyLong_As_unsigned_int(PyObject *x) { + if (likely(PyLong_Check(x))) { + return __Pyx_PyLong___Pyx_PyLong_As_unsigned_int(x); + } else { + return __Pyx_NonPyLong___Pyx_PyLong_As_unsigned_int(x); + } +} + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#if !CYTHON_COMPILING_IN_PYPY + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); +#else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL, *from_bytes_str = NULL;; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + if (!py_bytes) goto limited_bad; + from_bytes_str = PyUnicode_FromStringAndSize("from_bytes", 10); + if (!from_bytes_str) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[] = { (PyObject*)&PyLong_Type, py_bytes, order_str, Py_True }; + if (!is_unsigned) { + PyObject *signed_str = PyUnicode_FromStringAndSize("signed", 6); + if (!signed_str) goto limited_bad; +#if CYTHON_VECTORCALL + kwds = PyTuple_Pack(1, signed_str); +#else + { + PyObject *keys[] = {signed_str}; + PyObject *values[] = {Py_True}; + kwds = __Pyx_MakeKwargDict(keys, values, 1); + } +#endif + Py_DECREF(signed_str); + if (unlikely(!kwds)) goto limited_bad; + } + result = __Pyx_Object_VectorcallMethodKwds(from_bytes_str, args, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes_str); + return result; +#endif + } +} + +/* CIntFromPy */ +static int __Pyx_LargePyLong___Pyx_PyLong_As_int(PyObject *x); +static int __Pyx_raise_neg_overflow___Pyx_PyLong_As_int(void) { + const char* type_name = "int"; + PyErr_Format(PyExc_OverflowError, + "can't convert negative value to %.200s", type_name); + return (int) -1; +} +static int __Pyx_raise_overflow___Pyx_PyLong_As_int(void) { + const char* type_name = "int"; + PyErr_Format(PyExc_OverflowError, + "value too large to convert to %.200s", type_name); + return (int) -1; +} +static CYTHON_INLINE int __Pyx_PyULong___Pyx_PyLong_As_int(PyObject *x) { + const int is_unsigned = 1; +#if CYTHON_USE_PYLONG_INTERNALS + { + const digit* digits = __Pyx_PyLong_Digits(x); + const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); + if (size == 2 && (8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } else + if (size == 3 && (8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } else + if (size == 4 && (8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } else + {} + } +#elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if ((sizeof(int) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + return __Pyx_LargePyLong___Pyx_PyLong_As_int(x); +raise_neg_overflow: + return __Pyx_raise_neg_overflow___Pyx_PyLong_As_int(); +raise_overflow: + return __Pyx_raise_overflow___Pyx_PyLong_As_int(); +} +static CYTHON_INLINE int __Pyx_PySLong___Pyx_PyLong_As_int(PyObject *x) { + const int is_unsigned = 0; +#if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsNeg(x)) { + const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); + const digit* digits = __Pyx_PyLong_Digits(x); + if (size == 2 && (8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + long ival = - (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + __PYX_VERIFY_RETURN_INT(int, long, ival) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int) -1) * (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } else + if (size == 3 && (8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + long ival = - (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + __PYX_VERIFY_RETURN_INT(int, long, ival) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int) -1) * (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } else + if (size == 4 && (8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 4 * PyLong_SHIFT)) { + long ival = - (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + __PYX_VERIFY_RETURN_INT(int, long, ival) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int) -1) * (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } else + {} + } else { + const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); + const digit* digits = __Pyx_PyLong_Digits(x); + if (size == 2 && (8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } else + if (size == 3 && (8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } else + if (size == 4 && (8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } else + {} + } +#endif + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + if ((sizeof(int) <= sizeof(int)) && (sizeof(int) < sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(int, int, PyLong_AsInt(x)) + } else + #endif + if ((sizeof(int) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + return __Pyx_LargePyLong___Pyx_PyLong_As_int(x); +raise_neg_overflow: + return __Pyx_raise_neg_overflow___Pyx_PyLong_As_int(); +raise_overflow: + return __Pyx_raise_overflow___Pyx_PyLong_As_int(); +} +static int __Pyx_LargePyLong___Pyx_PyLong_As_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + int val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); + if ((0)) goto raise_overflow; +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (int) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (int) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = v; + } + v = NULL; + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((int) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; +done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + if (unlikely(ret)) + return (int) -1; + return val; +raise_overflow: + return __Pyx_raise_overflow___Pyx_PyLong_As_int(); +} +static CYTHON_INLINE int __Pyx_PyLong___Pyx_PyLong_As_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + #if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else + #endif + { + return __Pyx_PyULong___Pyx_PyLong_As_int(x); + } + } else { + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else + #endif + { + return __Pyx_PySLong___Pyx_PyLong_As_int(x); + } + } +#if CYTHON_USE_PYLONG_INTERNALS +raise_neg_overflow: + return __Pyx_raise_neg_overflow___Pyx_PyLong_As_int(); +raise_overflow: + return __Pyx_raise_overflow___Pyx_PyLong_As_int(); +#endif +} +static int __Pyx_NonPyLong___Pyx_PyLong_As_int(PyObject *x) { + int val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (int) -1; + val = __Pyx_PyLong_As_int(tmp); + Py_DECREF(tmp); + return val; +} +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *x) { + if (likely(PyLong_Check(x))) { + return __Pyx_PyLong___Pyx_PyLong_As_int(x); + } else { + return __Pyx_NonPyLong___Pyx_PyLong_As_int(x); + } +} + +/* CIntFromPy */ +static unsigned PY_LONG_LONG __Pyx_LargePyLong___Pyx_PyLong_As_unsigned_PY_LONG_LONG(PyObject *x); +static unsigned PY_LONG_LONG __Pyx_raise_neg_overflow___Pyx_PyLong_As_unsigned_PY_LONG_LONG(void) { + const char* type_name = "unsigned PY_LONG_LONG"; + PyErr_Format(PyExc_OverflowError, + "can't convert negative value to %.200s", type_name); + return (unsigned PY_LONG_LONG) -1; +} +static unsigned PY_LONG_LONG __Pyx_raise_overflow___Pyx_PyLong_As_unsigned_PY_LONG_LONG(void) { + const char* type_name = "unsigned PY_LONG_LONG"; + PyErr_Format(PyExc_OverflowError, + "value too large to convert to %.200s", type_name); + return (unsigned PY_LONG_LONG) -1; +} +static CYTHON_INLINE unsigned PY_LONG_LONG __Pyx_PyULong___Pyx_PyLong_As_unsigned_PY_LONG_LONG(PyObject *x) { + const int is_unsigned = 1; +#if CYTHON_USE_PYLONG_INTERNALS + { + const digit* digits = __Pyx_PyLong_Digits(x); + const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); + if (size == 2 && (8 * sizeof(unsigned PY_LONG_LONG) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned PY_LONG_LONG, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned PY_LONG_LONG) >= 2 * PyLong_SHIFT)) { + return (unsigned PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + } + } else + if (size == 3 && (8 * sizeof(unsigned PY_LONG_LONG) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned PY_LONG_LONG, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned PY_LONG_LONG) >= 3 * PyLong_SHIFT)) { + return (unsigned PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + } + } else + if (size == 4 && (8 * sizeof(unsigned PY_LONG_LONG) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned PY_LONG_LONG, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned PY_LONG_LONG) >= 4 * PyLong_SHIFT)) { + return (unsigned PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + } + } else + {} + } +#elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (unsigned PY_LONG_LONG) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if ((sizeof(unsigned PY_LONG_LONG) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned PY_LONG_LONG, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(unsigned PY_LONG_LONG) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned PY_LONG_LONG, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + return __Pyx_LargePyLong___Pyx_PyLong_As_unsigned_PY_LONG_LONG(x); +raise_neg_overflow: + return __Pyx_raise_neg_overflow___Pyx_PyLong_As_unsigned_PY_LONG_LONG(); +raise_overflow: + return __Pyx_raise_overflow___Pyx_PyLong_As_unsigned_PY_LONG_LONG(); +} +static CYTHON_INLINE unsigned PY_LONG_LONG __Pyx_PySLong___Pyx_PyLong_As_unsigned_PY_LONG_LONG(PyObject *x) { + const int is_unsigned = 0; +#if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsNeg(x)) { + const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); + const digit* digits = __Pyx_PyLong_Digits(x); + if (size == 2 && (8 * sizeof(unsigned PY_LONG_LONG) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + long ival = - (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + __PYX_VERIFY_RETURN_INT(unsigned PY_LONG_LONG, long, ival) + } else if ((8 * sizeof(unsigned PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT)) { + return (unsigned PY_LONG_LONG) (((unsigned PY_LONG_LONG) -1) * (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]))); + } + } else + if (size == 3 && (8 * sizeof(unsigned PY_LONG_LONG) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + long ival = - (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + __PYX_VERIFY_RETURN_INT(unsigned PY_LONG_LONG, long, ival) + } else if ((8 * sizeof(unsigned PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT)) { + return (unsigned PY_LONG_LONG) (((unsigned PY_LONG_LONG) -1) * (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]))); + } + } else + if (size == 4 && (8 * sizeof(unsigned PY_LONG_LONG) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 4 * PyLong_SHIFT)) { + long ival = - (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + __PYX_VERIFY_RETURN_INT(unsigned PY_LONG_LONG, long, ival) + } else if ((8 * sizeof(unsigned PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT)) { + return (unsigned PY_LONG_LONG) (((unsigned PY_LONG_LONG) -1) * (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]))); + } + } else + {} + } else { + const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); + const digit* digits = __Pyx_PyLong_Digits(x); + if (size == 2 && (8 * sizeof(unsigned PY_LONG_LONG) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned PY_LONG_LONG, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT)) { + return (unsigned PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + } + } else + if (size == 3 && (8 * sizeof(unsigned PY_LONG_LONG) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned PY_LONG_LONG, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT)) { + return (unsigned PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + } + } else + if (size == 4 && (8 * sizeof(unsigned PY_LONG_LONG) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned PY_LONG_LONG, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT)) { + return (unsigned PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + } + } else + {} + } +#endif + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + if ((sizeof(unsigned PY_LONG_LONG) <= sizeof(int)) && (sizeof(int) < sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned PY_LONG_LONG, int, PyLong_AsInt(x)) + } else + #endif + if ((sizeof(unsigned PY_LONG_LONG) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned PY_LONG_LONG, long, PyLong_AsLong(x)) + } else if ((sizeof(unsigned PY_LONG_LONG) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned PY_LONG_LONG, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + return __Pyx_LargePyLong___Pyx_PyLong_As_unsigned_PY_LONG_LONG(x); +raise_neg_overflow: + return __Pyx_raise_neg_overflow___Pyx_PyLong_As_unsigned_PY_LONG_LONG(); +raise_overflow: + return __Pyx_raise_overflow___Pyx_PyLong_As_unsigned_PY_LONG_LONG(); +} +static unsigned PY_LONG_LONG __Pyx_LargePyLong___Pyx_PyLong_As_unsigned_PY_LONG_LONG(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const unsigned PY_LONG_LONG neg_one = (unsigned PY_LONG_LONG) -1, const_zero = (unsigned PY_LONG_LONG) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + unsigned PY_LONG_LONG val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); + if ((0)) goto raise_overflow; +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (unsigned PY_LONG_LONG) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (unsigned PY_LONG_LONG) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to unsigned PY_LONG_LONG"); + return (unsigned PY_LONG_LONG) -1; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (unsigned PY_LONG_LONG) -1; + } else { + stepval = v; + } + v = NULL; + val = (unsigned PY_LONG_LONG) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(unsigned PY_LONG_LONG) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((unsigned PY_LONG_LONG) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(unsigned PY_LONG_LONG) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((unsigned PY_LONG_LONG) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((unsigned PY_LONG_LONG) 1) << (sizeof(unsigned PY_LONG_LONG) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; +done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + if (unlikely(ret)) + return (unsigned PY_LONG_LONG) -1; + return val; +raise_overflow: + return __Pyx_raise_overflow___Pyx_PyLong_As_unsigned_PY_LONG_LONG(); +} +static CYTHON_INLINE unsigned PY_LONG_LONG __Pyx_PyLong___Pyx_PyLong_As_unsigned_PY_LONG_LONG(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const unsigned PY_LONG_LONG neg_one = (unsigned PY_LONG_LONG) -1, const_zero = (unsigned PY_LONG_LONG) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + #if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(unsigned PY_LONG_LONG, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else + #endif + { + return __Pyx_PyULong___Pyx_PyLong_As_unsigned_PY_LONG_LONG(x); + } + } else { + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(unsigned PY_LONG_LONG, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else + #endif + { + return __Pyx_PySLong___Pyx_PyLong_As_unsigned_PY_LONG_LONG(x); + } + } +#if CYTHON_USE_PYLONG_INTERNALS +raise_neg_overflow: + return __Pyx_raise_neg_overflow___Pyx_PyLong_As_unsigned_PY_LONG_LONG(); +raise_overflow: + return __Pyx_raise_overflow___Pyx_PyLong_As_unsigned_PY_LONG_LONG(); +#endif +} +static unsigned PY_LONG_LONG __Pyx_NonPyLong___Pyx_PyLong_As_unsigned_PY_LONG_LONG(PyObject *x) { + unsigned PY_LONG_LONG val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (unsigned PY_LONG_LONG) -1; + val = __Pyx_PyLong_As_unsigned_PY_LONG_LONG(tmp); + Py_DECREF(tmp); + return val; +} +static CYTHON_INLINE unsigned PY_LONG_LONG __Pyx_PyLong_As_unsigned_PY_LONG_LONG(PyObject *x) { + if (likely(PyLong_Check(x))) { + return __Pyx_PyLong___Pyx_PyLong_As_unsigned_PY_LONG_LONG(x); + } else { + return __Pyx_NonPyLong___Pyx_PyLong_As_unsigned_PY_LONG_LONG(x); + } +} + +/* CIntFromPy */ +static long __Pyx_LargePyLong___Pyx_PyLong_As_long(PyObject *x); +static long __Pyx_raise_neg_overflow___Pyx_PyLong_As_long(void) { + const char* type_name = "long"; + PyErr_Format(PyExc_OverflowError, + "can't convert negative value to %.200s", type_name); + return (long) -1; +} +static long __Pyx_raise_overflow___Pyx_PyLong_As_long(void) { + const char* type_name = "long"; + PyErr_Format(PyExc_OverflowError, + "value too large to convert to %.200s", type_name); + return (long) -1; +} +static CYTHON_INLINE long __Pyx_PyULong___Pyx_PyLong_As_long(PyObject *x) { + const int is_unsigned = 1; +#if CYTHON_USE_PYLONG_INTERNALS + { + const digit* digits = __Pyx_PyLong_Digits(x); + const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); + if (size == 2 && (8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } else + if (size == 3 && (8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } else + if (size == 4 && (8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } else + {} + } +#elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if ((sizeof(long) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + return __Pyx_LargePyLong___Pyx_PyLong_As_long(x); +raise_neg_overflow: + return __Pyx_raise_neg_overflow___Pyx_PyLong_As_long(); +raise_overflow: + return __Pyx_raise_overflow___Pyx_PyLong_As_long(); +} +static CYTHON_INLINE long __Pyx_PySLong___Pyx_PyLong_As_long(PyObject *x) { + const int is_unsigned = 0; +#if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsNeg(x)) { + const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); + const digit* digits = __Pyx_PyLong_Digits(x); + if (size == 2 && (8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + long ival = - (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + __PYX_VERIFY_RETURN_INT(long, long, ival) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long) -1) * (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } else + if (size == 3 && (8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + long ival = - (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + __PYX_VERIFY_RETURN_INT(long, long, ival) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long) -1) * (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } else + if (size == 4 && (8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 4 * PyLong_SHIFT)) { + long ival = - (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + __PYX_VERIFY_RETURN_INT(long, long, ival) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long) -1) * (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } else + {} + } else { + const Py_ssize_t size = __Pyx_PyLong_DigitCount(x); + const digit* digits = __Pyx_PyLong_Digits(x); + if (size == 2 && (8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } else + if (size == 3 && (8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } else + if (size == 4 && (8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } else + {} + } +#endif + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + if ((sizeof(long) <= sizeof(int)) && (sizeof(int) < sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(long, int, PyLong_AsInt(x)) + } else + #endif + if ((sizeof(long) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + return __Pyx_LargePyLong___Pyx_PyLong_As_long(x); +raise_neg_overflow: + return __Pyx_raise_neg_overflow___Pyx_PyLong_As_long(); +raise_overflow: + return __Pyx_raise_overflow___Pyx_PyLong_As_long(); +} +static long __Pyx_LargePyLong___Pyx_PyLong_As_long(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + long val; + int ret = -1; +#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } +#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); + if ((0)) goto raise_overflow; +#else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (long) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (long) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = v; + } + v = NULL; + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((long) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; +done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + if (unlikely(ret)) + return (long) -1; + return val; +raise_overflow: + return __Pyx_raise_overflow___Pyx_PyLong_As_long(); +} +static CYTHON_INLINE long __Pyx_PyLong___Pyx_PyLong_As_long(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + #if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else + #endif + { + return __Pyx_PyULong___Pyx_PyLong_As_long(x); + } + } else { + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else + #endif + { + return __Pyx_PySLong___Pyx_PyLong_As_long(x); + } + } +#if CYTHON_USE_PYLONG_INTERNALS +raise_neg_overflow: + return __Pyx_raise_neg_overflow___Pyx_PyLong_As_long(); +raise_overflow: + return __Pyx_raise_overflow___Pyx_PyLong_As_long(); +#endif +} +static long __Pyx_NonPyLong___Pyx_PyLong_As_long(PyObject *x) { + long val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (long) -1; + val = __Pyx_PyLong_As_long(tmp); + Py_DECREF(tmp); + return val; +} +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) { + if (likely(PyLong_Check(x))) { + return __Pyx_PyLong___Pyx_PyLong_As_long(x); + } else { + return __Pyx_NonPyLong___Pyx_PyLong_As_long(x); + } +} + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#if !CYTHON_COMPILING_IN_PYPY + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); +#else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL, *from_bytes_str = NULL;; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + from_bytes_str = PyUnicode_FromStringAndSize("from_bytes", 10); + if (!from_bytes_str) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[] = { (PyObject*)&PyLong_Type, py_bytes, order_str, Py_True }; + if (!is_unsigned) { + PyObject *signed_str = PyUnicode_FromStringAndSize("signed", 6); + if (!signed_str) goto limited_bad; +#if CYTHON_VECTORCALL + kwds = PyTuple_Pack(1, signed_str); +#else + { + PyObject *keys[] = {signed_str}; + PyObject *values[] = {Py_True}; + kwds = __Pyx_MakeKwargDict(keys, values, 1); + } +#endif + Py_DECREF(signed_str); + if (unlikely(!kwds)) goto limited_bad; + } + result = __Pyx_Object_VectorcallMethodKwds(from_bytes_str, args, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes_str); + return result; +#endif + } +} + +/* UpdateUnpickledDict */ +static int __Pyx__UpdateUnpickledDict(PyObject *obj, PyObject *state, Py_ssize_t index) { + PyObject *state_dict = __Pyx_PySequence_ITEM(state, index); + if (unlikely(!state_dict)) { + return -1; + } + int non_empty = PyObject_IsTrue(state_dict); + if (non_empty == 0) { + Py_DECREF(state_dict); + return 0; + } else if (unlikely(non_empty == -1)) { + return -1; + } + PyObject *dict; + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + dict = PyObject_GetAttrString(obj, "__dict__"); + #else + dict = PyObject_GenericGetDict(obj, NULL); + #endif + if (unlikely(!dict)) { + Py_DECREF(state_dict); + return -1; + } + int result; + if (likely(PyDict_CheckExact(dict))) { + result = PyDict_Update(dict, state_dict); + } else { + PyObject *obj_result = __Pyx_PyObject_CallMethod1(dict, __pyx_mstate_global->__pyx_n_u_update, state_dict); + if (likely(obj_result)) { + Py_DECREF(obj_result); + result = 0; + } else { + result = -1; + } + } + Py_DECREF(state_dict); + Py_DECREF(dict); + return result; +} +static int __Pyx_UpdateUnpickledDict(PyObject *obj, PyObject *state, Py_ssize_t index) { + Py_ssize_t state_size = __Pyx_PyTuple_GET_SIZE(state); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(state_size == -1)) return -1; + #endif + if (state_size <= index) { + return 0; + } + return __Pyx__UpdateUnpickledDict(obj, state, index); +} + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_unsigned_PY_LONG_LONG(unsigned PY_LONG_LONG value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const unsigned PY_LONG_LONG neg_one = (unsigned PY_LONG_LONG) -1, const_zero = (unsigned PY_LONG_LONG) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(unsigned PY_LONG_LONG) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(unsigned PY_LONG_LONG) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#if !CYTHON_COMPILING_IN_PYPY + } else if (sizeof(unsigned PY_LONG_LONG) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(unsigned PY_LONG_LONG) <= sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(unsigned PY_LONG_LONG) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(unsigned PY_LONG_LONG), + little, !is_unsigned); +#else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL, *from_bytes_str = NULL;; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned PY_LONG_LONG)); + if (!py_bytes) goto limited_bad; + from_bytes_str = PyUnicode_FromStringAndSize("from_bytes", 10); + if (!from_bytes_str) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[] = { (PyObject*)&PyLong_Type, py_bytes, order_str, Py_True }; + if (!is_unsigned) { + PyObject *signed_str = PyUnicode_FromStringAndSize("signed", 6); + if (!signed_str) goto limited_bad; +#if CYTHON_VECTORCALL + kwds = PyTuple_Pack(1, signed_str); +#else + { + PyObject *keys[] = {signed_str}; + PyObject *values[] = {Py_True}; + kwds = __Pyx_MakeKwargDict(keys, values, 1); + } +#endif + Py_DECREF(signed_str); + if (unlikely(!kwds)) goto limited_bad; + } + result = __Pyx_Object_VectorcallMethodKwds(from_bytes_str, args, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes_str); + return result; +#endif + } +} + +/* CheckUnpickleChecksum */ +static int __Pyx_CheckUnpickleChecksum(long checksum, long checksum1, long checksum2, long checksum3, const char *members) { + int found = 0; + found |= checksum1 == checksum; + found |= checksum2 == checksum; + found |= checksum3 == checksum; + if (likely(found)) + return 0; + __Pyx_RaiseUnpickleChecksumError(checksum, checksum1, checksum2, checksum3, members); + return -1; +} + +/* GetRuntimeVersion */ +#if __PYX_LIMITED_VERSION_HEX < 0x030b0000 +void __Pyx_init_runtime_version(void) { + if (__Pyx_cached_runtime_version == 0) { + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; + } + version += factor * digit; + if (rt_version[i] != '.') + break; + digit = 0; + factor >>= 8; + ++i; + } + __Pyx_cached_runtime_version = version; + } +} +#endif +static unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + return Py_Version & ~0xFFUL; +#else + return __Pyx_cached_runtime_version; +#endif +} + +/* CheckBinaryVersion */ +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); + return PyErr_WarnEx(NULL, message, 1); + } +} + +/* NewCodeObj */ +#if CYTHON_COMPILING_IN_LIMITED_API + static PyObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *exception_table = NULL; + PyObject *types_module=NULL, *code_type=NULL, *result=NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + PyObject *version_info; + PyObject *py_minor_version = NULL; + #endif + long minor_version = 0; + #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); + } + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (!result) { + PyObject *exc_type, *exc_value, *exc_tb; + PyErr_Fetch(&exc_type, &exc_value, &exc_tb); + if (PyErr_WarnFormat( + PyExc_RuntimeWarning, 1, + "Code object creation failed in Cython module: %S\nTry recompiling with a more recent version of Cython.", + exc_value ? exc_value : exc_type) == 0) { + result = Py_None; + Py_INCREF(result); + } + Py_DECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_tb); + } + return result; + } +#elif PY_VERSION_HEX >= 0x030B0000 + static PyCodeObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030c00A1 + if (likely(result)) + result->_co_firsttraceable = 0; + #endif + return result; + } +#elif !CYTHON_COMPILING_IN_PYPY + #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx__PyCode_New(a, p, 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) +#endif +static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + PyObject *line_table, + PyObject *tuple_dedup_map +) { + PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL; + Py_ssize_t var_count = (Py_ssize_t) descr.nlocals; + PyObject *varnames_tuple = PyTuple_New(var_count); + if (unlikely(!varnames_tuple)) return NULL; + for (Py_ssize_t i=0; i < var_count; i++) { + Py_INCREF(varnames[i]); + if (__Pyx_PyTuple_SET_ITEM(varnames_tuple, i, varnames[i]) != (0)) goto done; + } + #if CYTHON_COMPILING_IN_LIMITED_API + varnames_tuple_dedup = PyDict_GetItem(tuple_dedup_map, varnames_tuple); + if (!varnames_tuple_dedup) { + if (unlikely(PyDict_SetItem(tuple_dedup_map, varnames_tuple, varnames_tuple) < 0)) goto done; + varnames_tuple_dedup = varnames_tuple; + } + #else + varnames_tuple_dedup = PyDict_SetDefault(tuple_dedup_map, varnames_tuple, varnames_tuple); + if (unlikely(!varnames_tuple_dedup)) goto done; + #endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(varnames_tuple_dedup); + #endif + if (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table != NULL && !CYTHON_COMPILING_IN_GRAAL) { + Py_ssize_t line_table_length = __Pyx_PyBytes_GET_SIZE(line_table); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(line_table_length == -1)) goto done; + #endif + Py_ssize_t code_len = (line_table_length * 2 + 4) & ~3LL; + code_bytes = PyBytes_FromStringAndSize(NULL, code_len); + if (unlikely(!code_bytes)) goto done; + char* c_code_bytes = PyBytes_AsString(code_bytes); + if (unlikely(!c_code_bytes)) goto done; + memset(c_code_bytes, 0, (size_t) code_len); + } + code_obj = (PyObject*) __Pyx__PyCode_New( + (int) descr.argcount, + (int) descr.num_posonly_args, + (int) descr.num_kwonly_args, + (int) descr.nlocals, + 0, + (int) descr.flags, + code_bytes ? code_bytes : __pyx_mstate_global->__pyx_empty_bytes, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + varnames_tuple_dedup, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + filename, + funcname, + (int) descr.first_line, + (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table) ? line_table : __pyx_mstate_global->__pyx_empty_bytes + ); +done: + Py_XDECREF(code_bytes); + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(varnames_tuple_dedup); + #endif + Py_DECREF(varnames_tuple); + return code_obj; +} + +/* DecompressString */ +CYTHON_UNUSED +static CYTHON_SMALL_CODE PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo) { +#ifdef __Pyx_DecompressString_UNUSED + CYTHON_UNUSED_VAR(s); + CYTHON_UNUSED_VAR(length); + CYTHON_UNUSED_VAR(algo); + return NULL; +#else + PyObject *module = NULL, *decompress, *compressed_bytes, *decompressed; + const char* module_name = algo == 3 ? "compression.zstd" : algo == 2 ? "bz2" : "zlib"; + PyObject *methodname = PyUnicode_FromString("decompress"); + if (unlikely(!methodname)) return NULL; + #if __PYX_LIMITED_VERSION_HEX >= 0x030e0000 + if (algo == 3) { + PyObject *fromlist = Py_BuildValue("[O]", methodname); + if (unlikely(!fromlist)) goto bad; + module = PyImport_ImportModuleLevel("compression.zstd", NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + } else + #endif + module = PyImport_ImportModule(module_name); + if (unlikely(!module)) goto import_failed; + decompress = PyObject_GetAttr(module, methodname); + if (unlikely(!decompress)) goto import_failed; + { + #ifdef __cplusplus + char *memview_bytes = const_cast(s); + #else + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wcast-qual" + #elif !defined(__INTEL_COMPILER) && defined(__GNUC__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wcast-qual" + #endif + char *memview_bytes = (char*) s; + #if defined(__clang__) + #pragma clang diagnostic pop + #elif !defined(__INTEL_COMPILER) && defined(__GNUC__) + #pragma GCC diagnostic pop + #endif + #endif + #if CYTHON_COMPILING_IN_LIMITED_API && !defined(PyBUF_READ) + int memview_flags = 0x100; + #else + int memview_flags = PyBUF_READ; + #endif + compressed_bytes = PyMemoryView_FromMemory(memview_bytes, length, memview_flags); + } + if (unlikely(!compressed_bytes)) { + Py_DECREF(decompress); + goto bad; + } + decompressed = PyObject_CallFunctionObjArgs(decompress, compressed_bytes, NULL); + Py_DECREF(compressed_bytes); + Py_DECREF(decompress); + Py_DECREF(module); + Py_DECREF(methodname); + return decompressed; +import_failed: + PyErr_Format(PyExc_ImportError, + "Failed to import '%.20s.decompress' - cannot initialise module strings. " + "String compression was configured with the C macro 'CYTHON_COMPRESS_STRINGS=%d'.", + module_name, algo); +bad: + Py_XDECREF(module); + Py_DECREF(methodname); + return NULL; +#endif +} + +/* DecompressString_LZSS */ +#ifndef __Pyx_DecompressString_LZSS_UNUSED +CYTHON_UNUSED +static CYTHON_SMALL_CODE size_t __pyx_lzss_decompress(const uint8_t* src, uint8_t* dst, size_t dst_len) { + size_t pos = 0, out_pos = 0; + while (1) { + uint32_t flags = src[pos++] | 0xFF00; + while (flags & 0x100) { + if (flags & 1) { + dst[out_pos++] = src[pos++]; + } else { + uint32_t lo = src[pos++], hi = src[pos++]; + uint32_t end_offset_of_last_occurrence, match_length; + if (!(lo & 0x80)) { + end_offset_of_last_occurrence = lo; + match_length = hi; + } else if (!(hi & 0x80)) { + end_offset_of_last_occurrence = 0x80 + (((hi << 2) & 0x180) | (lo & 0x7F)); + match_length = hi & 0x1F; + } else { + end_offset_of_last_occurrence = 0x80 + ((hi & 0x7F) << 7 | (lo & 0x7F)); + match_length = src[pos++]; + } + match_length += 3; + size_t ref_pos = out_pos - end_offset_of_last_occurrence - match_length; + memcpy(dst + out_pos, dst + ref_pos, match_length); + out_pos += match_length; + } + if (out_pos >= dst_len) return pos; + flags >>= 1; + } + } +} +#endif +static CYTHON_SMALL_CODE PyObject *__Pyx_DecompressString_LZSS(const char *s, size_t compressed_length, size_t uncompressed_length) { +#ifdef __Pyx_DecompressString_LZSS_UNUSED + CYTHON_UNUSED_VAR(s); + CYTHON_UNUSED_VAR(compressed_length); + CYTHON_UNUSED_VAR(uncompressed_length); + return NULL; +#else + PyObject *result; + unsigned char *result_data; + size_t src_length; + result = PyBytes_FromStringAndSize(NULL, (Py_ssize_t) uncompressed_length); + if (unlikely(!result)) return NULL; + result_data = __Pyx_PyBytes_AsWritableUString(result); + if (unlikely(!result_data)) goto bad; + src_length = __pyx_lzss_decompress((const uint8_t*) s, result_data, uncompressed_length); + if (unlikely(src_length != compressed_length)) goto decompression_failed; + return result; +decompression_failed: + PyErr_SetString(PyExc_RuntimeError, "LZSS string data decompression failed"); +bad: + Py_DECREF(result); + return NULL; +#endif +} + +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + { + const char* result; + Py_ssize_t unicode_length; + CYTHON_MAYBE_UNUSED_VAR(unicode_length); // only for __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (unlikely(PyArg_Parse(o, "s#", &result, length) < 0)) return NULL; + #else + result = PyUnicode_AsUTF8AndSize(o, length); + #endif + #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + unicode_length = PyUnicode_GetLength(o); + if (unlikely(unicode_length < 0)) return NULL; + if (unlikely(unicode_length != *length)) { + PyUnicode_AsASCIIString(o); + return NULL; + } + #endif + return result; + } +#else +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif +} +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + if (PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif + if (PyByteArray_Check(o)) { +#if (CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) || (CYTHON_COMPILING_IN_PYPY && (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))) + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); +#else + *length = PyByteArray_Size(o); + if (*length == -1) return NULL; + return PyByteArray_AsString(o); +#endif + } else + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_LongWrongResultType(PyObject* result) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(result)); + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 + if (unlikely(!result_type_name)) goto bad; + #endif + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); + goto bad; + } + __Pyx_DECREF_TypeName(result_type_name); + return result; + } + PyErr_Format(PyExc_TypeError, + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ")", + result_type_name); + __Pyx_DECREF_TypeName(result_type_name); +bad: + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + PyObject *res = NULL; + if (likely(PyLong_Check(x))) + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + if (likely(m && m->nb_int)) { + res = m->nb_int(x); + } +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Long(x); + } +#endif + if (likely(res)) { + if (unlikely(!PyLong_CheckExact(res))) { + return __Pyx_PyNumber_LongWrongResultType(res); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyLong_AsSsize_t(PyObject* b) { + #if CYTHON_USE_PYLONG_INTERNALS + Py_ssize_t ival; + const Py_ssize_t size = __Pyx_PyLong_DigitCount(b); + const int is_neg = __Pyx_PyLong_IsNeg(b); + const digit* digits = __Pyx_PyLong_Digits(b); + if (size == 0) return 0; + #if SIZEOF_SIZE_T * 8 > 1 * PyLong_SHIFT + if (size == 1) { + ival = (Py_ssize_t) (((size_t)digits[0])); + } else + #endif + #if SIZEOF_SIZE_T * 8 > 2 * PyLong_SHIFT + if (size == 2) { + ival = (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } else + #endif + #if SIZEOF_SIZE_T * 8 > 3 * PyLong_SHIFT + if (size == 3) { + ival = (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } else + #endif + #if SIZEOF_SIZE_T * 8 > 4 * PyLong_SHIFT + if (size == 4) { + ival = (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } else + #endif + return PyLong_AsSsize_t(b); + return is_neg ? -ival : ival; + #else + return PyLong_AsSsize_t(b); + #endif +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + if (likely(PyLong_Check(b))) { + return __Pyx_PyLong_AsSsize_t(b); + } else { + Py_ssize_t ival; + PyObject *x = PyNumber_Index(b); + if (unlikely(!x)) return -1; + ival = __Pyx_PyLong_AsSsize_t(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { + return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyLong_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b) { + CYTHON_UNUSED_VAR(b); + return __Pyx_NewRef(Py_None); +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return __Pyx_NewRef(b ? Py_True: Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t ival) { + return PyLong_FromSize_t(ival); +} + + +/* MultiPhaseInitModuleState */ +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +#ifndef CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +#if (CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000) + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 1 +#else + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 0 +#endif +#endif +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE && !CYTHON_ATOMICS +#error "Module state with PEP489 requires atomics. Currently that's one of\ + C11, C++11, gcc atomic intrinsics or MSVC atomic intrinsics" +#endif +#if !CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +#define __Pyx_ModuleStateLookup_Lock() +#define __Pyx_ModuleStateLookup_Unlock() +#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 +static PyMutex __Pyx_ModuleStateLookup_mutex = {0}; +#define __Pyx_ModuleStateLookup_Lock() PyMutex_Lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() PyMutex_Unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(__cplusplus) && __cplusplus >= 201103L +#include +static std::mutex __Pyx_ModuleStateLookup_mutex; +#define __Pyx_ModuleStateLookup_Lock() __Pyx_ModuleStateLookup_mutex.lock() +#define __Pyx_ModuleStateLookup_Unlock() __Pyx_ModuleStateLookup_mutex.unlock() +#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201112L) && !defined(__STDC_NO_THREADS__) +#include +static mtx_t __Pyx_ModuleStateLookup_mutex; +static once_flag __Pyx_ModuleStateLookup_mutex_once_flag = ONCE_FLAG_INIT; +static void __Pyx_ModuleStateLookup_initialize_mutex(void) { + mtx_init(&__Pyx_ModuleStateLookup_mutex, mtx_plain); +} +#define __Pyx_ModuleStateLookup_Lock()\ + call_once(&__Pyx_ModuleStateLookup_mutex_once_flag, __Pyx_ModuleStateLookup_initialize_mutex);\ + mtx_lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() mtx_unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(HAVE_PTHREAD_H) +#include +static pthread_mutex_t __Pyx_ModuleStateLookup_mutex = PTHREAD_MUTEX_INITIALIZER; +#define __Pyx_ModuleStateLookup_Lock() pthread_mutex_lock(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() pthread_mutex_unlock(&__Pyx_ModuleStateLookup_mutex) +#elif defined(_WIN32) +#include // synchapi.h on its own doesn't work +static SRWLOCK __Pyx_ModuleStateLookup_mutex = SRWLOCK_INIT; +#define __Pyx_ModuleStateLookup_Lock() AcquireSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) +#define __Pyx_ModuleStateLookup_Unlock() ReleaseSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) +#else +#error "No suitable lock available for CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE.\ + Requires C standard >= C11, or C++ standard >= C++11,\ + or pthreads, or the Windows 32 API, or Python >= 3.13." +#endif +typedef struct { + int64_t id; + PyObject *module; +} __Pyx_InterpreterIdAndModule; +typedef struct { + char interpreter_id_as_index; + Py_ssize_t count; + Py_ssize_t allocated; + __Pyx_InterpreterIdAndModule table[1]; +} __Pyx_ModuleStateLookupData; +#define __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE 32 +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static __pyx_atomic_int_type __Pyx_ModuleStateLookup_read_counter = 0; +#endif +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static __pyx_atomic_ptr_type __Pyx_ModuleStateLookup_data = 0; +#else +static __Pyx_ModuleStateLookupData* __Pyx_ModuleStateLookup_data = NULL; +#endif +static __Pyx_InterpreterIdAndModule* __Pyx_State_FindModuleStateLookupTableLowerBound( + __Pyx_InterpreterIdAndModule* table, + Py_ssize_t count, + int64_t interpreterId) { + __Pyx_InterpreterIdAndModule* begin = table; + __Pyx_InterpreterIdAndModule* end = begin + count; + if (begin->id == interpreterId) { + return begin; + } + while ((end - begin) > __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + __Pyx_InterpreterIdAndModule* halfway = begin + (end - begin)/2; + if (halfway->id == interpreterId) { + return halfway; + } + if (halfway->id < interpreterId) { + begin = halfway; + } else { + end = halfway; + } + } + for (; begin < end; ++begin) { + if (begin->id >= interpreterId) return begin; + } + return begin; +} +static PyObject *__Pyx_State_FindModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(PyInterpreterState_Get()); + if (interpreter_id == -1) return NULL; +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData* data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + { + __pyx_atomic_incr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + if (likely(data)) { + __Pyx_ModuleStateLookupData* new_data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_acquire(&__Pyx_ModuleStateLookup_data); + if (likely(data == new_data)) { + goto read_finished; + } + } + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + __Pyx_ModuleStateLookup_Lock(); + __pyx_atomic_incr_relaxed(&__Pyx_ModuleStateLookup_read_counter); + data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + __Pyx_ModuleStateLookup_Unlock(); + } + read_finished:; +#else + __Pyx_ModuleStateLookupData* data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_InterpreterIdAndModule* found = NULL; + if (unlikely(!data)) goto end; + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + found = data->table+interpreter_id; + } + } else { + found = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + } + end: + { + PyObject *result=NULL; + if (found && found->id == interpreter_id) { + result = found->module; + } +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); +#endif + return result; + } +} +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE +static void __Pyx_ModuleStateLookup_wait_until_no_readers(void) { + while (__pyx_atomic_load(&__Pyx_ModuleStateLookup_read_counter) != 0); +} +#else +#define __Pyx_ModuleStateLookup_wait_until_no_readers() +#endif +static int __Pyx_State_AddModuleInterpIdAsIndex(__Pyx_ModuleStateLookupData **old_data, PyObject* module, int64_t interpreter_id) { + Py_ssize_t to_allocate = (*old_data)->allocated; + while (to_allocate <= interpreter_id) { + if (to_allocate == 0) to_allocate = 1; + else to_allocate *= 2; + } + __Pyx_ModuleStateLookupData *new_data = *old_data; + if (to_allocate != (*old_data)->allocated) { + new_data = (__Pyx_ModuleStateLookupData *)realloc( + *old_data, + sizeof(__Pyx_ModuleStateLookupData)+(to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + PyErr_NoMemory(); + return -1; + } + for (Py_ssize_t i = new_data->allocated; i < to_allocate; ++i) { + new_data->table[i].id = i; + new_data->table[i].module = NULL; + } + new_data->allocated = to_allocate; + } + new_data->table[interpreter_id].module = module; + if (new_data->count < interpreter_id+1) { + new_data->count = interpreter_id+1; + } + *old_data = new_data; + return 0; +} +static void __Pyx_State_ConvertFromInterpIdAsIndex(__Pyx_ModuleStateLookupData *data) { + __Pyx_InterpreterIdAndModule *read = data->table; + __Pyx_InterpreterIdAndModule *write = data->table; + __Pyx_InterpreterIdAndModule *end = read + data->count; + for (; readmodule) { + write->id = read->id; + write->module = read->module; + ++write; + } + } + data->count = write - data->table; + for (; writeid = 0; + write->module = NULL; + } + data->interpreter_id_as_index = 0; +} +static int __Pyx_State_AddModule(PyObject* module, CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + int result = 0; + __Pyx_ModuleStateLookup_Lock(); +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *old_data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *old_data = __Pyx_ModuleStateLookup_data; +#endif + __Pyx_ModuleStateLookupData *new_data = old_data; + if (!new_data) { + new_data = (__Pyx_ModuleStateLookupData *)calloc(1, sizeof(__Pyx_ModuleStateLookupData)); + if (!new_data) { + result = -1; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = 1; + new_data->interpreter_id_as_index = 1; + } + __Pyx_ModuleStateLookup_wait_until_no_readers(); + if (new_data->interpreter_id_as_index) { + if (interpreter_id < __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + result = __Pyx_State_AddModuleInterpIdAsIndex(&new_data, module, interpreter_id); + goto end; + } + __Pyx_State_ConvertFromInterpIdAsIndex(new_data); + } + { + Py_ssize_t insert_at = 0; + { + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + new_data->table, new_data->count, interpreter_id); + assert(lower_bound); + insert_at = lower_bound - new_data->table; + if (unlikely(insert_at < new_data->count && lower_bound->id == interpreter_id)) { + lower_bound->module = module; + goto end; // already in table, nothing more to do + } + } + if (new_data->count+1 >= new_data->allocated) { + Py_ssize_t to_allocate = (new_data->count+1)*2; + new_data = + (__Pyx_ModuleStateLookupData*)realloc( + new_data, + sizeof(__Pyx_ModuleStateLookupData) + + (to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + result = -1; + new_data = old_data; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = to_allocate; + } + ++new_data->count; + int64_t last_id = interpreter_id; + PyObject *last_module = module; + for (Py_ssize_t i=insert_at; icount; ++i) { + int64_t current_id = new_data->table[i].id; + new_data->table[i].id = last_id; + last_id = current_id; + PyObject *current_module = new_data->table[i].module; + new_data->table[i].module = last_module; + last_module = current_module; + } + } + end: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, new_data); +#else + __Pyx_ModuleStateLookup_data = new_data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return result; +} +static int __Pyx_State_RemoveModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + __Pyx_ModuleStateLookup_Lock(); +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); +#else + __Pyx_ModuleStateLookupData *data = __Pyx_ModuleStateLookup_data; +#endif + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + data->table[interpreter_id].module = NULL; + } + goto done; + } + { + __Pyx_ModuleStateLookup_wait_until_no_readers(); + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + if (!lower_bound) goto done; + if (lower_bound->id != interpreter_id) goto done; + __Pyx_InterpreterIdAndModule *end = data->table+data->count; + for (;lower_boundid = (lower_bound+1)->id; + lower_bound->module = (lower_bound+1)->module; + } + } + --data->count; + if (data->count == 0) { + free(data); + data = NULL; + } + done: +#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, data); +#else + __Pyx_ModuleStateLookup_data = data; +#endif + __Pyx_ModuleStateLookup_Unlock(); + return 0; +} +#endif + +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ +#endif /* Py_PYTHON_H */ diff --git a/aiohttp/_websocket/reader_c.pxd b/aiohttp/_websocket/reader_c.pxd deleted file mode 100644 index b9c07f71d23..00000000000 --- a/aiohttp/_websocket/reader_c.pxd +++ /dev/null @@ -1,132 +0,0 @@ -import cython - -from .mask cimport _websocket_mask_cython as websocket_mask - - -cdef unsigned int READ_HEADER -cdef unsigned int READ_PAYLOAD_LENGTH -cdef unsigned int READ_PAYLOAD_MASK -cdef unsigned int READ_PAYLOAD - -cdef unsigned long long MAX_PAYLOAD_LEN - -cdef int OP_CODE_NOT_SET -cdef int OP_CODE_CONTINUATION -cdef int OP_CODE_TEXT -cdef int OP_CODE_BINARY -cdef int OP_CODE_CLOSE -cdef int OP_CODE_PING -cdef int OP_CODE_PONG - -cdef int COMPRESSED_NOT_SET -cdef int COMPRESSED_FALSE -cdef int COMPRESSED_TRUE - -cdef object UNPACK_LEN3 -cdef object UNPACK_CLOSE_CODE -cdef object TUPLE_NEW - -cdef object WSMsgType - -cdef object WSMessageText -cdef object WSMessageTextBytes -cdef object WSMessageBinary -cdef object WSMessagePing -cdef object WSMessagePong -cdef object WSMessageClose - -cdef object WS_MSG_TYPE_TEXT -cdef object WS_MSG_TYPE_BINARY - -cdef set ALLOWED_CLOSE_CODES -cdef set MESSAGE_TYPES_WITH_CONTENT - -cdef tuple EMPTY_FRAME -cdef tuple EMPTY_FRAME_ERROR - -cdef unsigned int MSG_SIZE_OVERHEAD - -cdef class WebSocketDataQueue: - - cdef readonly unsigned int _size - cdef public object _protocol - cdef readonly unsigned int _limit - cdef object _loop - cdef bint _eof - cdef object _waiter - cdef object _exception - cdef public object _buffer - cdef object _get_buffer - cdef object _put_buffer - cdef readonly object _stalled_reader - - cdef void _release_waiter(self) - - @cython.locals(size="unsigned int") - cpdef void feed_data(self, object data) - - @cython.locals(size="unsigned int") - cdef _read_from_buffer(self) - -cdef class WebSocketReader: - - # cdef classes are not weak-referenceable without this; the queue parks a - # weakref here while parsing is stalled. - cdef object __weakref__ - cdef object _weak_self - - cdef WebSocketDataQueue queue - cdef unsigned int _max_msg_size - cdef bint _decode_text - - cdef Exception _exc - cdef bytearray _partial - cdef unsigned int _state - - cdef int _opcode - cdef bint _frame_fin - cdef int _frame_opcode - cdef list _payload_fragments - cdef bytearray _payload_buffer - cdef Py_ssize_t _max_fragments - cdef Py_ssize_t _frame_payload_len - - cdef bytes _tail - cdef bint _has_mask - cdef bytes _frame_mask - cdef Py_ssize_t _payload_bytes_to_read - cdef unsigned int _payload_len_flag - cdef int _compressed - cdef object _decompressobj - cdef bint _compress - - cpdef tuple feed_data(self, object data) - - @cython.locals( - is_continuation=bint, - fin=bint, - has_partial=bint, - payload_merged=bytes, - ) - cpdef void _handle_frame(self, bint fin, int opcode, object payload, int compressed) except * - - @cython.locals( - start_pos=Py_ssize_t, - data_len=Py_ssize_t, - length=Py_ssize_t, - chunk_size=Py_ssize_t, - chunk_len=Py_ssize_t, - data_len=Py_ssize_t, - data_cstr="const unsigned char *", - first_byte="unsigned char", - second_byte="unsigned char", - f_start_pos=Py_ssize_t, - f_end_pos=Py_ssize_t, - has_mask=bint, - fin=bint, - had_fragments=Py_ssize_t, - partial_len=Py_ssize_t, - frame_len="unsigned long long", - payload_bytearray=bytearray, - ) - cpdef void _feed_data(self, bytes data) except * diff --git a/aiohttp/_websocket/reader_py.py b/aiohttp/_websocket/reader_py.py deleted file mode 100644 index 00588632dc2..00000000000 --- a/aiohttp/_websocket/reader_py.py +++ /dev/null @@ -1,627 +0,0 @@ -"""Reader for WebSocket protocol versions 13 and 8.""" - -import asyncio -import builtins -import sys -import weakref -from collections import deque - -from ..base_protocol import BaseProtocol -from ..compression_utils import TooManyMembersError, ZLibDecompressor -from ..helpers import _EXC_SENTINEL, set_exception -from ..log import ws_logger -from ..streams import EofStream -from .helpers import UNPACK_CLOSE_CODE, UNPACK_LEN3, websocket_mask -from .models import ( - WS_DEFLATE_TRAILING, - WebSocketError, - WSCloseCode, - WSMessage, - WSMessageBinary, - WSMessageClose, - WSMessagePing, - WSMessagePong, - WSMessageText, - WSMessageTextBytes, - WSMsgType, -) - -# ABNORMAL_CLOSURE is used internally, should never be accepted from a client. -# https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.1 -ALLOWED_CLOSE_CODES = {int(i) for i in WSCloseCode} - { - int(WSCloseCode.ABNORMAL_CLOSURE) -} - -# States for the reader, used to parse the WebSocket frame -# integer values are used so they can be cythonized -READ_HEADER = 1 -READ_PAYLOAD_LENGTH = 2 -READ_PAYLOAD_MASK = 3 -READ_PAYLOAD = 4 - -# Largest declared payload length the reader can represent: the compiled -# reader stores it in a Py_ssize_t, which holds 2**31-1 on the 32-bit builds -# (the win32 and armv7l wheels) and 2**63-1 everywhere else. -# TODO: Remove when we drop 32 bit support (and from reader_c.pxd). -MAX_PAYLOAD_LEN = sys.maxsize - -WS_MSG_TYPE_BINARY = WSMsgType.BINARY -WS_MSG_TYPE_TEXT = WSMsgType.TEXT - -# WSMsgType values unpacked so they can by cythonized to ints -OP_CODE_NOT_SET = -1 -OP_CODE_CONTINUATION = WSMsgType.CONTINUATION.value -OP_CODE_TEXT = WSMsgType.TEXT.value -OP_CODE_BINARY = WSMsgType.BINARY.value -OP_CODE_CLOSE = WSMsgType.CLOSE.value -OP_CODE_PING = WSMsgType.PING.value -OP_CODE_PONG = WSMsgType.PONG.value - -EMPTY_FRAME_ERROR = (True, b"") -EMPTY_FRAME = (False, b"") - -COMPRESSED_NOT_SET = -1 -COMPRESSED_FALSE = 0 -COMPRESSED_TRUE = 1 - -TUPLE_NEW = tuple.__new__ - -# Overhead added to each message to ensure that tiny messages can't use -# unreasonable amounts of memory. -MSG_SIZE_OVERHEAD = 128 - -STALLED_READER_COLLECTED = ( - "WebSocketReader was garbage collected while stalled; " - "callers of set_parser() must hold a strong reference" -) - -cython_int = int # Typed to int in Python, but cython with use a signed int in the pxd - - -class WebSocketDataQueue: - """WebSocketDataQueue resumes and pauses an underlying stream. - - It is a destination for WebSocket data. - """ - - def __init__( - self, protocol: BaseProtocol, limit: int, *, loop: asyncio.AbstractEventLoop - ) -> None: - self._size = 0 - self._protocol = protocol - self._limit = limit * 2 - self._loop = loop - self._eof = False - self._waiter: asyncio.Future[None] | None = None - self._exception: type[BaseException] | BaseException | None = None - self._buffer: deque[WSMessage] = deque() - self._get_buffer = self._buffer.popleft - self._put_buffer = self._buffer.append - self._stalled_reader: "weakref.ref[WebSocketReader] | None" = None - - def is_eof(self) -> bool: - return self._eof - - def exception(self) -> type[BaseException] | BaseException | None: - return self._exception - - def set_exception( - self, - exc: type[BaseException] | BaseException, - exc_cause: builtins.BaseException = _EXC_SENTINEL, - ) -> None: - self._eof = True - self._exception = exc - if (waiter := self._waiter) is not None: - self._waiter = None - set_exception(waiter, exc, exc_cause) - - def _release_waiter(self) -> None: - if (waiter := self._waiter) is None: - return - self._waiter = None - if not waiter.done(): - waiter.set_result(None) - - def feed_eof(self) -> None: - self._eof = True - self._release_waiter() - self._exception = None # Break cyclic references - - def feed_data(self, data: "WSMessage") -> None: - # Unbox into the typed local before adding, so Cython keeps the sum in - # C instead of boxing MSG_SIZE_OVERHEAD for a Python-level add. - size = data.size - self._size += size + MSG_SIZE_OVERHEAD - self._put_buffer(data) - self._release_waiter() - if self._size > self._limit and not self._protocol._reading_paused: - self._protocol.pause_reading() - - async def read(self) -> WSMessage: - if not self._buffer and not self._eof: - assert not self._waiter - self._waiter = self._loop.create_future() - try: - await self._waiter - except (asyncio.CancelledError, asyncio.TimeoutError): - self._waiter = None - raise - return self._read_from_buffer() - - def _read_from_buffer(self) -> WSMessage: - if self._buffer: - data = self._get_buffer() - size = data.size - self._size -= size + MSG_SIZE_OVERHEAD - if self._stalled_reader is not None and self._size <= self._limit // 2: - # Resume parsing once the queue drains to the low-water mark. - # Each resume re-slices the parser's unparsed tail, so waiting - # for headroom makes a drain cost one copy per batch of - # messages instead of one per message. - if (reader := self._stalled_reader()) is not None: - reader.feed_data(b"") - else: - # The stash died with the reader. Deliver what was already - # queued, then surface the contract violation on the next - # read instead of hanging. Log as well, since a caller that - # stops reading early never sees the deferred exception. A - # real failure that was already recorded stays the reported - # cause. - self._stalled_reader = None - ws_logger.warning(STALLED_READER_COLLECTED) - if self._exception is None: - self.set_exception(RuntimeError(STALLED_READER_COLLECTED)) - # Resuming the transport while a stash remains would admit - # another socket read into the tail for every couple of messages - # drained, moving the memory bound from the queue into the tail. - if ( - self._stalled_reader is None - and self._size < self._limit - and self._protocol._reading_paused - ): - self._protocol.resume_reading() - return data - if self._exception is not None: - raise self._exception - raise EofStream - - -class WebSocketReader: - def __init__( - self, - queue: WebSocketDataQueue, - max_msg_size: int, - compress: bool, - decode_text: bool, - ) -> None: - self.queue = queue - self._max_msg_size = max_msg_size - self._decode_text = decode_text - # Parked on the queue while parsing is stalled; created once so - # stalling does not allocate. - self._weak_self = weakref.ref(self) - - self._exc: Exception | None = None - self._partial = bytearray() - self._state = READ_HEADER - - self._opcode: int = OP_CODE_NOT_SET - self._frame_fin = False - self._frame_opcode: int = OP_CODE_NOT_SET - # Reads of an in-flight frame, joined once when it completes. - self._payload_fragments: list[bytes] = [] - # Fold reads into _payload_buffer past this count to bound the object - # count (bytes are bounded by max_msg_size). - self._max_fragments = max(1024, max_msg_size // 256) if max_msg_size else 0 - self._payload_buffer = bytearray() - self._frame_payload_len = 0 - - self._tail: bytes = b"" - self._has_mask = False - self._frame_mask: bytes | None = None - self._payload_bytes_to_read = 0 - self._payload_len_flag = 0 - self._compressed: int = COMPRESSED_NOT_SET - self._decompressobj: ZLibDecompressor | None = None - self._compress = compress - - def feed_eof(self) -> None: - self.queue.feed_eof() - - # data can be bytearray on Windows because proactor event loop uses bytearray - # and asyncio types this to Union[bytes, bytearray, memoryview] so we need - # coerce data to bytes if it is not - def feed_data(self, data: bytes | bytearray | memoryview) -> tuple[bool, bytes]: - if type(data) is not bytes: - data = bytes(data) - - if self._exc is not None: - return True, data - - try: - self._feed_data(data) - except Exception as exc: - self._exc = exc - set_exception(self.queue, exc) - return EMPTY_FRAME_ERROR - - return EMPTY_FRAME - - def _handle_frame( - self, - fin: bool, - opcode: int | cython_int, # Union intended: Cython pxd uses C int - payload: bytes | bytearray, - compressed: int | cython_int, # Union intended: Cython pxd uses C int - ) -> None: - msg: WSMessage - if opcode in {OP_CODE_TEXT, OP_CODE_BINARY, OP_CODE_CONTINUATION}: - # Validate continuation frames before processing - if opcode == OP_CODE_CONTINUATION and self._opcode == OP_CODE_NOT_SET: - raise WebSocketError( - WSCloseCode.PROTOCOL_ERROR, - "Continuation frame for non started message", - ) - - # load text/binary - if not fin: - # got partial frame payload - if opcode != OP_CODE_CONTINUATION: - self._opcode = opcode - self._partial += payload - return - - has_partial = bool(self._partial) - if opcode == OP_CODE_CONTINUATION: - opcode = self._opcode - self._opcode = OP_CODE_NOT_SET - # previous frame was non finished - # we should get continuation opcode - elif has_partial: - raise WebSocketError( - WSCloseCode.PROTOCOL_ERROR, - "The opcode in non-fin frame is expected " - f"to be zero, got {opcode!r}", - ) - - assembled_payload: bytes | bytearray - if has_partial: - assembled_payload = self._partial + payload - self._partial.clear() - else: - assembled_payload = payload - - # Decompress process must to be done after all packets - # received. - if compressed: - if not self._decompressobj: - self._decompressobj = ZLibDecompressor(suppress_deflate_header=True) - # XXX: It's possible that the zlib backend (isal is known to - # do this, maybe others too?) will return max_length bytes, - # but internally buffer more data such that the payload is - # >max_length, so we return one extra byte and if we're able - # to do that, then the message is too big. - try: - payload_merged = self._decompressobj.decompress_sync( - assembled_payload + WS_DEFLATE_TRAILING, - ( - self._max_msg_size + 1 - if self._max_msg_size - else self._max_msg_size - ), - ) - except TooManyMembersError as exc: - raise WebSocketError( - WSCloseCode.MESSAGE_TOO_BIG, - "Compressed message has too many deflate members", - ) from exc - if self._max_msg_size and len(payload_merged) > self._max_msg_size: - raise WebSocketError( - WSCloseCode.MESSAGE_TOO_BIG, - f"Decompressed message exceeds size limit {self._max_msg_size}", - ) - elif type(assembled_payload) is bytes: - payload_merged = assembled_payload - else: - payload_merged = bytes(assembled_payload) - - size = len(payload_merged) - if opcode == OP_CODE_TEXT: - if self._decode_text: - try: - text = payload_merged.decode("utf-8") - except UnicodeDecodeError as exc: - raise WebSocketError( - WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message" - ) from exc - - # XXX: The Text and Binary messages here can be a performance - # bottleneck, so we use tuple.__new__ to improve performance. - # This is not type safe, but many tests should fail in - # test_client_ws_functional.py if this is wrong. - msg = TUPLE_NEW(WSMessageText, (text, size, "", WS_MSG_TYPE_TEXT)) - else: - # Return raw bytes for TEXT messages when decode_text=False - msg = TUPLE_NEW( - WSMessageTextBytes, (payload_merged, size, "", WS_MSG_TYPE_TEXT) - ) - else: - msg = TUPLE_NEW( - WSMessageBinary, (payload_merged, size, "", WS_MSG_TYPE_BINARY) - ) - - self.queue.feed_data(msg) - elif opcode == OP_CODE_CLOSE: - payload_len = len(payload) - if payload_len >= 2: - close_code = UNPACK_CLOSE_CODE(payload[:2])[0] - # https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.2 - if close_code > 4999 or ( - close_code < 3000 and close_code not in ALLOWED_CLOSE_CODES - ): - raise WebSocketError( - WSCloseCode.PROTOCOL_ERROR, - f"Invalid close code: {close_code}", - ) - try: - close_message = payload[2:].decode("utf-8") - except UnicodeDecodeError as exc: - raise WebSocketError( - WSCloseCode.INVALID_TEXT, "Invalid UTF-8 text message" - ) from exc - msg = WSMessageClose( - data=close_code, size=payload_len, extra=close_message - ) - elif payload: - raise WebSocketError( - WSCloseCode.PROTOCOL_ERROR, - f"Invalid close frame: {fin} {opcode} {payload!r}", - ) - else: - msg = WSMessageClose(data=0, size=payload_len, extra="") - - self.queue.feed_data(msg) - elif opcode == OP_CODE_PING: - self.queue.feed_data( - WSMessagePing(data=bytes(payload), size=len(payload), extra="") - ) - elif opcode == OP_CODE_PONG: - self.queue.feed_data( - WSMessagePong(data=bytes(payload), size=len(payload), extra="") - ) - else: - raise WebSocketError( - WSCloseCode.PROTOCOL_ERROR, f"Unexpected opcode={opcode!r}" - ) - - def _feed_data(self, data: bytes) -> None: - """Return the next frame from the socket.""" - self.queue._stalled_reader = None - if self._tail: - data, self._tail = self._tail + data, b"" - - start_pos = 0 - data_len = len(data) - data_cstr = data - - while True: - if start_pos < data_len and self.queue._size > self.queue._limit: - # Over the high-water mark with unparsed bytes left: stash the - # remainder and stall. Gating on unparsed bytes keeps a read - # that ended on a frame boundary from arming an empty stall, - # which would hold the transport paused with nothing to drain. - self.queue._stalled_reader = self._weak_self - break - - # read header - if self._state == READ_HEADER: - if data_len - start_pos < 2: - break - first_byte = data_cstr[start_pos] - second_byte = data_cstr[start_pos + 1] - start_pos += 2 - - fin = (first_byte >> 7) & 1 - rsv1 = (first_byte >> 6) & 1 - rsv2 = (first_byte >> 5) & 1 - rsv3 = (first_byte >> 4) & 1 - opcode = first_byte & 0xF - - # frame-fin = %x0 ; more frames of this message follow - # / %x1 ; final frame of this message - # frame-rsv1 = %x0 ; - # 1 bit, MUST be 0 unless negotiated otherwise - # frame-rsv2 = %x0 ; - # 1 bit, MUST be 0 unless negotiated otherwise - # frame-rsv3 = %x0 ; - # 1 bit, MUST be 0 unless negotiated otherwise - # - # Remove rsv1 from this test for deflate development - if rsv2 or rsv3 or (rsv1 and not self._compress): - raise WebSocketError( - WSCloseCode.PROTOCOL_ERROR, - "Received frame with non-zero reserved bits", - ) - - if opcode not in { - OP_CODE_CONTINUATION, - OP_CODE_TEXT, - OP_CODE_BINARY, - OP_CODE_CLOSE, - OP_CODE_PING, - OP_CODE_PONG, - }: - raise WebSocketError( - WSCloseCode.PROTOCOL_ERROR, - f"Unexpected opcode={opcode!r}", - ) - - if opcode > 0x7 and fin == 0: - raise WebSocketError( - WSCloseCode.PROTOCOL_ERROR, - "Received fragmented control frame", - ) - - has_mask = (second_byte >> 7) & 1 - length = second_byte & 0x7F - - # Control frames MUST have a payload - # length of 125 bytes or less - if opcode > 0x7 and length > 125: - raise WebSocketError( - WSCloseCode.PROTOCOL_ERROR, - "Control frame payload cannot be larger than 125 bytes", - ) - - # Control frames (opcode > 0x7) may be interleaved between the - # fragments of a data message and never carry the per-message - # compressed bit, so they must not touch the compression state. - # https://datatracker.ietf.org/doc/html/rfc6455#section-5.4 - # https://datatracker.ietf.org/doc/html/rfc7692#section-6.1 - if opcode > 0x7: - if rsv1: - raise WebSocketError( - WSCloseCode.PROTOCOL_ERROR, - "Received frame with non-zero reserved bits", - ) - else: - # Set compress status if last package is FIN - # OR set compress status if this is first fragment - # Raise error if not first fragment with rsv1 = 0x1 - if self._frame_fin or self._compressed == COMPRESSED_NOT_SET: - self._compressed = COMPRESSED_TRUE if rsv1 else COMPRESSED_FALSE - elif rsv1: - raise WebSocketError( - WSCloseCode.PROTOCOL_ERROR, - "Received frame with non-zero reserved bits", - ) - self._frame_fin = bool(fin) - - self._frame_opcode = opcode - self._has_mask = bool(has_mask) - self._payload_len_flag = length - self._state = READ_PAYLOAD_LENGTH - - # read payload length - if self._state == READ_PAYLOAD_LENGTH: - len_flag = self._payload_len_flag - if len_flag == 126: - if data_len - start_pos < 2: - break - first_byte = data_cstr[start_pos] - second_byte = data_cstr[start_pos + 1] - start_pos += 2 - self._payload_bytes_to_read = first_byte << 8 | second_byte - elif len_flag > 126: - if data_len - start_pos < 8: - break - # The declared length is an unsigned 64-bit integer that - # does not necessarily fit _payload_bytes_to_read. - frame_len = UNPACK_LEN3(data, start_pos)[0] - if frame_len > MAX_PAYLOAD_LEN: - raise WebSocketError( - WSCloseCode.MESSAGE_TOO_BIG, - f"Message size {int(frame_len) + len(self._partial)} " - f"exceeds limit {self._max_msg_size or MAX_PAYLOAD_LEN}", - ) - self._payload_bytes_to_read = frame_len - start_pos += 8 - else: - self._payload_bytes_to_read = len_flag - - # Reject oversized data frames before buffering any payload - # bytes. Control frames are capped at 125 bytes (checked in - # READ_HEADER) so only text/binary/continuation need this. - if self._max_msg_size and self._frame_opcode in { - OP_CODE_TEXT, - OP_CODE_BINARY, - OP_CODE_CONTINUATION, - }: - # partial_len declared in reader_c.pxd to keep it in C. - partial_len = len(self._partial) - # payload_bytes_to_read is a signed Py_ssize_t C value, - # use subtraction here to avoid an integer overflow. - if self._payload_bytes_to_read >= self._max_msg_size - partial_len: - raise WebSocketError( - WSCloseCode.MESSAGE_TOO_BIG, - f"Message size {int(self._payload_bytes_to_read) + partial_len} " - f"exceeds limit {self._max_msg_size}", - ) - - self._state = READ_PAYLOAD_MASK if self._has_mask else READ_PAYLOAD - - # read payload mask - if self._state == READ_PAYLOAD_MASK: - if data_len - start_pos < 4: - break - self._frame_mask = data_cstr[start_pos : start_pos + 4] - start_pos += 4 - self._state = READ_PAYLOAD - - if self._state == READ_PAYLOAD: - chunk_len = data_len - start_pos - if self._payload_bytes_to_read >= chunk_len: - f_end_pos = data_len - self._payload_bytes_to_read -= chunk_len - else: - f_end_pos = start_pos + self._payload_bytes_to_read - self._payload_bytes_to_read = 0 - - had_fragments = self._frame_payload_len - self._frame_payload_len += f_end_pos - start_pos - f_start_pos = start_pos - start_pos = f_end_pos - - if self._payload_bytes_to_read != 0: - if f_start_pos < f_end_pos: # skip a header-only read - self._payload_fragments.append(data_cstr[f_start_pos:f_end_pos]) - if ( - self._max_fragments - and len(self._payload_fragments) > self._max_fragments - ): - # Fold to bound the object count. Not a pause: nothing - # resumes reading until the frame is queued. - self._payload_buffer += b"".join(self._payload_fragments) - self._payload_fragments.clear() - break - - payload: bytes | bytearray - if had_fragments: - self._payload_fragments.append(data_cstr[f_start_pos:f_end_pos]) - if self._payload_buffer: # folded prefix - self._payload_buffer += b"".join(self._payload_fragments) - if self._has_mask: - assert self._frame_mask is not None - websocket_mask(self._frame_mask, self._payload_buffer) - payload = self._payload_buffer - self._payload_buffer = bytearray() # detach; payload aliases it - elif self._has_mask: - assert self._frame_mask is not None - payload_bytearray = bytearray(b"".join(self._payload_fragments)) - websocket_mask(self._frame_mask, payload_bytearray) - payload = payload_bytearray - else: - payload = b"".join(self._payload_fragments) - self._payload_fragments.clear() - elif self._has_mask: - assert self._frame_mask is not None - payload_bytearray = data_cstr[f_start_pos:f_end_pos] # type: ignore[assignment] - if type(payload_bytearray) is not bytearray: - # Cython will do the conversion for us - # but we need to do it for Python and we - # will always get here in Python - payload_bytearray = bytearray(payload_bytearray) - websocket_mask(self._frame_mask, payload_bytearray) - payload = payload_bytearray - else: - payload = data_cstr[f_start_pos:f_end_pos] - - self._handle_frame( - self._frame_fin, self._frame_opcode, payload, self._compressed - ) - self._frame_payload_len = 0 - self._state = READ_HEADER - - # XXX: Cython needs slices to be bounded, so we can't omit the slice end here. - self._tail = data_cstr[start_pos:data_len] if start_pos < data_len else b"" diff --git a/pyproject.toml b/pyproject.toml index eb659f9b20e..0eff0bc4033 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,6 +6,9 @@ requires = [ # Don't bump too early to give distributors time to update # their setuptools version. "setuptools >= 67.0", + # Used for mypyc compilation. + # Mobile platforms have no wheels for mypy's compiled dependencies. + "mypy >= 2.3 ; platform_python_implementation == 'CPython' and sys_platform != 'ios' and sys_platform != 'android'", ] build-backend = "setuptools.build_meta" @@ -38,6 +41,7 @@ dependencies = [ "async-timeout >= 4.0, < 6.0 ; python_version < '3.11'", "frozenlist >= 1.1.1", "multidict >=4.5, < 7.0", + "mypy_extensions >= 1.0", "propcache >= 0.2.0", "typing_extensions >= 4.4 ; python_version < '3.13'", "yarl >= 1.17.0, < 2.0", diff --git a/requirements/runtime-deps.in b/requirements/runtime-deps.in index 3b57b27c57a..0cf37d6468b 100644 --- a/requirements/runtime-deps.in +++ b/requirements/runtime-deps.in @@ -10,6 +10,7 @@ Brotli >= 1.2; platform_python_implementation == 'CPython' and sys_platform != ' brotlicffi >= 1.2; platform_python_implementation != 'CPython' frozenlist >= 1.1.1 multidict >=4.5, < 7.0 +mypy_extensions >= 1.0 propcache >= 0.2.0 typing_extensions >= 4.4 ; python_version < '3.13' yarl >= 1.17.0, < 2.0 diff --git a/setup.cfg b/setup.cfg index 2a24abcb0cc..a036c1c0b27 100644 --- a/setup.cfg +++ b/setup.cfg @@ -20,7 +20,7 @@ per-file-ignores = docs/code/*:F841 # flake8-requirements -known-modules = proxy.py:[proxy] +known-modules = proxy.py:[proxy],mypy:[mypyc] requirements-file = requirements/test.in requirements-max-depth = 4 diff --git a/setup.py b/setup.py index 0933d969b00..3c802af565f 100644 --- a/setup.py +++ b/setup.py @@ -80,13 +80,31 @@ ["aiohttp/_http_writer.c"], define_macros=cython_trace_macros, ), - Extension( - "aiohttp._websocket.reader_c", - ["aiohttp/_websocket/reader_c.c"], - define_macros=cython_trace_macros, - ), ] +# Mobile platforms have no wheels for mypy's compiled dependencies. +if not NO_EXTENSIONS and sys.platform not in {"ios", "android"}: + from mypyc.build import mypycify + + # setuptools injects its vendored packages into sys.path inside PEP 517 + # build hooks; mypy would then find e.g. packaging under two module + # names and abort. Keep the vendored directory out of mypy's search + # path; setuptools' already-imported vendored modules are unaffected. + _sys_path = sys.path + sys.path = [p for p in sys.path if not p.endswith("_vendor")] + try: + extensions.extend( + mypycify( + [ + "--follow-imports=silent", + "aiohttp/_websocket/reader.py", + ], + opt_level="3", + ) + ) + finally: + sys.path = _sys_path + class ParallelBuildExt(build_ext): def build_extensions(self) -> None: diff --git a/tests/test_client_ws.py b/tests/test_client_ws.py index 44c71a5ec37..ad2ecfe5b98 100644 --- a/tests/test_client_ws.py +++ b/tests/test_client_ws.py @@ -357,6 +357,8 @@ async def test_close(ws_key: str, key_data: bytes) -> None: hdrs.SEC_WEBSOCKET_ACCEPT: ws_key, } mresp.connection.protocol.read_timeout = None + # The compiled reader unboxes this as bool when deciding to resume. + mresp.connection.protocol._reading_paused = False with mock.patch("aiohttp.client.WebSocketWriter") as WebSocketWriter: with mock.patch("aiohttp.client.os") as m_os: with mock.patch("aiohttp.client.ClientSession.request") as m_req: diff --git a/tests/test_websocket_parser.py b/tests/test_websocket_parser.py index 4bd1568194a..db505aa3b6a 100644 --- a/tests/test_websocket_parser.py +++ b/tests/test_websocket_parser.py @@ -20,12 +20,7 @@ websocket_mask, ) from aiohttp._websocket.models import WS_DEFLATE_TRAILING -from aiohttp._websocket.reader import WebSocketDataQueue -from aiohttp._websocket.reader_py import ( - MSG_SIZE_OVERHEAD, - WebSocketDataQueue as PyWebSocketDataQueue, - WebSocketReader as PyWebSocketReader, -) +from aiohttp._websocket.reader import MSG_SIZE_OVERHEAD, WebSocketDataQueue from aiohttp.base_protocol import BaseProtocol from aiohttp.compression_utils import ZLibBackend, ZLibBackendWrapper from aiohttp.helpers import DEFAULT_CHUNK_SIZE @@ -170,6 +165,16 @@ def test_feed_data_remembers_exception(parser: WebSocketReader) -> None: assert data == b"" +def test_feed_data_accepts_non_bytes_input( + out: WebSocketDataQueue, parser: WebSocketReader +) -> None: + """Proactor event loops deliver bytearray; asyncio also allows memoryview.""" + parser.feed_data(bytearray(build_frame(b"first", WSMsgType.TEXT))) + parser.feed_data(memoryview(build_frame(b"second", WSMsgType.TEXT))) + assert out._buffer[0].data == "first" + assert out._buffer[1].data == "second" + + def test_parse_frame(parser: PatchableWebSocketReader) -> None: parser.parse_frame(struct.pack("!BB", 0b00000001, 0b00000001)) res = parser.parse_frame(b"1")