aio-libs-aiohttp-9140

-rw-r--r-- 1 root root    118 Sep 30 16:07 .gitmodules
-rw-r--r-- 1 root root     44 Sep 30 16:07 .lgtm.yml
-rw-r--r-- 1 root root    985 Sep 30 16:07 .mypy.ini
-rw-r--r-- 1 root root     78 Sep 30 16:07 .pip-tools.toml
-rw-r--r-- 1 root root   2970 Sep 30 16:07 .pre-commit-config.yaml
-
…[2511 chars omitted]…
_request.py
./aiohttp/web_response.py
./aiohttp/web_routedef.py
./aiohttp/web_runner.py
./aiohttp/web_server.py
./aiohttp/web_urldispatcher.py
./aiohttp/web_ws.py
./aiohttp/worker.py
./aiohttp/_cparser.pxd
./aiohttp/_find_header.h
./aiohttp/_find_header.pxd
./aiohttp/_helpers.pyi
./aiohttp/_helpers.pyx
./aiohttp/_http_parser.pyx
./aiohttp/_http_writer.pyx
./aiohttp/_websocket.pyx
./aiohttp/__init__.py

tests/test_client_ws_functional.py
tests/test_connector.py

        """Cleanup unused transports."""
        if self._cleanup_handle:
            self._cleanup_handle.cancel()
            # _cleanup_handle should be unset, otherwise _release() will not
            # recreate it ever!
            self._cleanup_handle = None

        now = self._loop.time()
        timeout = self._keepalive_timeout

        if self._conns:
            connections = {}
            deadline = now - timeout
            for key, conns in self._conns.items():
                alive = []
                for proto, use_time in conns:
                  
…[8630 chars omitted]…
d(on_reuseconn)

    app = web.Application()
    app.router.add_route("GET", "/", handler)
    app.router.add_route("HEAD", "/", handler)

    connector = aiohttp.TCPConnector(limit=1)
    client = await aiohttp_client(
        app, connector=connector, trace_configs=[trace_config]
    )

    resp1 = await client.head("/")
    await resp1.read()
    resp2 = await client.get("/")
    await resp2.read()

from .helpers import (
    _EXC_SENTINEL,
    BaseTimerContext,
    set_exception,
    set_result,
    status_code_must_be_empty_body,
)
from .http import HttpResponseParser, RawResponseMessage, WebSocketReader
from .http_exceptions import HttpProcessingError
from .streams import EMPTY_PAYLOAD, DataQueue, StreamReader


class ResponseHandler(BaseProtocol, DataQueue[Tuple[RawResponseMessage, StreamReader]]):
    """Helper class to adapt between Protocol and StreamReader."""

    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
        BaseProtocol.__init__(self, loop=loop)
       
…[8628 chars omitted]…
:async def test_close_cancels_cleanup_handle(
1811:    assert conn._cleanup_handle is not None
1813:    assert conn._cleanup_handle is None
2456:    app.router.add_get("/", handler)
2554:    app.router.add_get("/", handler)
2596:    app.router.add_get("/", handler)
2656:    app.router.add_get("/", handler)
2683:    app.router.add_get("/", handler)
2718:    app.router.add_get("/", handler)
a52304d base

async def test_async_context_manager(loop: asyncio.AbstractEventLoop) -> None:
    conn = aiohttp.BaseConnector()

    async with conn as c:
        assert conn is c

    assert conn.closed


async def test_close(key: ConnectionKey) -> None:
    proto = create_mocked_conn()

    conn = aiohttp.BaseConnector()
    assert not conn.closed
    conn._conns[key] = [(proto, 0)]
    await conn.close()

    assert not conn._co
…[2264 chars omitted]…
[transport]
    await conn.close()


async def test_release_acquired(key: ConnectionKey) -> None:
    proto = create_mocked_conn()
    conn = aiohttp.BaseConnector(limit=5)
43:    proto.data_received(b"HTTP\r\n\r\n")
55:    proto.data_received(
74:    proto.data_received(b"HTTP/1.1 200 Ok\r\n\r\n")
92:    proto.data_received(b"0000")
96:    proto.data_received(b"1111")
106:    proto.data_received(b"")

        else:
            available = 1

        return available

    async def connect(
        self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout"
    ) -> Connection:
        """Get from pool or create new connection."""
        key = req.connection_key
        available = self._available_connections(key)

        # Wait if there are no available connections or if there are/were
        # waiters (i
…[6523 chars omitted]…
-> None:
    proto = ResponseHandler(loop=loop)
    proto.set_response_params(read_timeout=1)
    proto.start_timeout()
    assert proto._read_timeout_handle is not None
    proto._drop_timeout()
    assert proto._read_timeout_handle is None


async def test_reschedule_timeout(loop: asyncio.AbstractEventLoop) -> None:
    proto = ResponseHandler(loop=loop)
    proto.set_response_params(read_timeout=1)

tests/test_web_request.py:251:def test_non_keepalive_on_closing() -> None:
tests/test_web_websocket_functional.py:919:        assert request.protocol._keepalive
tests/test_web_websocket_functional.py:921:        assert not request.protocol._keepalive
tests/test_web_websocket_functional.py:922:        assert not request.protocol._keepalive_handle

        manager = self._manager
        assert manager is not None
        keepalive_timeout = self._keepalive_timeout
        resp = None
        assert self._request_factory is not None
        assert self._request_handler is not None

        while not self._force_close:
            if not self._messages:
                try:
                    # wait for next request
              
…[6907 chars omitted]…
waiter:
425:            self._waiter.cancel()
430:        if self._waiter:
431:            self._waiter.cancel()
463:        if self._waiter:
472:        self._handler_waiter = self._loop.create_future()
497:            self._handler_waiter.set_result(None)
524:                    self._waiter = loop.create_future()
525:                    await self._waiter
529:                    self._waiter = None

aiohttp/__init__.py                         26      8      2      1    68%
aiohttp/abc.py                              98      2     66      0    99%
aiohttp/base_protocol.py                    67     36     24      3    40%
aiohttp/client.py                          521    229    218     44    52%
aiohttp/client_exceptions.py    
…[8316 chars omitted]…
epalive_server_force_close_connection[pyloop]
0.02s call     tests/test_client_functional.py::test_handle_keepalive_on_closed_connection
0.01s teardown tests/test_client_functional.py::test_keepalive_after_head_requests_success[pyloop]
0.01s teardown tests/test_client_functional.py::test_keepalive_closed_by_server[pyloop]
====================== 15 passed, 218 deselected in 6.72s ======================

.....                                                                    [100%]

================================== XFAILURES ===================================
____________________ test_http10_keep_alive_default[pyloop] ____________________

aiohttp_client = <fun
…[8629 chars omitted]…
keepalive)
             return
 
-        # handler in idle state
-        if self._waiter:
+        # The waiter can still be set after data_received() has queued a
+        # request and woken it up.  Do not close a connection while there is
+        # a request waiting to be processed.
+        if self._waiter and not self._messages:
             self.force_close()
 
     async def _handle_request(

1.00s call     tests/test_client_functional.py::test_timeout_on_reading_data[pyloop]
0.51s call     tests/test_client_functional.py::test_timeout_with_full_buffer[pyloop]
0.51s call     tests/test_client_functional.py::test_no_error_on_conn_clos
…[777 chars omitted]…
sent only in Windows
XFAIL tests/test_client_functional.py::test_broken_connection[pyloop]
XFAIL tests/test_client_functional.py::test_header_too_large_error[pyloop] - #8395 Error message regression for large headers in 3.9.4
XFAIL tests/test_connector.py::test_del_with_scheduled_cleanup[pyloop]
================== 368 passed, 4 skipped, 3 xfailed in 26.09s ==================
 M aiohttp/web_protocol.py

-rw-r--r-- 1 root root    118 Sep 30 16:09 .gitmodules
-rw-r--r-- 1 root root     44 Sep 30 16:09 .lgtm.yml
-rw-r--r-- 1 root root    985 Sep 30 16:09 .mypy.ini
-rw-r--r-- 1 root root     78 Sep 30 16:09 .pip-tools.toml
-rw-r--r-- 1 root root   2970 Sep 30 16:09 .pre-commit-config.yaml
-
…[2511 chars omitted]…
_request.py
./aiohttp/web_response.py
./aiohttp/web_routedef.py
./aiohttp/web_runner.py
./aiohttp/web_server.py
./aiohttp/web_urldispatcher.py
./aiohttp/web_ws.py
./aiohttp/worker.py
./aiohttp/_cparser.pxd
./aiohttp/_find_header.h
./aiohttp/_find_header.pxd
./aiohttp/_helpers.pyi
./aiohttp/_helpers.pyx
./aiohttp/_http_parser.pyx
./aiohttp/_http_writer.pyx
./aiohttp/_websocket.pyx
./aiohttp/__init__.py

from http.cookies import SimpleCookie
from itertools import cycle, islice
from time import monotonic
from types import TracebackType
from typing import (
    TYPE_CHECKING,
    Any,
    Awaitable,
    Callable,
    DefaultDict,
    Dict,
    Iterator,
    List,
    Literal,
    Optional,
    Sequence,
    Set,
    Tuple,
    Type,
    Union,
    cast,
)

import aiohappyeyeballs

from . import hdrs, helpers
from .abc import AbstractResolver, ResolveResult
from .client_exceptions import (
    ClientConnectionError,
    ClientConnectorCertificateError,
    ClientConnectorError,
    ClientConnectorSSLError,
    ClientHttpProxyError,
    ClientProxyConn
…[7221 chars omitted]…
lf)
        context = {
            "connector": self,
            "connections": conns,
            "message": "Unclosed connector",
        }
        if self._source_traceback is not None:
            context["source_traceback"] = self._source_traceback
        self._loop.call_exception_handler(context)

    async def __aenter__(self) -> "BaseConnector":
        return self

    async def __aexit__(

from aiohttp.typedefs import Handler


@pytest.fixture
def here() -> pathlib.Path:
    return pathlib.Path(__file__).parent


@pytest.fixture
def fname(here: pathlib.Path) -> pathlib.Path:
    return here / "conftest.py"


async def test_keepalive_two_requests_success(aiohttp_client: AiohttpClient) -> None:
    async def handler(request: web.Request) -> web.Response:
        body = await request.read()
        assert b"" == body
        return web.Response(
…[6167 chars omitted]…
  await conn.close()


async def test_connect_with_limit_and_limit_per_host(
    loop: asyncio.AbstractEventLoop, key: ConnectionKey
) -> None:
    proto = create_mocked_conn(loop)
    proto.is_connected.return_value = True

    req = ClientRequest("GET", URL("http://localhost:80"), loop=loop)

    conn = aiohttp.BaseConnector(limit=1000, limit_per_host=1)
    conn._conns[key] = [(proto, loop.time())]

1531:async def test_cleanup(key: ConnectionKey) -> None:
1544:    existing_handle = conn._cleanup_handle = mock.Mock()
1546:    conn._cleanup()
1549:    assert conn._cleanup_handle is None
1552:async def test_cleanup_close_ssl_transport(
1
…[8391 chars omitted]…
der] = None
                for message, payload in messages:
                    if message.should_close:
                        self._should_close = True

                    self._payload = payload

                    if self._skip_payload or status_code_must_be_empty_body(
                        message.code
                    ):
                        self.feed_data((message, EMPTY_PAYLOAD))

                if payload is not None:
                    # new message(s) was processed
                    # register timeout handler unsubscribing
         
…[4061 chars omitted]…
loop, "__dict__"):
        pytest.skip("can not override loop attributes")

    m = mocker.spy(loop, "call_at")
    conn = aiohttp.BaseConnector(enable_cleanup_closed=True)
43:    proto.data_received(b"HTTP\r\n\r\n")
55:    proto.data_received(
74:    proto.data_received(b"HTTP/1.1 200 Ok\r\n\r\n")
92:    proto.data_received(b"0000")
96:    proto.data_received(b"1111")
106:    proto.data_received(b"")

            self._message_tail = b""

    def eof_received(self) -> None:
        pass

    def data_received(self, data: bytes) -> None:
        if self._force_close or self._close:
            return
        # parse http messages
        messages: Sequence[_MsgType]
        if self._payload_parser is None and not self._upgrade:
            assert self._request_parser is not None
            try:
                messages, upgraded, tail = self._request_parser.feed_data(data)
            except HttpPr
…[8629 chars omitted]…
._keepalive_handle is not None:
            self._keepalive_handle.cancel()

        if self._current_request is not None:
            if exc is None:
                exc = ConnectionResetError("Connection lost")
            self._current_request._cancel(exc)

        if handler_cancellation and self._task_handler is not None:
            self._task_handler.cancel()

        self._task_handler = None

        manager = self._manager
        assert manager is not None
        keepalive_timeout = self._keepalive_timeout
        resp = None
        assert self._request_factory is not None
        assert self._request_handler is not None

        while not self._force_close:
            if not self._messages:
                try:
                    # wait for next request
              
…[4172 chars omitted]…
lose transport if no handlers left
        if not self._force_close:
            self._task_handler = None
            if self.transport is not None:
                self.transport.close()

    async def finish_response(
        self, request: BaseRequest, resp: StreamResponse, start_time: float
    ) -> Tuple[StreamResponse, bool]:
sed: can't read tests/test_web_protocol.py: No such file or directory

aiohttp/__init__.py                         26      8      2      1    68%
aiohttp/abc.py                              98      2     66      0    99%
aiohttp/base_protocol.py                    67     36     24      3    40%
aiohttp/client.py                          521    229    218     44    52%
aiohttp/client_exceptions.py    
…[8630 chars omitted]…
ransport[pyloop]
0.02s teardown tests/test_connector.py::test_cleanup_closed[pyloop]
0.02s call     tests/test_connector.py::test_connect_waiters_cleanup_key_error[pyloop]
=========================== short test summary info ============================
XFAIL tests/test_connector.py::test_del_with_scheduled_cleanup[pyloop]
================ 11 passed, 130 deselected, 1 xfailed in 6.09s =================

================================== XFAILURES ===================================
____________________ test_http10_keep_alive_default[pyloop] ____________________

aiohttp_client = <function aiohttp_client.<locals>.go at 0x791895a6d300>

    @pytest.mark.xfail
    async def test_http10_keep_alive_default(aiohttp_client: Any) -> None:
        a
…[8629 chars omitted]…
  return
 
-        # handler in idle state
-        if self._waiter:
+        # The waiter can still be set after data_received() has queued a
+        # request and woken it up, but before the request handler gets a
+        # chance to resume.  Do not close a connection in that window.
+        if self._waiter and not self._messages:
             self.force_close()
 
     async def _handle_request(

        loop = self._loop
        now = loop.time()
        close_time = self._next_keepalive_close_time
        if now <= close_time:
            # Keep alive close check fired too early, reschedule
            self._keepalive_handle = loop.call_at(close_time, self._process_keepalive)
            return

        # The waiter can still be set after data_received() has queued a
        # request and woken it up, but before the request handler gets a
        # chance to resume.  Do not close a connection in that window.
        if self._waiter and not self._messages:
            self.force_close()

    async def _handle_request(
        self,
        request: _Request,

examples
pyproject.toml
requirements
setup.cfg
setup.py
tests
tools
vendor
==================================
Async http client/server framework
==================================

.. image:: https://raw.githubusercontent.com/aio-libs/aiohttp/master/docs/aiohttp-plain.svg
   :height: 64px
   :width: 64px
   :alt: aiohttp logo

|

.. image:: https://github.com/aio-libs/aiohttp/workflows/CI/badge.svg
   :target: https://github.com/aio-libs/aiohttp/actions?query=workflow%3ACI
   :alt: GitHub Actions status for master branch

.. image:: https://codecov.io/gh/aio-libs/aiohttp/branch/master/graph/badge.svg
   :target: https://codecov.io/gh/aio-libs/aiohttp
   :alt: codecov.io status for master branch

.. image:: https://badge.fury.io/py/aiohttp.svg
   :target: https://pypi.org/project/aiohttp
   :alt: Latest PyPI package version

.. image:: https://img.shields.io/pypi/dm/aiohttp
   :target: https://pypistats.org/packages/aiohttp
   :alt: Downloads count

.. image:: https://readthedocs.org/projects/aiohttp/badge/?version=latest
   :target: https://docs.aiohttp.org/
   :alt: Latest Read The Docs

215:        # placeholder to be replaced on keepalive timeout setup
216:        self._next_keepalive_close_time = 0.0
217:        self._keepalive_handle: Optional[asyncio.Handle] = None
218:        self._keepalive_timeout = keepalive_timeout
272:    def keepalive_timeout(self) -> float:
273:        return self._keepalive_timeout
283:        if self._keepalive_handle i
…[751 chars omitted]…
meout
566:                self._keepalive = bool(resp.keep_alive)
604:                    if self._keepalive and not self._close:
606:                        if keepalive_timeout is not None:
608:                            close_time = now + keepalive_timeout
609:                            self._next_keepalive_close_time = close_time
610:                            if self._keepalive_handle is None:

        if self._keepalive_handle:
            self._keepalive_handle.cancel()
            self._keepalive_handle = None

    def close(self) -> None:
        """Close connection.

        Stop accepting new pipelining messages and close
        connection when handlers done processing messages.
        """
        self._close = True
        if self._waiter:
            self._waiter.cancel()

    def force_close(self) -> None:
        """Forcefully close connection."""
        self._force_close = True
        if self._waiter:
            self._waiter.cancel()
        if
…[8132 chars omitted]…
ption information. Returns True if the client disconnects
        prematurely.
        """
        request._finish()
        if self._request_parser is not None:
            self._request_parser.set_upgraded(False)
            self._upgrade = False
            if self._message_tail:
                self._request_parser.feed_data(self._message_tail)
                self._message_tail = b""
        try:

                exc = ConnectionResetError("Connection lost")
            self._current_request._cancel(exc)

        if handler_cancellation and self._task_handler is not None:
            self._task_handler.cancel()

        self._task_handler = None

        if self._payload_parser is not None:
            self._payload_parser.feed_eof()
            self._payload_parser = None

    def set_parser(self, parser: Any) -> None:
        # Actual type is WebReader
        assert self._payload_parser is None

        self._p
…[1036 chars omitted]…
essages and waiter is not None and not waiter.done():
                # don't set result twice
                waiter.set_result(None)

            self._upgrade = upgraded
            if upgraded and tail:
                self._message_tail = tail

        # no parser, just store
        elif self._payload_parser is None and self._upgrade and data:
            self._message_tail += data

16af75c base

client_exceptions.py
client_proto.py
client_reqrep.py
client_ws.py
compression_utils.py
connector.py
cookiejar.py
formdata.py
hdrs.py
helpers.py
http.py
http_exceptions.py
http_parser.py
http_websocket.py
http_writer.py
locks.py
log.py
multipart.py

repo
root
run
sbin
srv
sys
tmp
usr
var

/opt:

/tmp:
install.log
repro.py

    Literal,
    NamedTuple,
    Optional,
    Pattern,
    Set,
    Tuple,
    Type,
    TypeVar,
    Union,
)

from multidict import CIMultiDict, CIMultiDictProxy, istr
from yarl import URL

from . import hdrs
from .base_protocol import BaseProtocol
from .compression_utils import HAS_BROTLI, BrotliDecompressor, ZLibDecompressor
from .helpers import (
    _EXC_SENTINEL,
    DEBUG,
    NO_EXTENSIONS,
    BaseTimerContext,
    method_must_be_empty_body,
    set_exception,
    status_code_must_be_empty_body,
)
from .http_exceptions import (
    BadHttpMessage,
1:__version__ = "4.0.0a2.dev0"

            HttpResponseParser,
            RawRequestMessage,
            RawResponseMessage,
        )

        HttpRequestParserC = HttpRequestParser
        HttpResponseParserC = HttpResponseParser
        RawRequestMessageC = RawRequestMessage
        RawResponseMessageC = RawResponseMessage
except ImportError:  # pragma: no cover
    pass
False

           ^^^^^
  File "/repo/aiohttp/web_request.py", line 844, in __init__
    super().__init__(*args, **kwargs)
  File "/repo/aiohttp/web_request.py", line 206, in __init__
    assert transport is not None
           ^^^^^^^^^^^^^^^^^^^^^
AssertionError
Future exception was never
…[177 chars omitted]…
al/lib/python3.12/asyncio/selector_events.py", line 1013, in _read_ready__data_received
    data = self._sock.recv(self.max_size)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
ConnectionResetError: [Errno 104] Connection reset by peer

The above exception was the direct cause of the following exception:

aiohttp.client_exceptions.ClientConnectionError: Connection lost: [Errno 104] Connection reset by peer

     async def _handle_request(