aiohttp-1.2.0/0000775000175000017500000000000013025135427014030 5ustar travistravis00000000000000aiohttp-1.2.0/tests/0000775000175000017500000000000013025135427015172 5ustar travistravis00000000000000aiohttp-1.2.0/tests/test_server.py0000664000175000017500000004016513025134363020115 0ustar travistravis00000000000000"""Tests for aiohttp/server.py""" import asyncio import socket from functools import partial from html import escape from unittest import mock import pytest from aiohttp import errors, helpers, server @pytest.yield_fixture def make_srv(loop): srv = None def maker(**kwargs): nonlocal srv srv = server.ServerHttpProtocol(loop=loop, access_log=None, **kwargs) return srv yield maker if srv is not None: srv.connection_lost(None) @pytest.fixture def srv(make_srv): return make_srv() def test_http_error_exception(): exc = errors.HttpProcessingError(code=500, message='Internal error') assert exc.code == 500 assert exc.message == 'Internal error' def test_handle_request(srv): transport = mock.Mock() srv.connection_made(transport) srv.writer = mock.Mock() message = mock.Mock() message.headers = [] message.version = (1, 1) srv.handle_request(message, mock.Mock()) content = b''.join( [c[1][0] for c in list(srv.writer.write.mock_calls)]) assert content.startswith(b'HTTP/1.1 404 Not Found\r\n') @asyncio.coroutine def test_shutdown(srv, loop): transport = mock.Mock() transport.close.side_effect = partial(srv.connection_lost, None) transport.drain.side_effect = [] srv.connection_made(transport) assert transport is srv.transport yield from asyncio.sleep(0, loop=loop) srv.reader.feed_data( b'GET / HTTP/1.1\r\n' b'Host: example.com\r\n' b'Content-Length: 0\r\n\r\n') srv._keepalive = True request_handler = srv._request_handler t0 = loop.time() yield from srv.shutdown() t1 = loop.time() assert t1 - t0 < 0.05, t1-t0 assert transport.close.called assert srv.transport is None assert srv._request_handler is None assert request_handler.done() @asyncio.coroutine def test_double_shutdown(srv): transport = srv.transport = mock.Mock() transport.close.side_effect = partial(srv.connection_lost, None) srv.connection_made(transport) srv.writer = mock.Mock() yield from srv.shutdown() assert transport.close.called assert srv.transport is None transport.reset_mock() yield from srv.shutdown() assert not transport.close.called assert srv.transport is None def test_connection_made(srv): assert srv._request_handler is None srv.connection_made(mock.Mock()) assert srv._request_handler is not None assert not srv._closing def test_connection_made_with_keepaplive(srv): sock = mock.Mock() transport = mock.Mock() transport.get_extra_info.return_value = sock srv.connection_made(transport) sock.setsockopt.assert_called_with(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) def test_connection_made_without_keepaplive(make_srv): srv = make_srv(keep_alive_on=False) sock = mock.Mock() transport = mock.Mock() transport.get_extra_info.return_value = sock srv.connection_made(transport) assert not sock.setsockopt.called def test_data_received(srv): srv.connection_made(mock.Mock()) srv.data_received(b'123') assert b'123' == bytes(srv.reader._buffer) srv.data_received(b'456') assert b'123456' == bytes(srv.reader._buffer) def test_eof_received(srv): srv.connection_made(mock.Mock()) srv.eof_received() assert srv.reader._eof @asyncio.coroutine def test_connection_lost(srv, loop): srv.connection_made(mock.Mock()) handle = srv._request_handler yield from asyncio.sleep(0, loop=loop) # wait for .start() starting srv.connection_lost(None) assert srv._closing yield from handle assert srv._request_handler is None def test_srv_keep_alive(srv): assert not srv._keepalive srv.keep_alive(True) assert srv._keepalive srv.keep_alive(False) assert not srv._keepalive def test_slow_request(make_srv, loop): transport = mock.Mock() srv = make_srv(slow_request_timeout=0.01, keepalive_timeout=0) srv.connection_made(transport) srv.reader.feed_data( b'GET / HTTP/1.0\r\n' b'Host: example.com\r\n') loop.run_until_complete(srv._request_handler) assert transport.close.called def test_bad_method(srv, loop): transport = mock.Mock() srv.connection_made(transport) srv.reader.feed_data( b'!@#$ / HTTP/1.0\r\n' b'Host: example.com\r\n\r\n') loop.run_until_complete(srv._request_handler) assert transport.write.mock_calls[0][1][0].startswith( b'HTTP/1.1 400 Bad Request\r\n') def test_line_too_long(srv, loop): transport = mock.Mock() srv.connection_made(transport) srv.data_received(b''.join([b'a' for _ in range(10000)]) + b'\r\n\r\n') loop.run_until_complete(srv._request_handler) assert transport.write.mock_calls[0][1][0].startswith( b'HTTP/1.1 400 Bad Request\r\n') def test_invalid_content_length(srv, loop): transport = mock.Mock() srv.connection_made(transport) srv.reader.feed_data( b'GET / HTTP/1.0\r\n' b'Host: example.com\r\n' b'Content-Length: sdgg\r\n\r\n') loop.run_until_complete(srv._request_handler) assert transport.write.mock_calls[0][1][0].startswith( b'HTTP/1.1 400 Bad Request\r\n') def test_handle_error(srv): transport = mock.Mock() srv.connection_made(transport) srv.keep_alive(True) srv.writer = mock.Mock() srv.handle_error(404, headers=(('X-Server', 'asyncio'),)) content = b''.join( [c[1][0] for c in list(srv.writer.write.mock_calls)]) assert b'HTTP/1.1 404 Not Found' in content assert b'X-Server: asyncio' in content assert not srv._keepalive def test_handle_error__utf(make_srv): transport = mock.Mock() srv = make_srv(debug=True) srv.connection_made(transport) srv.keep_alive(True) srv.writer = mock.Mock() srv.logger = mock.Mock() try: raise RuntimeError('что-то пошло не так') except RuntimeError as exc: srv.handle_error(exc=exc) content = b''.join( [c[1][0] for c in list(srv.writer.write.mock_calls)]) assert b'HTTP/1.1 500 Internal Server Error' in content assert b'Content-Type: text/html; charset=utf-8' in content pattern = escape("raise RuntimeError('что-то пошло не так')") assert pattern.encode('utf-8') in content assert not srv._keepalive srv.logger.exception.assert_called_with("Error handling request") def test_handle_error_traceback_exc(make_srv): log = mock.Mock() srv = make_srv(debug=True, logger=log) srv.transport = mock.Mock() srv.transport.get_extra_info.return_value = '127.0.0.1' srv.writer = mock.Mock() srv._request_handler = mock.Mock() with mock.patch('aiohttp.server.traceback') as m_trace: m_trace.format_exc.side_effect = ValueError srv.handle_error(500, exc=object()) content = b''.join( [c[1][0] for c in list(srv.writer.write.mock_calls)]) assert content.startswith(b'HTTP/1.1 500 Internal Server Error') assert log.exception.called def test_handle_error_debug(srv): transport = mock.Mock() srv.debug = True srv.connection_made(transport) srv.writer = mock.Mock() try: raise ValueError() except Exception as exc: srv.handle_error(999, exc=exc) content = b''.join( [c[1][0] for c in list(srv.writer.write.mock_calls)]) assert b'HTTP/1.1 500 Internal' in content assert b'Traceback (most recent call last):' in content def test_handle_error_500(make_srv, loop): log = mock.Mock() transport = mock.Mock() transport.drain.return_value = () srv = make_srv(logger=log) srv.connection_made(transport) srv.writer = mock.Mock() srv.handle_error(500) assert log.exception.called def test_handle(srv, loop): def get_mock_coro(return_value): @asyncio.coroutine def mock_coro(*args, **kwargs): return return_value return mock.Mock(wraps=mock_coro) transport = mock.Mock() srv.connection_made(transport) handle = srv.handle_request = get_mock_coro(return_value=None) srv.reader.feed_data( b'GET / HTTP/1.0\r\n' b'Host: example.com\r\n\r\n') loop.run_until_complete(srv._request_handler) assert handle.called assert transport.close.called def test_handle_uncompleted(make_srv, loop): transport = mock.Mock() closed = False def close(): nonlocal closed closed = True transport.close = close srv = make_srv(lingering_timeout=0) srv.connection_made(transport) srv.logger.exception = mock.Mock() handle = srv.handle_request = mock.Mock() handle.side_effect = ValueError srv.reader.feed_data( b'GET / HTTP/1.0\r\n' b'Host: example.com\r\n' b'Content-Length: 50000\r\n\r\n') loop.run_until_complete(srv._request_handler) assert handle.called assert closed srv.logger.exception.assert_called_with("Error handling request") @asyncio.coroutine def test_lingering(srv, loop): transport = mock.Mock() srv.connection_made(transport) yield from asyncio.sleep(0, loop=loop) assert not transport.close.called srv.reader.feed_data( b'GET / HTTP/1.0\r\n' b'Host: example.com\r\n' b'Content-Length: 0\r\n\r\n') srv.reader.feed_data(b'123') yield from asyncio.sleep(0, loop=loop) assert not transport.close.called srv.reader.feed_eof() yield from asyncio.sleep(0, loop=loop) transport.close.assert_called_with() @asyncio.coroutine def test_lingering_disabled(make_srv, loop): srv = make_srv(lingering_time=0) transport = mock.Mock() srv.connection_made(transport) yield from asyncio.sleep(0, loop=loop) assert not transport.close.called srv.reader.feed_data( b'GET / HTTP/1.0\r\n' b'Host: example.com\r\n' b'Content-Length: 50\r\n\r\n') srv.reader.feed_data(b'123') yield from asyncio.sleep(0, loop=loop) assert not transport.close.called srv.reader.feed_eof() yield from asyncio.sleep(0, loop=loop) transport.close.assert_called_with() @asyncio.coroutine def test_lingering_zero_timeout(make_srv, loop): srv = make_srv(lingering_time=1e-30) transport = mock.Mock() srv.connection_made(transport) yield from asyncio.sleep(0, loop=loop) assert not transport.close.called srv.reader.feed_data( b'GET / HTTP/1.0\r\n' b'Host: example.com\r\n' b'Content-Length: 50\r\n\r\n') srv.reader.feed_data(b'123') yield from asyncio.sleep(0, loop=loop) assert not transport.close.called srv.reader.feed_eof() yield from asyncio.sleep(0, loop=loop) transport.close.assert_called_with() def test_handle_coro(srv, loop): transport = mock.Mock() called = False @asyncio.coroutine def coro(message, payload): nonlocal called called = True srv.eof_received() srv.handle_request = coro srv.connection_made(transport) srv.reader.feed_data( b'GET / HTTP/1.0\r\n' b'Host: example.com\r\n\r\n') loop.run_until_complete(srv._request_handler) assert called def test_handle_cancel(make_srv, loop): log = mock.Mock() transport = mock.Mock() srv = make_srv(logger=log, debug=True) srv.connection_made(transport) srv.writer = mock.Mock() srv.handle_request = mock.Mock() @asyncio.coroutine def cancel(): srv._request_handler.cancel() loop.run_until_complete( asyncio.gather(srv._request_handler, cancel(), loop=loop)) assert log.debug.called def test_handle_cancelled(make_srv, loop): log = mock.Mock() transport = mock.Mock() srv = make_srv(logger=log, debug=True) srv.connection_made(transport) srv.handle_request = mock.Mock() # start request_handler task loop.run_until_complete(asyncio.sleep(0, loop=loop)) srv.reader.feed_data( b'GET / HTTP/1.0\r\n' b'Host: example.com\r\n\r\n') r_handler = srv._request_handler srv._request_handler = None # emulate srv.connection_lost() assert loop.run_until_complete(r_handler) is None def test_handle_400(srv, loop): transport = mock.Mock() transport.drain.side_effect = [] srv.connection_made(transport) srv.reader.feed_data(b'GET / HT/asd\r\n\r\n') loop.run_until_complete(srv._request_handler) assert b'400 Bad Request' in srv.transport.write.call_args[0][0] def test_handle_500(srv, loop): transport = mock.Mock() transport.drain.side_effect = [] srv.connection_made(transport) handle = srv.handle_request = mock.Mock() handle.side_effect = ValueError srv.reader.feed_data( b'GET / HTTP/1.0\r\n' b'Host: example.com\r\n\r\n') loop.run_until_complete(srv._request_handler) assert b'500 Internal Server Error' in srv.transport.write.call_args[0][0] def test_handle_error_no_handle_task(srv): transport = mock.Mock() srv.keep_alive(True) srv.connection_made(transport) srv.connection_lost(None) srv.handle_error(300) assert not srv._keepalive def test_keep_alive(make_srv, loop): srv = make_srv(keep_alive=0.1) transport = mock.Mock() closed = False def close(): nonlocal closed closed = True srv.connection_lost(None) loop.stop() transport.close = close srv.connection_made(transport) handle = srv.handle_request = mock.Mock() srv.reader.feed_data( b'GET / HTTP/1.1\r\n' b'CONNECTION: keep-alive\r\n' b'HOST: example.com\r\n\r\n') loop.run_forever() assert handle.called assert closed def test_keep_alive_close_existing(make_srv, loop): transport = mock.Mock() srv = make_srv(keepalive_timeout=15) srv.connection_made(transport) srv.handle_request = mock.Mock() srv.handle_request.return_value = helpers.create_future(loop) srv.handle_request.return_value.set_result(1) srv.data_received( b'GET / HTTP/1.0\r\n' b'HOST: example.com\r\n\r\n') loop.run_until_complete(srv._request_handler) assert transport.close.called def test_srv_process_request_without_timeout(make_srv, loop): transport = mock.Mock() srv = make_srv(timeout=0) srv.connection_made(transport) srv.reader.feed_data( b'GET / HTTP/1.0\r\n' b'Host: example.com\r\n\r\n') loop.run_until_complete(srv._request_handler) assert transport.close.called def test_keep_alive_timeout_default(srv): assert 75 == srv.keepalive_timeout def test_keep_alive_timeout_nondefault(make_srv): srv = make_srv(keepalive_timeout=10) assert 10 == srv.keepalive_timeout def test_keep_alive_timeout_deprecated(make_srv): with pytest.warns(DeprecationWarning) as ctx: make_srv(keep_alive=10) assert len(ctx) == 1 expected = "keep_alive is deprecated, use keepalive_timeout instead" assert ctx[0].message.args == (expected,) def test_keep_alive_timeout_deprecated2(make_srv): srv = make_srv(keepalive_timeout=10) with pytest.warns(DeprecationWarning) as ctx: assert 10 == srv.keep_alive_timeout assert len(ctx) == 1 expected = "Use keepalive_timeout property instead" assert ctx[0].message.args == (expected,) def test_supports_connect_method(srv, loop): transport = mock.Mock() srv.connection_made(transport) with mock.patch.object(srv, 'handle_request') as m_handle_request: srv.reader.feed_data( b'CONNECT aiohttp.readthedocs.org:80 HTTP/1.0\r\n' b'Content-Length: 0\r\n\r\n') loop.run_until_complete(srv._request_handler) assert m_handle_request.called assert m_handle_request.call_args[0] != (mock.ANY, server.EMPTY_PAYLOAD) def test_content_length_0(srv, loop): transport = mock.Mock() srv.connection_made(transport) with mock.patch.object(srv, 'handle_request') as m_handle_request: srv.reader.feed_data( b'GET / HTTP/1.1\r\n' b'Host: example.org\r\n' b'Content-Length: 0\r\n\r\n') loop.run_until_complete(srv._request_handler) assert m_handle_request.called assert m_handle_request.call_args[0] == (mock.ANY, server.EMPTY_PAYLOAD) aiohttp-1.2.0/tests/test_web_websocket.py0000664000175000017500000003073513025134363021434 0ustar travistravis00000000000000import asyncio from unittest import mock import pytest from aiohttp import (CIMultiDict, WSMessage, WSMsgType, errors, helpers, signals, web) from aiohttp.test_utils import make_mocked_coro, make_mocked_request from aiohttp.web import HTTPBadRequest, HTTPMethodNotAllowed, WebSocketResponse from aiohttp.web_ws import WebSocketReady @pytest.fixture def app(loop): ret = mock.Mock() ret.loop = loop ret._debug = False ret.on_response_prepare = signals.Signal(ret) return ret @pytest.fixture def writer(): return mock.Mock() @pytest.fixture def reader(): ret = mock.Mock() ret.set_parser.return_value = ret return ret @pytest.fixture def make_request(app, writer, reader): def maker(method, path, headers=None, protocols=False): if headers is None: headers = CIMultiDict( {'HOST': 'server.example.com', 'UPGRADE': 'websocket', 'CONNECTION': 'Upgrade', 'SEC-WEBSOCKET-KEY': 'dGhlIHNhbXBsZSBub25jZQ==', 'ORIGIN': 'http://example.com', 'SEC-WEBSOCKET-VERSION': '13'}) if protocols: headers['SEC-WEBSOCKET-PROTOCOL'] = 'chat, superchat' return make_mocked_request(method, path, headers, app=app, writer=writer, reader=reader) return maker def test_nonstarted_ping(): ws = WebSocketResponse() with pytest.raises(RuntimeError): ws.ping() def test_nonstarted_pong(): ws = WebSocketResponse() with pytest.raises(RuntimeError): ws.pong() def test_nonstarted_send_str(): ws = WebSocketResponse() with pytest.raises(RuntimeError): ws.send_str('string') def test_nonstarted_send_bytes(): ws = WebSocketResponse() with pytest.raises(RuntimeError): ws.send_bytes(b'bytes') def test_nonstarted_send_json(): ws = WebSocketResponse() with pytest.raises(RuntimeError): ws.send_json({'type': 'json'}) @asyncio.coroutine def test_nonstarted_close(): ws = WebSocketResponse() with pytest.raises(RuntimeError): yield from ws.close() @asyncio.coroutine def test_nonstarted_receive_str(): ws = WebSocketResponse() with pytest.raises(RuntimeError): yield from ws.receive_str() @asyncio.coroutine def test_nonstarted_receive_bytes(): ws = WebSocketResponse() with pytest.raises(RuntimeError): yield from ws.receive_bytes() @asyncio.coroutine def test_nonstarted_receive_json(): ws = WebSocketResponse() with pytest.raises(RuntimeError): yield from ws.receive_json() @asyncio.coroutine def test_receive_str_nonstring(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) @asyncio.coroutine def receive(): return WSMessage(WSMsgType.BINARY, b'data', b'') ws.receive = receive with pytest.raises(TypeError): yield from ws.receive_str() @asyncio.coroutine def test_receive_bytes_nonsbytes(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) @asyncio.coroutine def receive(): return WSMessage(WSMsgType.TEXT, 'data', b'') ws.receive = receive with pytest.raises(TypeError): yield from ws.receive_bytes() @asyncio.coroutine def test_send_str_nonstring(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) with pytest.raises(TypeError): ws.send_str(b'bytes') @asyncio.coroutine def test_send_bytes_nonbytes(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) with pytest.raises(TypeError): ws.send_bytes('string') @asyncio.coroutine def test_send_json_nonjson(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) with pytest.raises(TypeError): ws.send_json(set()) def test_write_non_prepared(): ws = WebSocketResponse() with pytest.raises(RuntimeError): ws.write(b'data') def test_websocket_ready(): websocket_ready = WebSocketReady(True, 'chat') assert websocket_ready.ok is True assert websocket_ready.protocol == 'chat' def test_websocket_not_ready(): websocket_ready = WebSocketReady(False, None) assert websocket_ready.ok is False assert websocket_ready.protocol is None def test_websocket_ready_unknown_protocol(): websocket_ready = WebSocketReady(True, None) assert websocket_ready.ok is True assert websocket_ready.protocol is None def test_bool_websocket_ready(): websocket_ready = WebSocketReady(True, None) assert bool(websocket_ready) is True def test_bool_websocket_not_ready(): websocket_ready = WebSocketReady(False, None) assert bool(websocket_ready) is False def test_can_prepare_ok(make_request): req = make_request('GET', '/', protocols=True) ws = WebSocketResponse(protocols=('chat',)) assert(True, 'chat') == ws.can_prepare(req) def test_can_prepare_unknown_protocol(make_request): req = make_request('GET', '/') ws = WebSocketResponse() assert (True, None) == ws.can_prepare(req) def test_can_prepare_invalid_method(make_request): req = make_request('POST', '/') ws = WebSocketResponse() assert (False, None) == ws.can_prepare(req) def test_can_prepare_without_upgrade(make_request): req = make_request('GET', '/', headers=CIMultiDict({})) ws = WebSocketResponse() assert (False, None) == ws.can_prepare(req) @asyncio.coroutine def test_can_prepare_started(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) with pytest.raises(RuntimeError) as ctx: ws.can_prepare(req) assert 'Already started' in str(ctx.value) def test_closed_after_ctor(): ws = WebSocketResponse() assert not ws.closed assert ws.close_code is None @asyncio.coroutine def test_send_str_closed(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) yield from ws.close() with pytest.raises(RuntimeError): ws.send_str('string') @asyncio.coroutine def test_send_bytes_closed(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) yield from ws.close() with pytest.raises(RuntimeError): ws.send_bytes(b'bytes') @asyncio.coroutine def test_send_json_closed(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) yield from ws.close() with pytest.raises(RuntimeError): ws.send_json({'type': 'json'}) @asyncio.coroutine def test_ping_closed(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) yield from ws.close() with pytest.raises(RuntimeError): ws.ping() @asyncio.coroutine def test_pong_closed(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) yield from ws.close() with pytest.raises(RuntimeError): ws.pong() @asyncio.coroutine def test_close_idempotent(make_request, writer): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) assert (yield from ws.close(code=1, message='message1')) assert ws.closed assert not (yield from ws.close(code=2, message='message2')) @asyncio.coroutine def test_start_invalid_method(make_request): req = make_request('POST', '/') ws = WebSocketResponse() with pytest.raises(HTTPMethodNotAllowed): yield from ws.prepare(req) @asyncio.coroutine def test_start_without_upgrade(make_request): req = make_request('GET', '/', headers=CIMultiDict({})) ws = WebSocketResponse() with pytest.raises(HTTPBadRequest): yield from ws.prepare(req) @asyncio.coroutine def test_wait_closed_before_start(): ws = WebSocketResponse() with pytest.raises(RuntimeError): yield from ws.close() @asyncio.coroutine def test_write_eof_not_started(): ws = WebSocketResponse() with pytest.raises(RuntimeError): yield from ws.write_eof() @asyncio.coroutine def test_write_eof_idempotent(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) yield from ws.close() yield from ws.write_eof() yield from ws.write_eof() yield from ws.write_eof() @asyncio.coroutine def test_receive_exc_in_reader(make_request, loop, reader): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) exc = ValueError() res = helpers.create_future(loop) res.set_exception(exc) reader.read = make_mocked_coro(res) msg = yield from ws.receive() assert msg.type == WSMsgType.ERROR assert msg.type is msg.tp assert msg.data is exc assert ws.exception() is exc @asyncio.coroutine def test_receive_cancelled(make_request, loop, reader): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) res = helpers.create_future(loop) res.set_exception(asyncio.CancelledError()) reader.read = make_mocked_coro(res) with pytest.raises(asyncio.CancelledError): yield from ws.receive() @asyncio.coroutine def test_receive_timeouterror(make_request, loop, reader): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) res = helpers.create_future(loop) res.set_exception(asyncio.TimeoutError()) reader.read = make_mocked_coro(res) with pytest.raises(asyncio.TimeoutError): yield from ws.receive() @asyncio.coroutine def test_receive_client_disconnected(make_request, loop, reader): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) exc = errors.ClientDisconnectedError() res = helpers.create_future(loop) res.set_exception(exc) reader.read = make_mocked_coro(res) msg = yield from ws.receive() assert ws.closed assert msg.type == WSMsgType.CLOSE assert msg.type is msg.tp assert msg.data is None assert ws.exception() is None @asyncio.coroutine def test_multiple_receive_on_close_connection(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) yield from ws.close() yield from ws.receive() yield from ws.receive() yield from ws.receive() yield from ws.receive() with pytest.raises(RuntimeError): yield from ws.receive() @asyncio.coroutine def test_concurrent_receive(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) ws._waiting = True with pytest.raises(RuntimeError): yield from ws.receive() @asyncio.coroutine def test_close_exc(make_request, reader, loop): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) exc = ValueError() reader.read.return_value = helpers.create_future(loop) reader.read.return_value.set_exception(exc) yield from ws.close() assert ws.closed assert ws.exception() is exc ws._closed = False reader.read.return_value = helpers.create_future(loop) reader.read.return_value.set_exception(asyncio.CancelledError()) with pytest.raises(asyncio.CancelledError): yield from ws.close() assert ws.close_code == 1006 @asyncio.coroutine def test_close_exc2(make_request): req = make_request('GET', '/') ws = WebSocketResponse() yield from ws.prepare(req) exc = ValueError() ws._writer = mock.Mock() ws._writer.close.side_effect = exc yield from ws.close() assert ws.closed assert ws.exception() is exc ws._closed = False ws._writer.close.side_effect = asyncio.CancelledError() with pytest.raises(asyncio.CancelledError): yield from ws.close() def test_start_twice_idempotent(make_request): req = make_request('GET', '/') ws = WebSocketResponse() with pytest.warns(DeprecationWarning): impl1 = ws.start(req) impl2 = ws.start(req) assert impl1 is impl2 def test_can_start_ok(make_request): req = make_request('GET', '/', protocols=True) ws = WebSocketResponse(protocols=('chat',)) with pytest.warns(DeprecationWarning): assert (True, 'chat') == ws.can_start(req) def test_msgtype_alias(): # deprecated since 1.0 assert web.MsgType is WSMsgType aiohttp-1.2.0/tests/test_client_functional.py0000664000175000017500000014442513025134363022313 0ustar travistravis00000000000000"""HTTP client functional tests against aiohttp.web server""" import asyncio import http.cookies import io import json import pathlib import ssl from unittest import mock import pytest from multidict import MultiDict import aiohttp from aiohttp import hdrs, web from aiohttp.errors import FingerprintMismatch from aiohttp.helpers import create_future from aiohttp.multipart import MultipartWriter @pytest.fixture def here(): return pathlib.Path(__file__).parent @pytest.fixture def ssl_ctx(here): ssl_ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23) ssl_ctx.load_cert_chain( str(here / 'sample.crt'), str(here / 'sample.key')) return ssl_ctx @pytest.fixture def fname(here): return here / 'sample.key' @asyncio.coroutine def test_keepalive_two_requests_success(loop, test_client): @asyncio.coroutine def handler(request): body = yield from request.read() assert b'' == body return web.Response(body=b'OK') app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp1 = yield from client.get('/') yield from resp1.read() resp2 = yield from client.get('/') yield from resp2.read() assert 1 == len(client._session.connector._conns) @asyncio.coroutine def test_keepalive_response_released(loop, test_client): @asyncio.coroutine def handler(request): body = yield from request.read() assert b'' == body return web.Response(body=b'OK') app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp1 = yield from client.get('/') yield from resp1.release() resp2 = yield from client.get('/') yield from resp2.release() assert 1 == len(client._session.connector._conns) @asyncio.coroutine def test_keepalive_server_force_close_connection(loop, test_client): @asyncio.coroutine def handler(request): body = yield from request.read() assert b'' == body response = web.Response(body=b'OK') response.force_close() return response app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp1 = yield from client.get('/') resp1.close() resp2 = yield from client.get('/') resp2.close() assert 0 == len(client._session.connector._conns) @asyncio.coroutine def test_HTTP_304(loop, test_client): @asyncio.coroutine def handler(request): body = yield from request.read() assert b'' == body return web.Response(status=304) app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.get('/') assert resp.status == 304 content = yield from resp.read() assert content == b'' @asyncio.coroutine def test_HTTP_304_WITH_BODY(loop, test_client): @asyncio.coroutine def handler(request): body = yield from request.read() assert b'' == body return web.Response(body=b'test', status=304) app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.get('/') assert resp.status == 304 content = yield from resp.read() assert content == b'' @asyncio.coroutine def test_auto_header_user_agent(loop, test_client): @asyncio.coroutine def handler(request): assert 'aiohttp' in request.headers['user-agent'] return web.Response() app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.get('/') assert 200, resp.status @asyncio.coroutine def test_skip_auto_headers_user_agent(loop, test_client): @asyncio.coroutine def handler(request): assert hdrs.USER_AGENT not in request.headers return web.Response() app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.get('/', skip_auto_headers=['user-agent']) assert 200 == resp.status @asyncio.coroutine def test_skip_default_auto_headers_user_agent(loop, test_client): @asyncio.coroutine def handler(request): assert hdrs.USER_AGENT not in request.headers return web.Response() app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app, skip_auto_headers=['user-agent']) resp = yield from client.get('/') assert 200 == resp.status @asyncio.coroutine def test_skip_auto_headers_content_type(loop, test_client): @asyncio.coroutine def handler(request): assert hdrs.CONTENT_TYPE not in request.headers return web.Response() app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.get('/', skip_auto_headers=['content-type']) assert 200 == resp.status @asyncio.coroutine def test_post_data_bytesio(loop, test_client): data = b'some buffer' @asyncio.coroutine def handler(request): assert len(data) == request.content_length val = yield from request.read() assert data == val return web.Response() app = web.Application(loop=loop) app.router.add_route('POST', '/', handler) client = yield from test_client(app) resp = yield from client.post('/', data=io.BytesIO(data)) assert 200 == resp.status @asyncio.coroutine def test_post_data_with_bytesio_file(loop, test_client): data = b'some buffer' @asyncio.coroutine def handler(request): post_data = yield from request.post() assert ['file'] == list(post_data.keys()) assert data == post_data['file'].file.read() return web.Response() app = web.Application(loop=loop) app.router.add_route('POST', '/', handler) client = yield from test_client(app) resp = yield from client.post('/', data={'file': io.BytesIO(data)}) assert 200 == resp.status @asyncio.coroutine def test_client_ssl(loop, ssl_ctx, test_server, test_client): connector = aiohttp.TCPConnector(verify_ssl=False, loop=loop) @asyncio.coroutine def handler(request): return web.HTTPOk(text='Test message') app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) server = yield from test_server(app, ssl=ssl_ctx) client = yield from test_client(server, connector=connector) resp = yield from client.get('/') assert 200 == resp.status txt = yield from resp.text() assert txt == 'Test message' @pytest.mark.parametrize('fingerprint', [ b'\xa2\x06G\xad\xaa\xf5\xd8\\J\x99^by;\x06=', b's\x93\xfd:\xed\x08\x1do\xa9\xaeq9\x1a\xe3\xc5\x7f\x89\xe7l\xf9', b'0\x9a\xc9D\x83\xdc\x91\'\x88\x91\x11\xa1d\x97\xfd\xcb~7U\x14D@L' b'\x11\xab\x99\xa8\xae\xb7\x14\xee\x8b'], ids=['md5', 'sha1', 'sha256']) @asyncio.coroutine def test_tcp_connector_fingerprint_ok(test_server, test_client, loop, ssl_ctx, fingerprint): @asyncio.coroutine def handler(request): return web.HTTPOk(text='Test message') # Test for deprecation warning on md5 and sha1 len digests. if len(fingerprint) == 16 or len(fingerprint) == 20: with pytest.warns(DeprecationWarning) as cm: connector = aiohttp.TCPConnector(loop=loop, verify_ssl=False, fingerprint=fingerprint) assert 'Use sha256.' in str(cm[0].message) else: connector = aiohttp.TCPConnector(loop=loop, verify_ssl=False, fingerprint=fingerprint) app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) server = yield from test_server(app, ssl=ssl_ctx) client = yield from test_client(server, connector=connector) resp = yield from client.get('/') assert resp.status == 200 resp.close() @pytest.mark.parametrize('fingerprint', [ b'\xa2\x06G\xad\xaa\xf5\xd8\\J\x99^by;\x06=', b's\x93\xfd:\xed\x08\x1do\xa9\xaeq9\x1a\xe3\xc5\x7f\x89\xe7l\xf9', b'0\x9a\xc9D\x83\xdc\x91\'\x88\x91\x11\xa1d\x97\xfd\xcb~7U\x14D@L' b'\x11\xab\x99\xa8\xae\xb7\x14\xee\x8b'], ids=['md5', 'sha1', 'sha256']) @asyncio.coroutine def test_tcp_connector_fingerprint_fail(test_server, test_client, loop, ssl_ctx, fingerprint): @asyncio.coroutine def handler(request): return web.HTTPOk(text='Test message') bad_fingerprint = b'\x00' * len(fingerprint) connector = aiohttp.TCPConnector(loop=loop, verify_ssl=False, fingerprint=bad_fingerprint) app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) server = yield from test_server(app, ssl=ssl_ctx) client = yield from test_client(server, connector=connector) with pytest.raises(FingerprintMismatch) as cm: yield from client.get('/') exc = cm.value assert exc.expected == bad_fingerprint assert exc.got == fingerprint @asyncio.coroutine def test_format_task_get(test_server, loop): @asyncio.coroutine def handler(request): return web.Response(body=b'OK') app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) server = yield from test_server(app) client = aiohttp.ClientSession(loop=loop) task = loop.create_task(client.get(server.make_url('/'))) assert "{}".format(task)[:18] == "' == repr(handler) handler.transport = object() request = make_mocked_request('GET', '/index.html') handler._request = request assert '' == repr(handler) def test_connections(loop): app = web.Application(loop=loop) manager = app.make_handler() assert manager.connections == [] handler = object() transport = object() manager.connection_made(handler, transport) assert manager.connections == [handler] manager.connection_lost(handler, None) assert manager.connections == [] @asyncio.coroutine def test_finish_connection_no_timeout(loop): app = web.Application(loop=loop) manager = app.make_handler() handler = mock.Mock() handler.shutdown = make_mocked_coro(mock.Mock()) transport = mock.Mock() manager.connection_made(handler, transport) yield from manager.finish_connections() manager.connection_lost(handler, None) assert manager.connections == [] handler.shutdown.assert_called_with(None) @asyncio.coroutine def test_finish_connection_timeout(loop): app = web.Application(loop=loop) manager = app.make_handler() handler = mock.Mock() handler.shutdown = make_mocked_coro(mock.Mock()) transport = mock.Mock() manager.connection_made(handler, transport) yield from manager.finish_connections(timeout=0.1) manager.connection_lost(handler, None) assert manager.connections == [] handler.shutdown.assert_called_with(0.1) aiohttp-1.2.0/tests/test_resolver.py0000664000175000017500000001563213025134363020451 0ustar travistravis00000000000000import asyncio import ipaddress import socket from unittest.mock import patch import pytest from aiohttp.resolver import AsyncResolver, DefaultResolver, ThreadedResolver try: import aiodns gethostbyname = hasattr(aiodns.DNSResolver, 'gethostbyname') except ImportError: aiodns = None gethostbyname = False class FakeResult: def __init__(self, addresses): self.addresses = addresses class FakeQueryResult: def __init__(self, host): self.host = host @asyncio.coroutine def fake_result(addresses): return FakeResult(addresses=tuple(addresses)) @asyncio.coroutine def fake_query_result(result): return [FakeQueryResult(host=h) for h in result] def fake_addrinfo(hosts): @asyncio.coroutine def fake(*args, **kwargs): if not hosts: raise socket.gaierror return list([(None, None, None, None, [h, 0]) for h in hosts]) return fake @pytest.mark.skipif(not gethostbyname, reason="aiodns 1.1 required") @asyncio.coroutine def test_async_resolver_positive_lookup(loop): with patch('aiodns.DNSResolver') as mock: mock().gethostbyname.return_value = fake_result(['127.0.0.1']) resolver = AsyncResolver(loop=loop) real = yield from resolver.resolve('www.python.org') ipaddress.ip_address(real[0]['host']) mock().gethostbyname.assert_called_with('www.python.org', socket.AF_INET) @pytest.mark.skipif(aiodns is None, reason="aiodns required") @asyncio.coroutine def test_async_resolver_query_positive_lookup(loop): with patch('aiodns.DNSResolver') as mock: del mock().gethostbyname mock().query.return_value = fake_query_result(['127.0.0.1']) resolver = AsyncResolver(loop=loop) real = yield from resolver.resolve('www.python.org') ipaddress.ip_address(real[0]['host']) mock().query.assert_called_with('www.python.org', 'A') @pytest.mark.skipif(not gethostbyname, reason="aiodns 1.1 required") @asyncio.coroutine def test_async_resolver_multiple_replies(loop): with patch('aiodns.DNSResolver') as mock: ips = ['127.0.0.1', '127.0.0.2', '127.0.0.3', '127.0.0.4'] mock().gethostbyname.return_value = fake_result(ips) resolver = AsyncResolver(loop=loop) real = yield from resolver.resolve('www.google.com') ips = [ipaddress.ip_address(x['host']) for x in real] assert len(ips) > 3, "Expecting multiple addresses" @pytest.mark.skipif(aiodns is None, reason="aiodns required") @asyncio.coroutine def test_async_resolver_query_multiple_replies(loop): with patch('aiodns.DNSResolver') as mock: del mock().gethostbyname ips = ['127.0.0.1', '127.0.0.2', '127.0.0.3', '127.0.0.4'] mock().query.return_value = fake_query_result(ips) resolver = AsyncResolver(loop=loop) real = yield from resolver.resolve('www.google.com') ips = [ipaddress.ip_address(x['host']) for x in real] @pytest.mark.skipif(not gethostbyname, reason="aiodns 1.1 required") @asyncio.coroutine def test_async_resolver_negative_lookup(loop): with patch('aiodns.DNSResolver') as mock: mock().gethostbyname.side_effect = aiodns.error.DNSError() resolver = AsyncResolver(loop=loop) with pytest.raises(aiodns.error.DNSError): yield from resolver.resolve('doesnotexist.bla') @pytest.mark.skipif(aiodns is None, reason="aiodns required") @asyncio.coroutine def test_async_resolver_query_negative_lookup(loop): with patch('aiodns.DNSResolver') as mock: del mock().gethostbyname mock().query.side_effect = aiodns.error.DNSError() resolver = AsyncResolver(loop=loop) with pytest.raises(aiodns.error.DNSError): yield from resolver.resolve('doesnotexist.bla') @asyncio.coroutine def test_threaded_resolver_positive_lookup(loop): loop.getaddrinfo = fake_addrinfo(["127.0.0.1"]) resolver = ThreadedResolver(loop=loop) real = yield from resolver.resolve('www.python.org') ipaddress.ip_address(real[0]['host']) @asyncio.coroutine def test_threaded_resolver_multiple_replies(loop): ips = ['127.0.0.1', '127.0.0.2', '127.0.0.3', '127.0.0.4'] loop.getaddrinfo = fake_addrinfo(ips) resolver = ThreadedResolver(loop=loop) real = yield from resolver.resolve('www.google.com') ips = [ipaddress.ip_address(x['host']) for x in real] assert len(ips) > 3, "Expecting multiple addresses" @asyncio.coroutine def test_threaded_negative_lookup(loop): ips = [] loop.getaddrinfo = fake_addrinfo(ips) resolver = ThreadedResolver(loop=loop) with pytest.raises(socket.gaierror): yield from resolver.resolve('doesnotexist.bla') @asyncio.coroutine def test_close_for_threaded_resolver(loop): resolver = ThreadedResolver(loop=loop) yield from resolver.close() @pytest.mark.skipif(aiodns is None, reason="aiodns required") @asyncio.coroutine def test_close_for_async_resolver(loop): resolver = AsyncResolver(loop=loop) yield from resolver.close() def test_default_loop_for_threaded_resolver(loop): asyncio.set_event_loop(loop) resolver = ThreadedResolver() assert resolver._loop is loop @pytest.mark.skipif(aiodns is None, reason="aiodns required") def test_default_loop_for_async_resolver(loop): asyncio.set_event_loop(loop) resolver = AsyncResolver() assert resolver._loop is loop @pytest.mark.skipif(not gethostbyname, reason="aiodns 1.1 required") @asyncio.coroutine def test_async_resolver_ipv6_positive_lookup(loop): with patch('aiodns.DNSResolver') as mock: mock().gethostbyname.return_value = fake_result(['::1']) resolver = AsyncResolver(loop=loop) real = yield from resolver.resolve('www.python.org', family=socket.AF_INET6) ipaddress.ip_address(real[0]['host']) mock().gethostbyname.assert_called_with('www.python.org', socket.AF_INET6) @pytest.mark.skipif(aiodns is None, reason="aiodns required") @asyncio.coroutine def test_async_resolver_query_ipv6_positive_lookup(loop): with patch('aiodns.DNSResolver') as mock: del mock().gethostbyname mock().query.return_value = fake_query_result(['::1']) resolver = AsyncResolver(loop=loop) real = yield from resolver.resolve('www.python.org', family=socket.AF_INET6) ipaddress.ip_address(real[0]['host']) mock().query.assert_called_with('www.python.org', 'AAAA') def test_async_resolver_aiodns_not_present(loop, monkeypatch): monkeypatch.setattr("aiohttp.resolver.aiodns", None) with pytest.raises(RuntimeError): AsyncResolver(loop=loop) def test_default_resolver(): # if gethostbyname: # assert DefaultResolver is AsyncResolver # else: # assert DefaultResolver is ThreadedResolver assert DefaultResolver is ThreadedResolver aiohttp-1.2.0/tests/test_client_ws_functional.py0000664000175000017500000002736413025134363023026 0ustar travistravis00000000000000import asyncio import pytest import aiohttp from aiohttp import hdrs, helpers, web @asyncio.coroutine def test_send_recv_text(loop, test_client): @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) msg = yield from ws.receive_str() ws.send_str(msg+'/answer') yield from ws.close() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.ws_connect('/') resp.send_str('ask') data = yield from resp.receive_str() assert data == 'ask/answer' yield from resp.close() @asyncio.coroutine def test_send_recv_bytes_bad_type(loop, test_client): @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) msg = yield from ws.receive_str() ws.send_str(msg+'/answer') yield from ws.close() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.ws_connect('/') resp.send_str('ask') with pytest.raises(TypeError): yield from resp.receive_bytes() yield from resp.close() @asyncio.coroutine def test_send_recv_bytes(loop, test_client): @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) msg = yield from ws.receive_bytes() ws.send_bytes(msg+b'/answer') yield from ws.close() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.ws_connect('/') resp.send_bytes(b'ask') data = yield from resp.receive_bytes() assert data == b'ask/answer' yield from resp.close() @asyncio.coroutine def test_send_recv_text_bad_type(loop, test_client): @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) msg = yield from ws.receive_bytes() ws.send_bytes(msg+b'/answer') yield from ws.close() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.ws_connect('/') resp.send_bytes(b'ask') with pytest.raises(TypeError): yield from resp.receive_str() yield from resp.close() @asyncio.coroutine def test_send_recv_json(loop, test_client): @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) data = yield from ws.receive_json() ws.send_json({'response': data['request']}) yield from ws.close() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.ws_connect('/') payload = {'request': 'test'} resp.send_json(payload) data = yield from resp.receive_json() assert data['response'] == payload['request'] yield from resp.close() @asyncio.coroutine def test_ping_pong(loop, test_client): closed = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) msg = yield from ws.receive_bytes() ws.ping() ws.send_bytes(msg+b'/answer') try: yield from ws.close() finally: closed.set_result(1) return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.ws_connect('/') resp.ping() resp.send_bytes(b'ask') msg = yield from resp.receive() assert msg.type == aiohttp.WSMsgType.BINARY assert msg.data == b'ask/answer' msg = yield from resp.receive() assert msg.type == aiohttp.WSMsgType.CLOSE yield from resp.close() yield from closed @asyncio.coroutine def test_ping_pong_manual(loop, test_client): closed = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) msg = yield from ws.receive_bytes() ws.ping() ws.send_bytes(msg+b'/answer') try: yield from ws.close() finally: closed.set_result(1) return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.ws_connect('/', autoping=False) resp.ping() resp.send_bytes(b'ask') msg = yield from resp.receive() assert msg.type == aiohttp.WSMsgType.PONG msg = yield from resp.receive() assert msg.type == aiohttp.WSMsgType.PING resp.pong() msg = yield from resp.receive() assert msg.data == b'ask/answer' msg = yield from resp.receive() assert msg.type == aiohttp.WSMsgType.CLOSE yield from closed @asyncio.coroutine def test_close(loop, test_client): @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) yield from ws.receive_bytes() ws.send_str('test') yield from ws.receive() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.ws_connect('/') resp.send_bytes(b'ask') closed = yield from resp.close() assert closed assert resp.closed assert resp.close_code == 1000 msg = yield from resp.receive() assert msg.type == aiohttp.WSMsgType.CLOSED @asyncio.coroutine def test_close_from_server(loop, test_client): closed = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) try: yield from ws.receive_bytes() yield from ws.close() finally: closed.set_result(1) return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.ws_connect('/') resp.send_bytes(b'ask') msg = yield from resp.receive() assert msg.type == aiohttp.WSMsgType.CLOSE assert resp.closed msg = yield from resp.receive() assert msg.type == aiohttp.WSMsgType.CLOSED yield from closed @asyncio.coroutine def test_close_manual(loop, test_client): closed = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) yield from ws.receive_bytes() ws.send_str('test') try: yield from ws.close() finally: closed.set_result(1) return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.ws_connect('/', autoclose=False) resp.send_bytes(b'ask') msg = yield from resp.receive() assert msg.data == 'test' msg = yield from resp.receive() assert msg.type == aiohttp.WSMsgType.CLOSE assert msg.data == 1000 assert msg.extra == '' assert not resp.closed yield from resp.close() yield from closed assert resp.closed @asyncio.coroutine def test_close_timeout(loop, test_client): @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) yield from ws.receive_bytes() ws.send_str('test') yield from asyncio.sleep(10, loop=loop) app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.ws_connect('/', timeout=0.2, autoclose=False) resp.send_bytes(b'ask') msg = yield from resp.receive() assert msg.data == 'test' assert msg.type == aiohttp.WSMsgType.TEXT msg = yield from resp.close() assert resp.closed assert isinstance(resp.exception(), asyncio.TimeoutError) @asyncio.coroutine def test_close_cancel(loop, test_client): @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) yield from ws.receive_bytes() ws.send_str('test') yield from asyncio.sleep(10, loop=loop) app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.ws_connect('/', autoclose=False) resp.send_bytes(b'ask') text = yield from resp.receive() assert text.data == 'test' t = loop.create_task(resp.close()) yield from asyncio.sleep(0.1, loop=loop) t.cancel() yield from asyncio.sleep(0.1, loop=loop) assert resp.closed assert resp.exception() is None @asyncio.coroutine def test_override_default_headers(loop, test_client): @asyncio.coroutine def handler(request): assert request.headers[hdrs.SEC_WEBSOCKET_VERSION] == '8' ws = web.WebSocketResponse() yield from ws.prepare(request) ws.send_str('answer') yield from ws.close() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) headers = {hdrs.SEC_WEBSOCKET_VERSION: '8'} client = yield from test_client(app) resp = yield from client.ws_connect('/', headers=headers) msg = yield from resp.receive() assert msg.data == 'answer' yield from resp.close() @asyncio.coroutine def test_additional_headers(loop, test_client): @asyncio.coroutine def handler(request): assert request.headers['x-hdr'] == 'xtra' ws = web.WebSocketResponse() yield from ws.prepare(request) ws.send_str('answer') yield from ws.close() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.ws_connect('/', headers={'x-hdr': 'xtra'}) msg = yield from resp.receive() assert msg.data == 'answer' yield from resp.close() @asyncio.coroutine def test_recv_protocol_error(loop, test_client): @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) yield from ws.receive_str() ws._writer.writer.write(b'01234' * 100) yield from ws.close() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.ws_connect('/') resp.send_str('ask') msg = yield from resp.receive() assert msg.type == aiohttp.WSMsgType.ERROR assert type(msg.data) is aiohttp.WebSocketError assert msg.data.args[0] == 'Received frame with non-zero reserved bits' assert msg.extra is None yield from resp.close() @asyncio.coroutine def test_recv_timeout(loop, test_client): @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) yield from ws.receive_str() yield from asyncio.sleep(0.1, loop=request.app.loop) yield from ws.close() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.ws_connect('/') resp.send_str('ask') with pytest.raises(asyncio.TimeoutError): with aiohttp.Timeout(0.01, loop=app.loop): yield from resp.receive() yield from resp.close() aiohttp-1.2.0/tests/test_websocket_parser.py0000664000175000017500000003441113025134363022146 0ustar travistravis00000000000000import random import struct from unittest import mock import pytest import aiohttp from aiohttp import WebSocketError, WSCloseCode, WSMessage, WSMsgType, _ws_impl from aiohttp._ws_impl import (PACK_CLOSE_CODE, PACK_LEN1, PACK_LEN2, PACK_LEN3, WebSocketParser, _websocket_mask, parse_frame) def build_frame(message, opcode, use_mask=False, noheader=False): """Send a frame over the websocket with message as its payload.""" msg_length = len(message) if use_mask: # pragma: no cover mask_bit = 0x80 else: mask_bit = 0 if msg_length < 126: header = PACK_LEN1( 0x80 | opcode, msg_length | mask_bit) elif msg_length < (1 << 16): # pragma: no cover header = PACK_LEN2( 0x80 | opcode, 126 | mask_bit, msg_length) else: header = PACK_LEN3( 0x80 | opcode, 127 | mask_bit, msg_length) if use_mask: # pragma: no cover mask = random.randrange(0, 0xffffffff) mask = mask.to_bytes(4, 'big') message = _websocket_mask(mask, bytearray(message)) if noheader: return message else: return header + mask + message else: if noheader: return message else: return header + message def build_close_frame(code=1000, message=b'', noheader=False): """Close the websocket, sending the specified code and message.""" if isinstance(message, str): # pragma: no cover message = message.encode('utf-8') return build_frame( PACK_CLOSE_CODE(code) + message, opcode=WSMsgType.CLOSE, noheader=noheader) @pytest.fixture() def buf(): return aiohttp.ParserBuffer() @pytest.fixture() def out(loop): return aiohttp.DataQueue(loop=loop) @pytest.fixture() def parser(buf, out): return WebSocketParser(out, buf) def test_parse_frame(buf): p = parse_frame(buf) next(p) p.send(struct.pack('!BB', 0b00000001, 0b00000001)) try: p.send(b'1') except StopIteration as exc: fin, opcode, payload = exc.value assert (0, 1, b'1') == (fin, opcode, payload) def test_parse_frame_length0(buf): p = parse_frame(buf) next(p) try: p.send(struct.pack('!BB', 0b00000001, 0b00000000)) except StopIteration as exc: fin, opcode, payload = exc.value assert (0, 1, b'') == (fin, opcode, payload) def test_parse_frame_length2(buf): p = parse_frame(buf) next(p) p.send(struct.pack('!BB', 0b00000001, 126)) p.send(struct.pack('!H', 4)) try: p.send(b'1234') except StopIteration as exc: fin, opcode, payload = exc.value assert (0, 1, b'1234') == (fin, opcode, payload) def test_parse_frame_length4(buf): p = parse_frame(buf) next(p) p.send(struct.pack('!BB', 0b00000001, 127)) p.send(struct.pack('!Q', 4)) try: p.send(b'1234') except StopIteration as exc: fin, opcode, payload = exc.value assert (0, 1, b'1234') == (fin, opcode, payload) def test_parse_frame_mask(buf): p = parse_frame(buf) next(p) p.send(struct.pack('!BB', 0b00000001, 0b10000001)) p.send(b'0001') try: p.send(b'1') except StopIteration as exc: fin, opcode, payload = exc.value assert (0, 1, b'\x01') == (fin, opcode, payload) def test_parse_frame_header_reversed_bits(buf): p = parse_frame(buf) next(p) with pytest.raises(WebSocketError): p.send(struct.pack('!BB', 0b01100000, 0b00000000)) def test_parse_frame_header_control_frame(buf): p = parse_frame(buf) next(p) with pytest.raises(WebSocketError): p.send(struct.pack('!BB', 0b00001000, 0b00000000)) def test_parse_frame_header_continuation(buf): p = parse_frame(buf) next(p) with pytest.raises(WebSocketError): p.send(struct.pack('!BB', 0b00000000, 0b00000000)) def test_parse_frame_header_new_data_err(buf): p = parse_frame(buf) next(p) with pytest.raises(WebSocketError): p.send(struct.pack('!BB', 0b000000000, 0b00000000)) def test_parse_frame_header_payload_size(buf): p = parse_frame(buf) next(p) with pytest.raises(WebSocketError): p.send(struct.pack('!BB', 0b10001000, 0b01111110)) def test_ping_frame(out, parser): def parse_frame(buf): yield return (1, WSMsgType.PING, b'data') with mock.patch('aiohttp._ws_impl.parse_frame') as m_parse_frame: m_parse_frame.side_effect = parse_frame next(parser) parser.send(b'') res = out._buffer[0] assert res == ((WSMsgType.PING, b'data', ''), 4) def test_pong_frame(out, parser): def parse_frame(buf): yield return (1, WSMsgType.PONG, b'data') with mock.patch('aiohttp._ws_impl.parse_frame') as m_parse_frame: m_parse_frame.side_effect = parse_frame next(parser) parser.send(b'') res = out._buffer[0] assert res == ((WSMsgType.PONG, b'data', ''), 4) def test_close_frame(out, parser): def parse_frame(buf): yield return (1, WSMsgType.CLOSE, b'') with mock.patch('aiohttp._ws_impl.parse_frame') as m_parse_frame: m_parse_frame.side_effect = parse_frame next(parser) parser.send(b'') res = out._buffer[0] assert res == ((WSMsgType.CLOSE, 0, ''), 0) def test_close_frame_info(out, parser): def parse_frame(buf): yield return (1, WSMsgType.CLOSE, b'0112345') with mock.patch('aiohttp._ws_impl.parse_frame') as m_parse_frame: m_parse_frame.side_effect = parse_frame next(parser) parser.send(b'') res = out._buffer[0] assert res == (WSMessage(WSMsgType.CLOSE, 12337, '12345'), 0) def test_close_frame_invalid(out, parser): def parse_frame(buf): yield return (1, WSMsgType.CLOSE, b'1') with mock.patch('aiohttp._ws_impl.parse_frame') as m_parse_frame: m_parse_frame.side_effect = parse_frame next(parser) with pytest.raises(WebSocketError) as ctx: next(parser) assert ctx.value.code == WSCloseCode.PROTOCOL_ERROR def test_close_frame_invalid_2(buf, parser): buf.extend(build_close_frame(code=1)) with pytest.raises(WebSocketError) as ctx: next(parser) assert ctx.value.code == WSCloseCode.PROTOCOL_ERROR def test_close_frame_unicode_err(buf, parser): buf.extend(build_close_frame( code=1000, message=b'\xf4\x90\x80\x80')) with pytest.raises(WebSocketError) as ctx: next(parser) assert ctx.value.code == WSCloseCode.INVALID_TEXT def test_unknown_frame(out, parser): def parse_frame(buf): yield return (1, WSMsgType.CONTINUATION, b'') with mock.patch('aiohttp._ws_impl.parse_frame') as m_parse_frame: m_parse_frame.side_effect = parse_frame next(parser) with pytest.raises(WebSocketError): parser.send(b'') def test_simple_text(buf, out, parser): buf.extend(build_frame(b'text', WSMsgType.TEXT)) next(parser) parser.send(b'') res = out._buffer[0] assert res == ((WSMsgType.TEXT, 'text', ''), 4) def test_simple_text_unicode_err(buf, parser): buf.extend( build_frame(b'\xf4\x90\x80\x80', WSMsgType.TEXT)) with pytest.raises(WebSocketError) as ctx: next(parser) assert ctx.value.code == WSCloseCode.INVALID_TEXT def test_simple_binary(out, parser): def parse_frame(buf): yield return (1, WSMsgType.BINARY, b'binary') with mock.patch('aiohttp._ws_impl.parse_frame') as m_parse_frame: m_parse_frame.side_effect = parse_frame next(parser) parser.send(b'') res = out._buffer[0] assert res == ((WSMsgType.BINARY, b'binary', ''), 6) def test_continuation(out, parser): cur = 0 def parse_frame(buf, cont=False): nonlocal cur yield if cur == 0: cur = 1 return (0, WSMsgType.TEXT, b'line1') else: return (1, WSMsgType.CONTINUATION, b'line2') with mock.patch('aiohttp._ws_impl.parse_frame') as m_parse_frame: m_parse_frame.side_effect = parse_frame next(parser) parser.send(b'') parser.send(b'') res = out._buffer[0] assert res == (WSMessage(WSMsgType.TEXT, 'line1line2', ''), 10) def test_continuation_with_ping(out, parser): frames = [ (0, WSMsgType.TEXT, b'line1'), (0, WSMsgType.PING, b''), (1, WSMsgType.CONTINUATION, b'line2'), ] def parse_frame(buf, cont=False): yield return frames.pop(0) with mock.patch('aiohttp._ws_impl.parse_frame') as m_parse_frame: m_parse_frame.side_effect = parse_frame next(parser) parser.send(b'') parser.send(b'') parser.send(b'') res = out._buffer[0] assert res == (WSMessage(WSMsgType.PING, b'', ''), 0) res = out._buffer[1] assert res == (WSMessage(WSMsgType.TEXT, 'line1line2', ''), 10) def test_continuation_err(out, parser): cur = 0 def parse_frame(buf, cont=False): nonlocal cur yield if cur == 0: cur = 1 return (0, WSMsgType.TEXT, b'line1') else: return (1, WSMsgType.TEXT, b'line2') with mock.patch('aiohttp._ws_impl.parse_frame') as m_parse_frame: m_parse_frame.side_effect = parse_frame next(parser) parser.send(b'') with pytest.raises(WebSocketError): parser.send(b'') def test_continuation_with_close(out, parser): frames = [ (0, WSMsgType.TEXT, b'line1'), (0, WSMsgType.CLOSE, build_close_frame(1002, b'test', noheader=True)), (1, WSMsgType.CONTINUATION, b'line2'), ] def parse_frame(buf, cont=False): yield return frames.pop(0) with mock.patch('aiohttp._ws_impl.parse_frame') as m_parse_frame: m_parse_frame.side_effect = parse_frame next(parser) parser.send(b'') parser.send(b'') parser.send(b'') res = out._buffer[0] assert res, (WSMessage(WSMsgType.CLOSE, 1002, 'test'), 0) res = out._buffer[1] assert res == (WSMessage(WSMsgType.TEXT, 'line1line2', ''), 10) def test_continuation_with_close_unicode_err(out, parser): frames = [ (0, WSMsgType.TEXT, b'line1'), (0, WSMsgType.CLOSE, build_close_frame(1000, b'\xf4\x90\x80\x80', noheader=True)), (1, WSMsgType.CONTINUATION, b'line2')] def parse_frame(buf, cont=False): yield return frames.pop(0) with mock.patch('aiohttp._ws_impl.parse_frame') as m_parse_frame: m_parse_frame.side_effect = parse_frame next(parser) parser.send(b'') with pytest.raises(WebSocketError) as ctx: parser.send(b'') assert ctx.value.code == WSCloseCode.INVALID_TEXT def test_continuation_with_close_bad_code(out, parser): frames = [ (0, WSMsgType.TEXT, b'line1'), (0, WSMsgType.CLOSE, build_close_frame(1, b'test', noheader=True)), (1, WSMsgType.CONTINUATION, b'line2')] def parse_frame(buf, cont=False): yield return frames.pop(0) with mock.patch('aiohttp._ws_impl.parse_frame') as m_parse_frame: m_parse_frame.side_effect = parse_frame next(parser) parser.send(b'') with pytest.raises(WebSocketError) as ctx: parser.send(b'') assert ctx.value.code == WSCloseCode.PROTOCOL_ERROR def test_continuation_with_close_bad_payload(out, parser): frames = [ (0, WSMsgType.TEXT, b'line1'), (0, WSMsgType.CLOSE, b'1'), (1, WSMsgType.CONTINUATION, b'line2')] def parse_frame(buf, cont=False): yield return frames.pop(0) with mock.patch('aiohttp._ws_impl.parse_frame') as m_parse_frame: m_parse_frame.side_effect = parse_frame next(parser) parser.send(b'') with pytest.raises(WebSocketError) as ctx: parser.send(b'') assert ctx.value.code, WSCloseCode.PROTOCOL_ERROR def test_continuation_with_close_empty(out, parser): frames = [ (0, WSMsgType.TEXT, b'line1'), (0, WSMsgType.CLOSE, b''), (1, WSMsgType.CONTINUATION, b'line2'), ] def parse_frame(buf, cont=False): yield return frames.pop(0) with mock.patch('aiohttp._ws_impl.parse_frame') as m_parse_frame: m_parse_frame.side_effect = parse_frame next(parser) parser.send(b'') parser.send(b'') parser.send(b'') res = out._buffer[0] assert res, (WSMessage(WSMsgType.CLOSE, 0, ''), 0) res = out._buffer[1] assert res == (WSMessage(WSMsgType.TEXT, 'line1line2', ''), 10) websocket_mask_data = bytearray( b'some very long data for masking by websocket') websocket_mask_mask = b'1234' websocket_mask_masked = (b'B]^Q\x11DVFH\x12_[_U\x13PPFR\x14W]A\x14\\S@_X' b'\\T\x14SK\x13CTP@[RYV@') def test_websocket_mask_python(): ret = _ws_impl._websocket_mask_python(websocket_mask_mask, websocket_mask_data) assert ret == websocket_mask_masked @pytest.mark.skipif(not hasattr(_ws_impl, '_websocket_mask_cython'), reason='Requires Cython') def test_websocket_mask_cython(): ret = _ws_impl._websocket_mask_cython(websocket_mask_mask, websocket_mask_data) assert ret == websocket_mask_masked def test_websocket_mask_python_empty(): ret = _ws_impl._websocket_mask_python(websocket_mask_mask, bytearray()) assert ret == bytearray() @pytest.mark.skipif(not hasattr(_ws_impl, '_websocket_mask_cython'), reason='Requires Cython') def test_websocket_mask_cython_empty(): ret = _ws_impl._websocket_mask_cython(websocket_mask_mask, bytearray()) assert ret == bytearray() def test_msgtype_class_alias(): assert aiohttp.MsgType is aiohttp.WSMsgType def test_msgtype_aliases(): assert aiohttp.WSMsgType.TEXT == aiohttp.WSMsgType.text assert aiohttp.WSMsgType.BINARY == aiohttp.WSMsgType.binary assert aiohttp.WSMsgType.PING == aiohttp.WSMsgType.ping assert aiohttp.WSMsgType.PONG == aiohttp.WSMsgType.pong assert aiohttp.WSMsgType.CLOSE == aiohttp.WSMsgType.close assert aiohttp.WSMsgType.CLOSED == aiohttp.WSMsgType.closed assert aiohttp.WSMsgType.ERROR == aiohttp.WSMsgType.error aiohttp-1.2.0/tests/test_web_sendfile.py0000664000175000017500000001347313025134363021237 0ustar travistravis00000000000000import os from unittest import mock from yarl import URL from aiohttp import hdrs, helpers from aiohttp.file_sender import FileSender from aiohttp.test_utils import make_mocked_coro, make_mocked_request def test_env_nosendfile(): with mock.patch.dict(os.environ, {'AIOHTTP_NOSENDFILE': '1'}): file_sender = FileSender() assert file_sender._sendfile == file_sender._sendfile_fallback def test_static_handle_eof(loop): fake_loop = mock.Mock() with mock.patch('aiohttp.file_sender.os') as m_os: out_fd = 30 in_fd = 31 fut = helpers.create_future(loop) m_os.sendfile.return_value = 0 file_sender = FileSender() file_sender._sendfile_cb(fut, out_fd, in_fd, 0, 100, fake_loop, False) m_os.sendfile.assert_called_with(out_fd, in_fd, 0, 100) assert fut.done() assert fut.result() is None assert not fake_loop.add_writer.called assert not fake_loop.remove_writer.called def test_static_handle_again(loop): fake_loop = mock.Mock() with mock.patch('aiohttp.file_sender.os') as m_os: out_fd = 30 in_fd = 31 fut = helpers.create_future(loop) m_os.sendfile.side_effect = BlockingIOError() file_sender = FileSender() file_sender._sendfile_cb(fut, out_fd, in_fd, 0, 100, fake_loop, False) m_os.sendfile.assert_called_with(out_fd, in_fd, 0, 100) assert not fut.done() fake_loop.add_writer.assert_called_with(out_fd, file_sender._sendfile_cb, fut, out_fd, in_fd, 0, 100, fake_loop, True) assert not fake_loop.remove_writer.called def test_static_handle_exception(loop): fake_loop = mock.Mock() with mock.patch('aiohttp.file_sender.os') as m_os: out_fd = 30 in_fd = 31 fut = helpers.create_future(loop) exc = OSError() m_os.sendfile.side_effect = exc file_sender = FileSender() file_sender._sendfile_cb(fut, out_fd, in_fd, 0, 100, fake_loop, False) m_os.sendfile.assert_called_with(out_fd, in_fd, 0, 100) assert fut.done() assert exc is fut.exception() assert not fake_loop.add_writer.called assert not fake_loop.remove_writer.called def test__sendfile_cb_return_on_cancelling(loop): fake_loop = mock.Mock() with mock.patch('aiohttp.file_sender.os') as m_os: out_fd = 30 in_fd = 31 fut = helpers.create_future(loop) fut.cancel() file_sender = FileSender() file_sender._sendfile_cb(fut, out_fd, in_fd, 0, 100, fake_loop, False) assert fut.done() assert not fake_loop.add_writer.called assert not fake_loop.remove_writer.called assert not m_os.sendfile.called def test_using_gzip_if_header_present_and_file_available(loop): request = make_mocked_request( 'GET', URL('http://python.org/logo.png'), headers={ hdrs.ACCEPT_ENCODING: 'gzip' } ) gz_filepath = mock.Mock() gz_filepath.open = mock.mock_open() gz_filepath.is_file.return_value = True gz_filepath.stat.return_value = mock.MagicMock() gz_filepath.stat.st_size = 1024 filepath = mock.Mock() filepath.name = 'logo.png' filepath.open = mock.mock_open() filepath.with_name.return_value = gz_filepath file_sender = FileSender() file_sender._sendfile = make_mocked_coro(None) loop.run_until_complete(file_sender.send(request, filepath)) assert not filepath.open.called assert gz_filepath.open.called def test_gzip_if_header_not_present_and_file_available(loop): request = make_mocked_request( 'GET', URL('http://python.org/logo.png'), headers={ } ) gz_filepath = mock.Mock() gz_filepath.open = mock.mock_open() gz_filepath.is_file.return_value = True filepath = mock.Mock() filepath.name = 'logo.png' filepath.open = mock.mock_open() filepath.with_name.return_value = gz_filepath filepath.stat.return_value = mock.MagicMock() filepath.stat.st_size = 1024 file_sender = FileSender() file_sender._sendfile = make_mocked_coro(None) loop.run_until_complete(file_sender.send(request, filepath)) assert filepath.open.called assert not gz_filepath.open.called def test_gzip_if_header_not_present_and_file_not_available(loop): request = make_mocked_request( 'GET', URL('http://python.org/logo.png'), headers={ } ) gz_filepath = mock.Mock() gz_filepath.open = mock.mock_open() gz_filepath.is_file.return_value = False filepath = mock.Mock() filepath.name = 'logo.png' filepath.open = mock.mock_open() filepath.with_name.return_value = gz_filepath filepath.stat.return_value = mock.MagicMock() filepath.stat.st_size = 1024 file_sender = FileSender() file_sender._sendfile = make_mocked_coro(None) loop.run_until_complete(file_sender.send(request, filepath)) assert filepath.open.called assert not gz_filepath.open.called def test_gzip_if_header_present_and_file_not_available(loop): request = make_mocked_request( 'GET', URL('http://python.org/logo.png'), headers={ hdrs.ACCEPT_ENCODING: 'gzip' } ) gz_filepath = mock.Mock() gz_filepath.open = mock.mock_open() gz_filepath.is_file.return_value = False filepath = mock.Mock() filepath.name = 'logo.png' filepath.open = mock.mock_open() filepath.with_name.return_value = gz_filepath filepath.stat.return_value = mock.MagicMock() filepath.stat.st_size = 1024 file_sender = FileSender() file_sender._sendfile = make_mocked_coro(None) loop.run_until_complete(file_sender.send(request, filepath)) assert filepath.open.called assert not gz_filepath.open.called aiohttp-1.2.0/tests/test_web_functional.py0000664000175000017500000010265213025134363021606 0ustar travistravis00000000000000import asyncio import json import pathlib import zlib from unittest import mock import pytest from multidict import MultiDict from yarl import URL from aiohttp import FormData, multipart, web from aiohttp.protocol import HttpVersion, HttpVersion10, HttpVersion11 try: import ssl except: ssl = False @asyncio.coroutine def test_simple_get(loop, test_client): @asyncio.coroutine def handler(request): body = yield from request.read() assert b'' == body return web.Response(body=b'OK') app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) resp = yield from client.get('/') assert 200 == resp.status txt = yield from resp.text() assert 'OK' == txt @asyncio.coroutine def test_handler_returns_not_response(loop, test_server, test_client): logger = mock.Mock() @asyncio.coroutine def handler(request): return 'abc' app = web.Application(loop=loop) app.router.add_get('/', handler) server = yield from test_server(app, logger=logger) client = yield from test_client(server) resp = yield from client.get('/') assert 500 == resp.status assert logger.exception.called @asyncio.coroutine def test_head_returns_empty_body(loop, test_client): @asyncio.coroutine def handler(request): return web.Response(body=b'test') app = web.Application(loop=loop) app.router.add_head('/', handler) client = yield from test_client(app) resp = yield from client.head('/', version=HttpVersion11) assert 200 == resp.status txt = yield from resp.text() assert '' == txt @asyncio.coroutine def test_post_form(loop, test_client): @asyncio.coroutine def handler(request): data = yield from request.post() assert {'a': '1', 'b': '2'} == data return web.Response(body=b'OK') app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) resp = yield from client.post('/', data={'a': 1, 'b': 2}) assert 200 == resp.status txt = yield from resp.text() assert 'OK' == txt @asyncio.coroutine def test_post_text(loop, test_client): @asyncio.coroutine def handler(request): data = yield from request.text() assert 'русский' == data data2 = yield from request.text() assert data == data2 return web.Response(text=data) app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) resp = yield from client.post('/', data='русский') assert 200 == resp.status txt = yield from resp.text() assert 'русский' == txt @asyncio.coroutine def test_post_json(loop, test_client): dct = {'key': 'текст'} @asyncio.coroutine def handler(request): data = yield from request.json() assert dct == data data2 = yield from request.json(loads=json.loads) assert data == data2 with pytest.warns(DeprecationWarning): data3 = yield from request.json(loader=json.loads) assert data == data3 resp = web.Response() resp.content_type = 'application/json' resp.body = json.dumps(data).encode('utf8') return resp app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) headers = {'Content-Type': 'application/json'} resp = yield from client.post('/', data=json.dumps(dct), headers=headers) assert 200 == resp.status data = yield from resp.json() assert dct == data @asyncio.coroutine def test_multipart(loop, test_client): with multipart.MultipartWriter() as writer: writer.append('test') writer.append_json({'passed': True}) @asyncio.coroutine def handler(request): reader = yield from request.multipart() assert isinstance(reader, multipart.MultipartReader) part = yield from reader.next() assert isinstance(part, multipart.BodyPartReader) thing = yield from part.text() assert thing == 'test' part = yield from reader.next() assert isinstance(part, multipart.BodyPartReader) assert part.headers['Content-Type'] == 'application/json' thing = yield from part.json() assert thing == {'passed': True} resp = web.Response() resp.content_type = 'application/json' resp.body = b'' return resp app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) resp = yield from client.post('/', data=writer, headers=writer.headers) assert 200 == resp.status yield from resp.release() @asyncio.coroutine def test_multipart_content_transfer_encoding(loop, test_client): """For issue #1168""" with multipart.MultipartWriter() as writer: writer.append(b'\x00' * 10, headers={'Content-Transfer-Encoding': 'binary'}) @asyncio.coroutine def handler(request): reader = yield from request.multipart() assert isinstance(reader, multipart.MultipartReader) part = yield from reader.next() assert isinstance(part, multipart.BodyPartReader) assert part.headers['Content-Transfer-Encoding'] == 'binary' thing = yield from part.read() assert thing == b'\x00' * 10 resp = web.Response() resp.content_type = 'application/json' resp.body = b'' return resp app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) resp = yield from client.post('/', data=writer, headers=writer.headers) assert 200 == resp.status yield from resp.release() @asyncio.coroutine def test_render_redirect(loop, test_client): @asyncio.coroutine def handler(request): raise web.HTTPMovedPermanently(location='/path') app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) resp = yield from client.get('/', allow_redirects=False) assert 301 == resp.status txt = yield from resp.text() assert '301: Moved Permanently' == txt assert '/path' == resp.headers['location'] @asyncio.coroutine def test_post_single_file(loop, test_client): here = pathlib.Path(__file__).parent def check_file(fs): fullname = here / fs.filename with fullname.open() as f: test_data = f.read().encode() data = fs.file.read() assert test_data == data @asyncio.coroutine def handler(request): with pytest.warns(DeprecationWarning): data = yield from request.post() assert ['sample.crt'] == list(data.keys()) for fs in data.values(): check_file(fs) fs.file.close() resp = web.Response(body=b'OK') return resp app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) fname = here / 'sample.crt' resp = yield from client.post('/', data=[fname.open()]) assert 200 == resp.status @asyncio.coroutine def test_files_upload_with_same_key(loop, test_client): @asyncio.coroutine def handler(request): data = yield from request.post() files = data.getall('file') file_names = set() for _file in files: assert not _file.file.closed if _file.filename == 'test1.jpeg': assert _file.file.read() == b'binary data 1' if _file.filename == 'test2.jpeg': assert _file.file.read() == b'binary data 2' file_names.add(_file.filename) assert len(files) == 2 assert file_names == {'test1.jpeg', 'test2.jpeg'} resp = web.Response(body=b'OK') return resp app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) data = FormData() data.add_field('file', b'binary data 1', content_type='image/jpeg', filename='test1.jpeg') data.add_field('file', b'binary data 2', content_type='image/jpeg', filename='test2.jpeg') resp = yield from client.post('/', data=data) assert 200 == resp.status @asyncio.coroutine def test_post_files(loop, test_client): here = pathlib.Path(__file__).parent def check_file(fs): fullname = here / fs.filename with fullname.open() as f: test_data = f.read().encode() data = fs.file.read() assert test_data == data @asyncio.coroutine def handler(request): data = yield from request.post() assert ['sample.crt', 'sample.key'] == list(data.keys()) for fs in data.values(): check_file(fs) fs.file.close() resp = web.Response(body=b'OK') return resp app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) with (here / 'sample.crt').open() as f1: with (here / 'sample.key').open() as f2: resp = yield from client.post('/', data=[f1, f2]) assert 200 == resp.status @asyncio.coroutine def test_release_post_data(loop, test_client): @asyncio.coroutine def handler(request): yield from request.release() chunk = yield from request.content.readany() assert chunk == b'' return web.Response() app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) resp = yield from client.post('/', data='post text') assert 200 == resp.status @asyncio.coroutine def test_POST_DATA_with_content_transfer_encoding(loop, test_client): @asyncio.coroutine def handler(request): data = yield from request.post() assert b'123' == data['name'] return web.Response() app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) form = FormData() form.add_field('name', b'123', content_transfer_encoding='base64') resp = yield from client.post('/', data=form) assert 200 == resp.status @asyncio.coroutine def test_post_form_with_duplicate_keys(loop, test_client): @asyncio.coroutine def handler(request): data = yield from request.post() lst = list(data.items()) assert [('a', '1'), ('a', '2')] == lst return web.Response() app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) resp = yield from client.post('/', data=MultiDict([('a', 1), ('a', 2)])) assert 200 == resp.status def test_repr_for_application(loop): app = web.Application(loop=loop) assert "".format(id(app)) == repr(app) @asyncio.coroutine def test_expect_default_handler_unknown(loop, test_client): """Test default Expect handler for unknown Expect value. A server that does not understand or is unable to comply with any of the expectation values in the Expect field of a request MUST respond with appropriate error status. The server MUST respond with a 417 (Expectation Failed) status if any of the expectations cannot be met or, if there are other problems with the request, some other 4xx status. http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.20 """ @asyncio.coroutine def handler(request): yield from request.post() pytest.xfail('Handler should not proceed to this point in case of ' 'unknown Expect header') app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) resp = yield from client.post('/', headers={'Expect': 'SPAM'}) assert 417 == resp.status @asyncio.coroutine def test_100_continue(loop, test_client): @asyncio.coroutine def handler(request): data = yield from request.post() assert b'123' == data['name'] return web.Response() form = FormData() form.add_field('name', b'123', content_transfer_encoding='base64') app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) resp = yield from client.post('/', data=form, expect100=True) assert 200 == resp.status @asyncio.coroutine def test_100_continue_custom(loop, test_client): expect_received = False @asyncio.coroutine def handler(request): data = yield from request.post() assert b'123' == data['name'] return web.Response() @asyncio.coroutine def expect_handler(request): nonlocal expect_received expect_received = True if request.version == HttpVersion11: request.transport.write(b"HTTP/1.1 100 Continue\r\n\r\n") form = FormData() form.add_field('name', b'123', content_transfer_encoding='base64') app = web.Application(loop=loop) app.router.add_post('/', handler, expect_handler=expect_handler) client = yield from test_client(app) resp = yield from client.post('/', data=form, expect100=True) assert 200 == resp.status assert expect_received @asyncio.coroutine def test_100_continue_custom_response(loop, test_client): @asyncio.coroutine def handler(request): data = yield from request.post() assert b'123', data['name'] return web.Response() @asyncio.coroutine def expect_handler(request): if request.version == HttpVersion11: if auth_err: return web.HTTPForbidden() request.transport.write(b"HTTP/1.1 100 Continue\r\n\r\n") form = FormData() form.add_field('name', b'123', content_transfer_encoding='base64') app = web.Application(loop=loop) app.router.add_post('/', handler, expect_handler=expect_handler) client = yield from test_client(app) auth_err = False resp = yield from client.post('/', data=form, expect100=True) assert 200 == resp.status auth_err = True resp = yield from client.post('/', data=form, expect100=True) assert 403 == resp.status @asyncio.coroutine def test_100_continue_for_not_found(loop, test_client): app = web.Application(loop=loop) client = yield from test_client(app) resp = yield from client.post('/not_found', data='data', expect100=True) assert 404 == resp.status @asyncio.coroutine def test_100_continue_for_not_allowed(loop, test_client): @asyncio.coroutine def handler(request): return web.Response() app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) resp = yield from client.get('/', expect100=True) assert 405 == resp.status @asyncio.coroutine def test_http11_keep_alive_default(loop, test_client): @asyncio.coroutine def handler(request): return web.Response() app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) resp = yield from client.get('/', version=HttpVersion11) assert 200 == resp.status assert resp.version == HttpVersion11 assert 'Connection' not in resp.headers @asyncio.coroutine def test_http10_keep_alive_default(loop, test_client): @asyncio.coroutine def handler(request): return web.Response() app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) resp = yield from client.get('/', version=HttpVersion10) assert 200 == resp.status assert resp.version == HttpVersion10 assert resp.headers['Connection'] == 'keep-alive' @asyncio.coroutine def test_http09_keep_alive_default(loop, test_client): @asyncio.coroutine def handler(request): yield from request.read() return web.Response() app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) headers = {'Connection': 'keep-alive'} # should be ignored resp = yield from client.get('/', version=HttpVersion(0, 9), headers=headers) assert 200 == resp.status assert resp.version == HttpVersion(0, 9) assert 'Connection' not in resp.headers @asyncio.coroutine def test_http10_keep_alive_with_headers_close(loop, test_client): @asyncio.coroutine def handler(request): yield from request.read() return web.Response(body=b'OK') app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) headers = {'Connection': 'close'} resp = yield from client.get('/', version=HttpVersion10, headers=headers) assert 200 == resp.status assert resp.version == HttpVersion10 assert 'Connection' not in resp.headers @asyncio.coroutine def test_http10_keep_alive_with_headers(loop, test_client): @asyncio.coroutine def handler(request): yield from request.read() return web.Response(body=b'OK') app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) headers = {'Connection': 'keep-alive'} resp = yield from client.get('/', version=HttpVersion10, headers=headers) assert 200 == resp.status assert resp.version == HttpVersion10 assert resp.headers['Connection'] == 'keep-alive' @asyncio.coroutine def test_upload_file(loop, test_client): here = pathlib.Path(__file__).parent fname = here / 'software_development_in_picture.jpg' with fname.open('rb') as f: data = f.read() @asyncio.coroutine def handler(request): form = yield from request.post() raw_data = form['file'].file.read() assert data == raw_data return web.Response() app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) resp = yield from client.post('/', data={'file': data}) assert 200 == resp.status @asyncio.coroutine def test_upload_file_object(loop, test_client): here = pathlib.Path(__file__).parent fname = here / 'software_development_in_picture.jpg' with fname.open('rb') as f: data = f.read() @asyncio.coroutine def handler(request): form = yield from request.post() raw_data = form['file'].file.read() assert data == raw_data return web.Response() app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) with fname.open('rb') as f: resp = yield from client.post('/', data={'file': f}) assert 200 == resp.status @asyncio.coroutine def test_empty_content_for_query_without_body(loop, test_client): @asyncio.coroutine def handler(request): assert not request.has_body return web.Response() app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) resp = yield from client.get('/') assert 200 == resp.status @asyncio.coroutine def test_empty_content_for_query_with_body(loop, test_client): @asyncio.coroutine def handler(request): assert request.has_body body = yield from request.read() return web.Response(body=body) app = web.Application(loop=loop) app.router.add_post('/', handler) client = yield from test_client(app) resp = yield from client.post('/', data=b'data') assert 200 == resp.status @asyncio.coroutine def test_get_with_empty_arg(loop, test_client): @asyncio.coroutine def handler(request): assert 'arg' in request.GET assert '' == request.GET['arg'] return web.Response() app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) resp = yield from client.get('/?arg') assert 200 == resp.status @asyncio.coroutine def test_large_header(loop, test_client): @asyncio.coroutine def handler(request): return web.Response() app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) headers = {'Long-Header': 'ab' * 8129} resp = yield from client.get('/', headers=headers) assert 400 == resp.status @asyncio.coroutine def test_large_header_allowed(loop, test_client, test_server): @asyncio.coroutine def handler(request): return web.Response() app = web.Application(loop=loop) app.router.add_get('/', handler) server = yield from test_server(app, max_field_size=81920) client = yield from test_client(server) headers = {'Long-Header': 'ab' * 8129} resp = yield from client.get('/', headers=headers) assert 200 == resp.status @asyncio.coroutine def test_get_with_empty_arg_with_equal(loop, test_client): @asyncio.coroutine def handler(request): assert 'arg' in request.GET assert '' == request.GET['arg'] return web.Response() app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) resp = yield from client.get('/?arg=') assert 200 == resp.status @pytest.mark.xfail # and had never worked @asyncio.coroutine def test_response_with_precompressed_body(loop, test_client): @asyncio.coroutine def handler(request): headers = {'Content-Encoding': 'gzip'} deflated_data = zlib.compress(b'mydata') return web.Response(body=deflated_data, headers=headers) app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) resp = yield from client.get('/') assert 200 == resp.status data = yield from resp.read() assert b'mydata' == data assert resp.headers.get('Content-Encoding') == 'deflate' @asyncio.coroutine def test_stream_response_multiple_chunks(loop, test_client): @asyncio.coroutine def handler(request): resp = web.StreamResponse() resp.enable_chunked_encoding() yield from resp.prepare(request) resp.write(b'x') resp.write(b'y') resp.write(b'z') return resp app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) resp = yield from client.get('/') assert 200 == resp.status data = yield from resp.read() assert b'xyz' == data @asyncio.coroutine def test_start_without_routes(loop, test_client): app = web.Application(loop=loop) client = yield from test_client(app) resp = yield from client.get('/') assert 404 == resp.status @asyncio.coroutine def test_requests_count(loop, test_client): @asyncio.coroutine def handler(request): return web.Response() app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) assert client.server.handler.requests_count == 0 resp = yield from client.get('/') assert 200 == resp.status assert client.server.handler.requests_count == 1 resp = yield from client.get('/') assert 200 == resp.status assert client.server.handler.requests_count == 2 resp = yield from client.get('/') assert 200 == resp.status assert client.server.handler.requests_count == 3 @asyncio.coroutine def test_redirect_url(loop, test_client): @asyncio.coroutine def redirector(request): raise web.HTTPFound(location=URL('/redirected')) @asyncio.coroutine def redirected(request): return web.Response() app = web.Application(loop=loop) app.router.add_get('/redirector', redirector) app.router.add_get('/redirected', redirected) client = yield from test_client(app) resp = yield from client.get('/redirector') assert resp.status == 200 @asyncio.coroutine def test_simple_subapp(loop, test_client): @asyncio.coroutine def handler(request): return web.Response(text="OK") app = web.Application(loop=loop) subapp = web.Application(loop=loop) subapp.router.add_get('/to', handler) app.router.add_subapp('/path', subapp) client = yield from test_client(app) resp = yield from client.get('/path/to') assert resp.status == 200 txt = yield from resp.text() assert 'OK' == txt @asyncio.coroutine def test_subapp_reverse_url(loop, test_client): @asyncio.coroutine def handler(request): return web.HTTPMovedPermanently( location=subapp.router['name'].url_for()) @asyncio.coroutine def handler2(request): return web.Response(text="OK") app = web.Application(loop=loop) subapp = web.Application(loop=loop) subapp.router.add_get('/to', handler) subapp.router.add_get('/final', handler2, name='name') app.router.add_subapp('/path', subapp) client = yield from test_client(app) resp = yield from client.get('/path/to') assert resp.status == 200 txt = yield from resp.text() assert 'OK' == txt assert resp.url_obj.path == '/path/final' @asyncio.coroutine def test_subapp_reverse_variable_url(loop, test_client): @asyncio.coroutine def handler(request): return web.HTTPMovedPermanently( location=subapp.router['name'].url_for(part='final')) @asyncio.coroutine def handler2(request): return web.Response(text="OK") app = web.Application(loop=loop) subapp = web.Application(loop=loop) subapp.router.add_get('/to', handler) subapp.router.add_get('/{part}', handler2, name='name') app.router.add_subapp('/path', subapp) client = yield from test_client(app) resp = yield from client.get('/path/to') assert resp.status == 200 txt = yield from resp.text() assert 'OK' == txt assert resp.url_obj.path == '/path/final' @asyncio.coroutine def test_subapp_reverse_static_url(loop, test_client): fname = 'software_development_in_picture.jpg' @asyncio.coroutine def handler(request): return web.HTTPMovedPermanently( location=subapp.router['name'].url_for(filename=fname)) app = web.Application(loop=loop) subapp = web.Application(loop=loop) subapp.router.add_get('/to', handler) here = pathlib.Path(__file__).parent subapp.router.add_static('/static', here, name='name') app.router.add_subapp('/path', subapp) client = yield from test_client(app) resp = yield from client.get('/path/to') assert resp.url_obj.path == '/path/static/' + fname assert resp.status == 200 body = yield from resp.read() with (here / fname).open('rb') as f: assert body == f.read() @asyncio.coroutine def test_subapp_app(loop, test_client): @asyncio.coroutine def handler(request): assert request.app is subapp return web.HTTPOk(text='OK') app = web.Application(loop=loop) subapp = web.Application(loop=loop) subapp.router.add_get('/to', handler) app.router.add_subapp('/path/', subapp) client = yield from test_client(app) resp = yield from client.get('/path/to') assert resp.status == 200 txt = yield from resp.text() assert 'OK' == txt @asyncio.coroutine def test_subapp_not_found(loop, test_client): @asyncio.coroutine def handler(request): return web.HTTPOk(text='OK') app = web.Application(loop=loop) subapp = web.Application(loop=loop) subapp.router.add_get('/to', handler) app.router.add_subapp('/path/', subapp) client = yield from test_client(app) resp = yield from client.get('/path/other') assert resp.status == 404 @asyncio.coroutine def test_subapp_not_found2(loop, test_client): @asyncio.coroutine def handler(request): return web.HTTPOk(text='OK') app = web.Application(loop=loop) subapp = web.Application(loop=loop) subapp.router.add_get('/to', handler) app.router.add_subapp('/path/', subapp) client = yield from test_client(app) resp = yield from client.get('/invalid/other') assert resp.status == 404 @asyncio.coroutine def test_subapp_not_allowed(loop, test_client): @asyncio.coroutine def handler(request): return web.HTTPOk(text='OK') app = web.Application(loop=loop) subapp = web.Application(loop=loop) subapp.router.add_get('/to', handler) app.router.add_subapp('/path/', subapp) client = yield from test_client(app) resp = yield from client.post('/path/to') assert resp.status == 405 assert resp.headers['Allow'] == 'GET' @asyncio.coroutine def test_subapp_cannot_add_app_in_handler(loop, test_client): @asyncio.coroutine def handler(request): request.match_info.add_app(app) return web.HTTPOk(text='OK') app = web.Application(loop=loop) subapp = web.Application(loop=loop) subapp.router.add_get('/to', handler) app.router.add_subapp('/path/', subapp) client = yield from test_client(app) resp = yield from client.get('/path/to') assert resp.status == 500 @asyncio.coroutine def test_subapp_middlewares(loop, test_client): order = [] @asyncio.coroutine def handler(request): return web.HTTPOk(text='OK') @asyncio.coroutine def middleware_factory(app, handler): @asyncio.coroutine def middleware(request): order.append((1, app)) resp = yield from handler(request) assert 200 == resp.status order.append((2, app)) return resp return middleware app = web.Application(loop=loop, middlewares=[middleware_factory]) subapp1 = web.Application(loop=loop, middlewares=[middleware_factory]) subapp2 = web.Application(loop=loop, middlewares=[middleware_factory]) subapp2.router.add_get('/to', handler) subapp1.router.add_subapp('/b/', subapp2) app.router.add_subapp('/a/', subapp1) client = yield from test_client(app) resp = yield from client.get('/a/b/to') assert resp.status == 200 assert [(1, app), (1, subapp1), (1, subapp2), (2, subapp2), (2, subapp1), (2, app)] == order @asyncio.coroutine def test_subapp_on_response_prepare(loop, test_client): order = [] @asyncio.coroutine def handler(request): return web.HTTPOk(text='OK') def make_signal(app): @asyncio.coroutine def on_response(request, response): order.append(app) return on_response app = web.Application(loop=loop) app.on_response_prepare.append(make_signal(app)) subapp1 = web.Application(loop=loop) subapp1.on_response_prepare.append(make_signal(subapp1)) subapp2 = web.Application(loop=loop) subapp2.on_response_prepare.append(make_signal(subapp2)) subapp2.router.add_get('/to', handler) subapp1.router.add_subapp('/b/', subapp2) app.router.add_subapp('/a/', subapp1) client = yield from test_client(app) resp = yield from client.get('/a/b/to') assert resp.status == 200 assert [app, subapp1, subapp2] == order @asyncio.coroutine def test_subapp_on_startup(loop, test_server): order = [] @asyncio.coroutine def on_signal(app): order.append(app) app = web.Application(loop=loop) app.on_startup.append(on_signal) subapp1 = web.Application(loop=loop) subapp1.on_startup.append(on_signal) subapp2 = web.Application(loop=loop) subapp2.on_startup.append(on_signal) subapp1.router.add_subapp('/b/', subapp2) app.router.add_subapp('/a/', subapp1) yield from test_server(app) assert [app, subapp1, subapp2] == order @asyncio.coroutine def test_subapp_on_shutdown(loop, test_server): order = [] def on_signal(app): order.append(app) app = web.Application(loop=loop) app.on_shutdown.append(on_signal) subapp1 = web.Application(loop=loop) subapp1.on_shutdown.append(on_signal) subapp2 = web.Application(loop=loop) subapp2.on_shutdown.append(on_signal) subapp1.router.add_subapp('/b/', subapp2) app.router.add_subapp('/a/', subapp1) server = yield from test_server(app) yield from server.close() assert [app, subapp1, subapp2] == order @asyncio.coroutine def test_subapp_on_cleanup(loop, test_server): order = [] @asyncio.coroutine def on_signal(app): order.append(app) app = web.Application(loop=loop) app.on_cleanup.append(on_signal) subapp1 = web.Application(loop=loop) subapp1.on_cleanup.append(on_signal) subapp2 = web.Application(loop=loop) subapp2.on_cleanup.append(on_signal) subapp1.router.add_subapp('/b/', subapp2) app.router.add_subapp('/a/', subapp1) server = yield from test_server(app) yield from server.close() assert [app, subapp1, subapp2] == order @asyncio.coroutine def test_custom_date_header(loop, test_client): @asyncio.coroutine def handler(request): return web.Response(headers={'Date': 'Sun, 30 Oct 2016 03:13:52 GMT'}) app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) resp = yield from client.get('/') assert 200 == resp.status assert resp.headers['Date'] == 'Sun, 30 Oct 2016 03:13:52 GMT' @asyncio.coroutine def test_response_task(loop, test_client): srv_resp = None @asyncio.coroutine def handler(request): nonlocal srv_resp srv_resp = web.StreamResponse() assert srv_resp.task is None yield from srv_resp.prepare(request) assert srv_resp.task is not None return srv_resp app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) resp = yield from client.get('/') assert 200 == resp.status assert srv_resp.task is None aiohttp-1.2.0/tests/test_client_response.py0000664000175000017500000002455413025134363022007 0ustar travistravis00000000000000# -*- coding: utf-8 -*- """Tests for aiohttp/client.py""" import asyncio import gc from unittest import mock import pytest from yarl import URL import aiohttp from aiohttp import helpers from aiohttp.client_reqrep import ClientResponse def test_del(loop): response = ClientResponse('get', URL('http://del-cl-resp.org')) response._post_init(loop) connection = mock.Mock() response._setup_connection(connection) loop.set_exception_handler(lambda loop, ctx: None) with pytest.warns(ResourceWarning): del response gc.collect() connection.close.assert_called_with() def test_close(loop): response = ClientResponse('get', URL('http://def-cl-resp.org')) response._post_init(loop) response._connection = mock.Mock() response.close() assert response.connection is None response.close() response.close() def test_wait_for_100_1(loop): response = ClientResponse( 'get', URL('http://python.org'), continue100=object()) response._post_init(loop) assert response._continue is not None response.close() def test_wait_for_100_2(loop): response = ClientResponse( 'get', URL('http://python.org')) response._post_init(loop) assert response._continue is None response.close() def test_repr(loop): response = ClientResponse('get', URL('http://def-cl-resp.org')) response._post_init(loop) response.status = 200 response.reason = 'Ok' assert ''\ in repr(response) def test_repr_non_ascii_url(): response = ClientResponse('get', URL('http://fake-host.org/\u03bb')) assert ""\ in repr(response) def test_repr_non_ascii_reason(): response = ClientResponse('get', URL('http://fake-host.org/path')) response.reason = '\u03bb' assert ""\ in repr(response) @asyncio.coroutine def test_read_and_release_connection(loop): response = ClientResponse('get', URL('http://def-cl-resp.org')) response._post_init(loop) def side_effect(*args, **kwargs): fut = helpers.create_future(loop) fut.set_result(b'payload') return fut content = response.content = mock.Mock() content.read.side_effect = side_effect res = yield from response.read() assert res == b'payload' assert response._connection is None @asyncio.coroutine def test_read_and_release_connection_with_error(loop): response = ClientResponse('get', URL('http://def-cl-resp.org')) response._post_init(loop) content = response.content = mock.Mock() content.read.return_value = helpers.create_future(loop) content.read.return_value.set_exception(ValueError) with pytest.raises(ValueError): yield from response.read() assert response._closed @asyncio.coroutine def test_release(loop): response = ClientResponse('get', URL('http://def-cl-resp.org')) response._post_init(loop) fut = helpers.create_future(loop) fut.set_result(b'') content = response.content = mock.Mock() content.readany.return_value = fut yield from response.release() assert response._connection is None @asyncio.coroutine def test_text(loop): response = ClientResponse('get', URL('http://def-cl-resp.org')) response._post_init(loop) def side_effect(*args, **kwargs): fut = helpers.create_future(loop) fut.set_result('{"тест": "пройден"}'.encode('cp1251')) return fut response.headers = { 'Content-Type': 'application/json;charset=cp1251'} content = response.content = mock.Mock() content.read.side_effect = side_effect res = yield from response.text() assert res == '{"тест": "пройден"}' assert response._connection is None @asyncio.coroutine def test_text_custom_encoding(loop): response = ClientResponse('get', URL('http://def-cl-resp.org')) response._post_init(loop) def side_effect(*args, **kwargs): fut = helpers.create_future(loop) fut.set_result('{"тест": "пройден"}'.encode('cp1251')) return fut response.headers = { 'Content-Type': 'application/json'} content = response.content = mock.Mock() content.read.side_effect = side_effect response._get_encoding = mock.Mock() res = yield from response.text(encoding='cp1251') assert res == '{"тест": "пройден"}' assert response._connection is None assert not response._get_encoding.called @asyncio.coroutine def test_text_detect_encoding(loop): response = ClientResponse('get', URL('http://def-cl-resp.org')) response._post_init(loop) def side_effect(*args, **kwargs): fut = helpers.create_future(loop) fut.set_result('{"тест": "пройден"}'.encode('cp1251')) return fut response.headers = {'Content-Type': 'text/plain'} content = response.content = mock.Mock() content.read.side_effect = side_effect yield from response.read() res = yield from response.text() assert res == '{"тест": "пройден"}' assert response._connection is None @asyncio.coroutine def test_text_after_read(loop): response = ClientResponse('get', URL('http://def-cl-resp.org')) response._post_init(loop) def side_effect(*args, **kwargs): fut = helpers.create_future(loop) fut.set_result('{"тест": "пройден"}'.encode('cp1251')) return fut response.headers = { 'Content-Type': 'application/json;charset=cp1251'} content = response.content = mock.Mock() content.read.side_effect = side_effect res = yield from response.text() assert res == '{"тест": "пройден"}' assert response._connection is None @asyncio.coroutine def test_json(loop): response = ClientResponse('get', URL('http://def-cl-resp.org')) response._post_init(loop) def side_effect(*args, **kwargs): fut = helpers.create_future(loop) fut.set_result('{"тест": "пройден"}'.encode('cp1251')) return fut response.headers = { 'Content-Type': 'application/json;charset=cp1251'} content = response.content = mock.Mock() content.read.side_effect = side_effect res = yield from response.json() assert res == {'тест': 'пройден'} assert response._connection is None @asyncio.coroutine def test_json_custom_loader(loop): response = ClientResponse('get', URL('http://def-cl-resp.org')) response._post_init(loop) response.headers = { 'Content-Type': 'application/json;charset=cp1251'} response._content = b'data' def custom(content): return content + '-custom' res = yield from response.json(loads=custom) assert res == 'data-custom' @asyncio.coroutine def test_json_no_content(loop): response = ClientResponse('get', URL('http://def-cl-resp.org')) response._post_init(loop) response.headers = { 'Content-Type': 'data/octet-stream'} response._content = b'' with mock.patch('aiohttp.client_reqrep.client_logger') as m_log: res = yield from response.json() assert res is None m_log.warning.assert_called_with( 'Attempt to decode JSON with unexpected mimetype: %s', 'data/octet-stream') @asyncio.coroutine def test_json_override_encoding(loop): response = ClientResponse('get', URL('http://def-cl-resp.org')) response._post_init(loop) def side_effect(*args, **kwargs): fut = helpers.create_future(loop) fut.set_result('{"тест": "пройден"}'.encode('cp1251')) return fut response.headers = { 'Content-Type': 'application/json;charset=utf8'} content = response.content = mock.Mock() content.read.side_effect = side_effect response._get_encoding = mock.Mock() res = yield from response.json(encoding='cp1251') assert res == {'тест': 'пройден'} assert response._connection is None assert not response._get_encoding.called def test_override_flow_control(loop): class MyResponse(ClientResponse): flow_control_class = aiohttp.StreamReader response = MyResponse('get', URL('http://my-cl-resp.org')) response._post_init(loop) response._setup_connection(mock.Mock()) assert isinstance(response.content, aiohttp.StreamReader) response.close() def test_get_encoding_unknown(loop): response = ClientResponse('get', URL('http://def-cl-resp.org')) response._post_init(loop) response.headers = {'Content-Type': 'application/json'} with mock.patch('aiohttp.client_reqrep.chardet') as m_chardet: m_chardet.detect.return_value = {'encoding': None} assert response._get_encoding() == 'utf-8' def test_raise_for_status_2xx(): response = ClientResponse('get', URL('http://def-cl-resp.org')) response.status = 200 response.reason = 'OK' response.raise_for_status() # should not raise def test_raise_for_status_4xx(): response = ClientResponse('get', URL('http://def-cl-resp.org')) response.status = 409 response.reason = 'CONFLICT' with pytest.raises(aiohttp.HttpProcessingError) as cm: response.raise_for_status() assert str(cm.value.code) == '409' assert str(cm.value.message) == "CONFLICT" def test_resp_host(): response = ClientResponse('get', URL('http://del-cl-resp.org')) with pytest.warns(DeprecationWarning): assert 'del-cl-resp.org' == response.host def test_content_type(): response = ClientResponse('get', URL('http://def-cl-resp.org')) response.headers = {'Content-Type': 'application/json;charset=cp1251'} assert 'application/json' == response.content_type def test_content_type_no_header(): response = ClientResponse('get', URL('http://def-cl-resp.org')) response.headers = {} assert 'application/octet-stream' == response.content_type def test_charset(): response = ClientResponse('get', URL('http://def-cl-resp.org')) response.headers = {'Content-Type': 'application/json;charset=cp1251'} assert 'cp1251' == response.charset def test_charset_no_header(): response = ClientResponse('get', URL('http://def-cl-resp.org')) response.headers = {} assert response.charset is None def test_charset_no_charset(): response = ClientResponse('get', URL('http://def-cl-resp.org')) response.headers = {'Content-Type': 'application/json'} assert response.charset is None aiohttp-1.2.0/tests/test_py35/0000775000175000017500000000000013025135427017031 5ustar travistravis00000000000000aiohttp-1.2.0/tests/test_py35/test_streams_35.py0000664000175000017500000000444313025134363022432 0ustar travistravis00000000000000import pytest from aiohttp import streams DATA = b'line1\nline2\nline3\n' def chunkify(seq, n): for i in range(0, len(seq), n): yield seq[i:i+n] def create_stream(loop): stream = streams.StreamReader(loop=loop) stream.feed_data(DATA) stream.feed_eof() return stream async def test_stream_reader_lines(loop): line_iter = iter(DATA.splitlines(keepends=True)) async for line in create_stream(loop): assert line == next(line_iter, None) pytest.raises(StopIteration, next, line_iter) async def test_stream_reader_chunks_complete(loop): """Tests if chunked iteration works if the chunking works out (i.e. the data is divisible by the chunk size) """ chunk_iter = chunkify(DATA, 9) async for data in create_stream(loop).iter_chunked(9): assert data == next(chunk_iter, None) pytest.raises(StopIteration, next, chunk_iter) async def test_stream_reader_chunks_incomplete(loop): """Tests if chunked iteration works if the last chunk is incomplete""" chunk_iter = chunkify(DATA, 8) async for data in create_stream(loop).iter_chunked(8): assert data == next(chunk_iter, None) pytest.raises(StopIteration, next, chunk_iter) async def test_data_queue_empty(loop): """Tests that async looping yields nothing if nothing is there""" buffer = streams.DataQueue(loop=loop) buffer.feed_eof() async for _ in buffer: # NOQA assert False async def test_data_queue_items(loop): """Tests that async looping yields objects identically""" buffer = streams.DataQueue(loop=loop) items = [object(), object()] buffer.feed_data(items[0], 1) buffer.feed_data(items[1], 1) buffer.feed_eof() item_iter = iter(items) async for item in buffer: assert item is next(item_iter, None) pytest.raises(StopIteration, next, item_iter) async def test_stream_reader_iter_any(loop): it = iter([b'line1\nline2\nline3\n']) async for raw in create_stream(loop).iter_any(): assert raw == next(it) pytest.raises(StopIteration, next, it) async def test_stream_reader_iter(loop): it = iter([b'line1\n', b'line2\n', b'line3\n']) async for raw in create_stream(loop): assert raw == next(it) pytest.raises(StopIteration, next, it) aiohttp-1.2.0/tests/test_py35/test_multipart_35.py0000664000175000017500000000363113025134363022773 0ustar travistravis00000000000000import io import json import aiohttp import aiohttp.hdrs as h class Stream(object): def __init__(self, content): self.content = io.BytesIO(content) async def read(self, size=None): return self.content.read(size) async def readline(self): return self.content.readline() async def test_async_for_reader(loop): data = [{"test": "passed"}, 42, b'plain text', b'aiohttp\n'] reader = aiohttp.MultipartReader( headers={h.CONTENT_TYPE: 'multipart/mixed; boundary=":"'}, content=Stream(b'\r\n'.join([ b'--:', b'Content-Type: application/json', b'', json.dumps(data[0]).encode(), b'--:', b'Content-Type: application/json', b'', json.dumps(data[1]).encode(), b'--:', b'Content-Type: multipart/related; boundary="::"', b'', b'--::', b'Content-Type: text/plain', b'', data[2], b'--::', b'Content-Disposition: attachment; filename="aiohttp"', b'Content-Type: text/plain', b'Content-Length: 28', b'Content-Encoding: gzip', b'', b'\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03K\xcc\xcc\xcf())' b'\xe0\x02\x00\xd6\x90\xe2O\x08\x00\x00\x00', b'--::--', b'--:--', b'']))) idata = iter(data) async for part in reader: if isinstance(part, aiohttp.BodyPartReader): assert next(idata) == (await part.json()) else: async for subpart in part: assert next(idata) == await subpart.read(decode=True) async def test_async_for_bodypart(loop): part = aiohttp.BodyPartReader( boundary=b'--:', headers={}, content=Stream(b'foobarbaz\r\n--:--')) async for data in part: assert data == b'foobarbaz' aiohttp-1.2.0/tests/test_py35/test_resp.py0000664000175000017500000000654713025134363021425 0ustar travistravis00000000000000import asyncio from collections.abc import Coroutine import pytest import aiohttp from aiohttp import web from aiohttp.client import _RequestContextManager async def test_await(test_server, loop): async def handler(request): return web.HTTPOk() app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) server = await test_server(app) resp = await aiohttp.get(server.make_url('/'), loop=loop) assert resp.status == 200 assert resp.connection is not None await resp.release() assert resp.connection is None async def test_response_context_manager(test_server, loop): async def handler(request): return web.HTTPOk() app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) server = await test_server(app) resp = await aiohttp.get(server.make_url('/'), loop=loop) async with resp: assert resp.status == 200 assert resp.connection is not None assert resp.connection is None async def test_response_context_manager_error(test_server, loop): async def handler(request): return web.HTTPOk() app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) server = await test_server(app) cm = aiohttp.get(server.make_url('/'), loop=loop) session = cm._session resp = await cm with pytest.raises(RuntimeError): async with resp: assert resp.status == 200 resp.content.set_exception(RuntimeError()) await resp.read() assert len(session._connector._conns) == 0 async def test_client_api_context_manager(test_server, loop): async def handler(request): return web.HTTPOk() app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) server = await test_server(app) async with aiohttp.get(server.make_url('/'), loop=loop) as resp: assert resp.status == 200 assert resp.connection is not None assert resp.connection is None def test_ctx_manager_is_coroutine(): assert issubclass(_RequestContextManager, Coroutine) async def test_context_manager_timeout_on_release(test_server, loop): async def handler(request): resp = web.StreamResponse() await resp.prepare(request) await asyncio.sleep(10, loop=loop) return resp app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) server = await test_server(app) with aiohttp.ClientSession(loop=loop) as session: resp = await session.get(server.make_url('/')) with pytest.raises(asyncio.TimeoutError): with aiohttp.Timeout(0.01, loop=loop): async with resp: assert resp.status == 200 assert resp.connection is not None assert resp.connection is None async def test_iter_any(test_server, loop): data = b'0123456789' * 1024 async def handler(request): buf = [] async for raw in request.content.iter_any(): buf.append(raw) assert b''.join(buf) == data return web.Response() app = web.Application(loop=loop) app.router.add_route('POST', '/', handler) server = await test_server(app) with aiohttp.ClientSession(loop=loop) as session: async with await session.post(server.make_url('/'), data=data) as resp: assert resp.status == 200 aiohttp-1.2.0/tests/test_py35/test_web_websocket_35.py0000664000175000017500000000344713025134363023602 0ustar travistravis00000000000000import aiohttp from aiohttp import helpers, web from aiohttp._ws_impl import WSMsgType async def test_server_ws_async_for(loop, test_server): closed = helpers.create_future(loop) async def handler(request): ws = web.WebSocketResponse() await ws.prepare(request) async for msg in ws: assert msg.type == aiohttp.MsgType.TEXT s = msg.data ws.send_str(s + '/answer') await ws.close() closed.set_result(1) return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) server = await test_server(app) resp = await aiohttp.ws_connect(server.make_url('/'), loop=loop) items = ['q1', 'q2', 'q3'] for item in items: resp.send_str(item) msg = await resp.receive() assert msg.type == aiohttp.MsgType.TEXT assert item + '/answer' == msg.data await resp.close() await closed async def test_closed_async_for(loop, test_client): closed = helpers.create_future(loop) async def handler(request): ws = web.WebSocketResponse() await ws.prepare(request) messages = [] async for msg in ws: messages.append(msg) if 'stop' == msg.data: ws.send_str('stopping') await ws.close() assert 1 == len(messages) assert messages[0].type == WSMsgType.TEXT assert messages[0].data == 'stop' closed.set_result(None) return ws app = web.Application(loop=loop) app.router.add_get('/', handler) client = await test_client(app) ws = await client.ws_connect('/') ws.send_str('stop') msg = await ws.receive() assert msg.type == WSMsgType.TEXT assert msg.data == 'stopping' await ws.close() await closed aiohttp-1.2.0/tests/test_py35/test_client_websocket_35.py0000664000175000017500000000551513025134363024301 0ustar travistravis00000000000000import pytest import aiohttp from aiohttp import helpers, web async def test_client_ws_async_for(loop, test_client): items = ['q1', 'q2', 'q3'] async def handler(request): ws = web.WebSocketResponse() await ws.prepare(request) for i in items: ws.send_str(i) await ws.close() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = await test_client(app) resp = await client.ws_connect('/') it = iter(items) async for msg in resp: assert msg.data == next(it) with pytest.raises(StopIteration): next(it) assert resp.closed async def test_client_ws_async_with(loop, test_server): async def handler(request): ws = web.WebSocketResponse() await ws.prepare(request) msg = await ws.receive() ws.send_str(msg.data + '/answer') await ws.close() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) server = await test_server(app) async with aiohttp.ClientSession(loop=loop) as client: async with client.ws_connect(server.make_url('/')) as ws: ws.send_str('request') msg = await ws.receive() assert msg.data == 'request/answer' assert ws.closed async def test_client_ws_async_with_shortcut(loop, test_server): async def handler(request): ws = web.WebSocketResponse() await ws.prepare(request) msg = await ws.receive() ws.send_str(msg.data + '/answer') await ws.close() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) server = await test_server(app) async with aiohttp.ClientSession(loop=loop) as client: async with client.ws_connect(server.make_url('/')) as ws: ws.send_str('request') msg = await ws.receive() assert msg.data == 'request/answer' assert ws.closed async def test_closed_async_for(loop, test_client): closed = helpers.create_future(loop) async def handler(request): ws = web.WebSocketResponse() await ws.prepare(request) try: ws.send_bytes(b'started') await ws.receive_bytes() finally: closed.set_result(1) return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = await test_client(app) resp = await client.ws_connect('/') messages = [] async for msg in resp: messages.append(msg) if b'started' == msg.data: resp.send_bytes(b'ask') await resp.close() assert 1 == len(messages) assert messages[0].type == aiohttp.WSMsgType.BINARY assert messages[0].data == b'started' assert resp.closed await closed aiohttp-1.2.0/tests/test_py35/test_cbv35.py0000664000175000017500000000053613025134363021366 0ustar travistravis00000000000000from unittest import mock from aiohttp import web from aiohttp.web_urldispatcher import View async def test_render_ok(): resp = web.Response(text='OK') class MyView(View): async def get(self): return resp request = mock.Mock() request.method = 'GET' resp2 = await MyView(request) assert resp is resp2 aiohttp-1.2.0/tests/test_py35/test_client.py0000664000175000017500000000375013025134363021723 0ustar travistravis00000000000000import pytest import aiohttp from aiohttp import web async def test_async_with_session(loop): async with aiohttp.ClientSession(loop=loop) as session: pass assert session.closed async def test_close_resp_on_error_async_with_session(loop, test_server): async def handler(request): return web.Response() app = web.Application(loop=loop) app.router.add_get('/', handler) server = await test_server(app) async with aiohttp.ClientSession(loop=loop) as session: with pytest.raises(RuntimeError): async with session.get(server.make_url('/')) as resp: resp.content.set_exception(RuntimeError()) await resp.read() assert len(session._connector._conns) == 0 async def test_release_resp_on_normal_exit_from_cm(loop, test_server): async def handler(request): return web.Response() app = web.Application(loop=loop) app.router.add_get('/', handler) server = await test_server(app) async with aiohttp.ClientSession(loop=loop) as session: async with session.get(server.make_url('/')) as resp: await resp.read() assert len(session._connector._conns) == 1 async def test_non_close_detached_session_on_error_cm(loop, test_server): async def handler(request): return web.Response() app = web.Application(loop=loop) app.router.add_get('/', handler) server = await test_server(app) cm = aiohttp.get(server.make_url('/'), loop=loop) session = cm._session assert not session.closed with pytest.raises(RuntimeError): async with cm as resp: resp.content.set_exception(RuntimeError()) await resp.read() assert not session.closed async def test_close_detached_session_on_non_existing_addr(loop): cm = aiohttp.get('http://non-existing.example.com', loop=loop) session = cm._session assert not session.closed with pytest.raises(Exception): await cm assert session.closed aiohttp-1.2.0/tests/test_py35/test_test_utils_35.py0000664000175000017500000000205013025134363023143 0ustar travistravis00000000000000import pytest import aiohttp from aiohttp import web from aiohttp.test_utils import TestClient as _TestClient from aiohttp.test_utils import TestServer as _TestServer @pytest.fixture def app(loop): async def handler(request): return web.Response(body=b"OK") app = web.Application(loop=loop) app.router.add_route('*', '/', handler) return app async def test_server_context_manager(app, loop): async with _TestServer(app) as server: async with aiohttp.ClientSession(loop=loop) as client: async with client.head(server.make_url('/')) as resp: assert resp.status == 200 @pytest.mark.parametrize("method", [ "head", "get", "post", "options", "post", "put", "patch", "delete" ]) async def test_client_context_manager_response(method, app, loop): async with _TestClient(app) as client: async with getattr(client, method)('/') as resp: assert resp.status == 200 if method != 'head': text = await resp.text() assert "OK" in text aiohttp-1.2.0/tests/test_classbasedview.py0000664000175000017500000000260313025134363021601 0ustar travistravis00000000000000import asyncio from unittest import mock import pytest from aiohttp import web from aiohttp.web_urldispatcher import View def test_ctor(): request = mock.Mock() view = View(request) assert view.request is request @asyncio.coroutine def test_render_ok(): resp = web.Response(text='OK') class MyView(View): @asyncio.coroutine def get(self): return resp request = mock.Mock() request.method = 'GET' resp2 = yield from MyView(request) assert resp is resp2 @asyncio.coroutine def test_render_unknown_method(): class MyView(View): @asyncio.coroutine def get(self): return web.Response(text='OK') options = get request = mock.Mock() request.method = 'UNKNOWN' with pytest.raises(web.HTTPMethodNotAllowed) as ctx: yield from MyView(request) assert ctx.value.headers['allow'] == 'GET,OPTIONS' assert ctx.value.status == 405 @asyncio.coroutine def test_render_unsupported_method(): class MyView(View): @asyncio.coroutine def get(self): return web.Response(text='OK') options = delete = get request = mock.Mock() request.method = 'POST' with pytest.raises(web.HTTPMethodNotAllowed) as ctx: yield from MyView(request) assert ctx.value.headers['allow'] == 'DELETE,GET,OPTIONS' assert ctx.value.status == 405 aiohttp-1.2.0/tests/test_multipart.py0000664000175000017500000021232213025134363020624 0ustar travistravis00000000000000import asyncio import functools import io import os import unittest import zlib from unittest import mock import aiohttp.multipart from aiohttp import helpers from aiohttp.hdrs import (CONTENT_DISPOSITION, CONTENT_ENCODING, CONTENT_TRANSFER_ENCODING, CONTENT_TYPE) from aiohttp.helpers import parse_mimetype from aiohttp.multipart import (content_disposition_filename, parse_content_disposition) def run_in_loop(f): @functools.wraps(f) def wrapper(testcase, *args, **kwargs): coro = asyncio.coroutine(f) future = asyncio.wait_for(coro(testcase, *args, **kwargs), timeout=5) return testcase.loop.run_until_complete(future) return wrapper class MetaAioTestCase(type): def __new__(cls, name, bases, attrs): for key, obj in attrs.items(): if key.startswith('test_'): attrs[key] = run_in_loop(obj) return super().__new__(cls, name, bases, attrs) class TestCase(unittest.TestCase, metaclass=MetaAioTestCase): def setUp(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(self.loop) def tearDown(self): self.loop.close() def future(self, obj): fut = helpers.create_future(self.loop) fut.set_result(obj) return fut class Response(object): def __init__(self, headers, content): self.headers = headers self.content = content class Stream(object): def __init__(self, content): self.content = io.BytesIO(content) @asyncio.coroutine def read(self, size=None): return self.content.read(size) def at_eof(self): return self.content.tell() == len(self.content.getbuffer()) @asyncio.coroutine def readline(self): return self.content.readline() def unread_data(self, data): self.content = io.BytesIO(data + self.content.read()) class StreamWithShortenRead(Stream): def __init__(self, content): self._first = True super().__init__(content) @asyncio.coroutine def read(self, size=None): if size is not None and self._first: self._first = False size = size // 2 return (yield from super().read(size)) class MultipartResponseWrapperTestCase(TestCase): def setUp(self): super().setUp() wrapper = aiohttp.multipart.MultipartResponseWrapper(mock.Mock(), mock.Mock()) self.wrapper = wrapper def test_at_eof(self): self.wrapper.at_eof() self.assertTrue(self.wrapper.resp.content.at_eof.called) def test_next(self): self.wrapper.stream.next.return_value = self.future(b'') self.wrapper.stream.at_eof.return_value = False yield from self.wrapper.next() self.assertTrue(self.wrapper.stream.next.called) def test_release(self): self.wrapper.resp.release.return_value = self.future(None) yield from self.wrapper.release() self.assertTrue(self.wrapper.resp.release.called) def test_release_when_stream_at_eof(self): self.wrapper.resp.release.return_value = self.future(None) self.wrapper.stream.next.return_value = self.future(b'') self.wrapper.stream.at_eof.return_value = True yield from self.wrapper.next() self.assertTrue(self.wrapper.stream.next.called) self.assertTrue(self.wrapper.resp.release.called) class PartReaderTestCase(TestCase): def setUp(self): super().setUp() self.boundary = b'--:' def test_next(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {}, Stream(b'Hello, world!\r\n--:')) result = yield from obj.next() self.assertEqual(b'Hello, world!', result) self.assertTrue(obj.at_eof()) def test_next_next(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {}, Stream(b'Hello, world!\r\n--:')) result = yield from obj.next() self.assertEqual(b'Hello, world!', result) self.assertTrue(obj.at_eof()) result = yield from obj.next() self.assertIsNone(result) def test_read(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {}, Stream(b'Hello, world!\r\n--:')) result = yield from obj.read() self.assertEqual(b'Hello, world!', result) self.assertTrue(obj.at_eof()) def test_read_chunk_at_eof(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {}, Stream(b'--:')) obj._at_eof = True result = yield from obj.read_chunk() self.assertEqual(b'', result) def test_read_chunk_without_content_length(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {}, Stream(b'Hello, world!\r\n--:')) c1 = yield from obj.read_chunk(8) c2 = yield from obj.read_chunk(8) c3 = yield from obj.read_chunk(8) self.assertEqual(c1 + c2, b'Hello, world!') self.assertEqual(c3, b'') def test_read_incomplete_chunk(self): stream = Stream(b'') def prepare(data): f = helpers.create_future(self.loop) f.set_result(data) return f with mock.patch.object(stream, 'read', side_effect=[ prepare(b'Hello, '), prepare(b'World'), prepare(b'!\r\n--:'), prepare(b'') ]): obj = aiohttp.multipart.BodyPartReader( self.boundary, {}, stream) c1 = yield from obj.read_chunk(8) self.assertEqual(c1, b'Hello, ') c2 = yield from obj.read_chunk(8) self.assertEqual(c2, b'World') c3 = yield from obj.read_chunk(8) self.assertEqual(c3, b'!') def test_read_all_at_once(self): stream = Stream(b'Hello, World!\r\n--:--\r\n') obj = aiohttp.multipart.BodyPartReader(self.boundary, {}, stream) result = yield from obj.read_chunk() self.assertEqual(b'Hello, World!', result) result = yield from obj.read_chunk() self.assertEqual(b'', result) self.assertTrue(obj.at_eof()) def test_read_incomplete_body_chunked(self): stream = Stream(b'Hello, World!\r\n-') obj = aiohttp.multipart.BodyPartReader(self.boundary, {}, stream) result = b'' with self.assertRaises(AssertionError): for _ in range(4): result += yield from obj.read_chunk(7) self.assertEqual(b'Hello, World!\r\n-', result) def test_read_boundary_with_incomplete_chunk(self): stream = Stream(b'') def prepare(data): f = helpers.create_future(self.loop) f.set_result(data) return f with mock.patch.object(stream, 'read', side_effect=[ prepare(b'Hello, World'), prepare(b'!\r\n'), prepare(b'--:'), prepare(b'') ]): obj = aiohttp.multipart.BodyPartReader( self.boundary, {}, stream) c1 = yield from obj.read_chunk(12) self.assertEqual(c1, b'Hello, World') c2 = yield from obj.read_chunk(8) self.assertEqual(c2, b'!') c3 = yield from obj.read_chunk(8) self.assertEqual(c3, b'') def test_multi_read_chunk(self): stream = Stream(b'Hello,\r\n--:\r\n\r\nworld!\r\n--:--') obj = aiohttp.multipart.BodyPartReader(self.boundary, {}, stream) result = yield from obj.read_chunk(8) self.assertEqual(b'Hello,', result) result = yield from obj.read_chunk(8) self.assertEqual(b'', result) self.assertTrue(obj.at_eof()) def test_read_chunk_properly_counts_read_bytes(self): expected = b'.' * 10 size = len(expected) obj = aiohttp.multipart.BodyPartReader( self.boundary, {'CONTENT-LENGTH': size}, StreamWithShortenRead(expected + b'\r\n--:--')) result = bytearray() while True: chunk = yield from obj.read_chunk() if not chunk: break result.extend(chunk) self.assertEqual(size, len(result)) self.assertEqual(b'.' * size, result) self.assertTrue(obj.at_eof()) def test_read_does_reads_boundary(self): stream = Stream(b'Hello, world!\r\n--:') obj = aiohttp.multipart.BodyPartReader( self.boundary, {}, stream) result = yield from obj.read() self.assertEqual(b'Hello, world!', result) self.assertEqual(b'', (yield from stream.read())) self.assertEqual([b'--:'], list(obj._unread)) def test_multiread(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {}, Stream(b'Hello,\r\n--:\r\n\r\nworld!\r\n--:--')) result = yield from obj.read() self.assertEqual(b'Hello,', result) result = yield from obj.read() self.assertEqual(b'', result) self.assertTrue(obj.at_eof()) def test_read_multiline(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {}, Stream(b'Hello\n,\r\nworld!\r\n--:--')) result = yield from obj.read() self.assertEqual(b'Hello\n,\r\nworld!', result) result = yield from obj.read() self.assertEqual(b'', result) self.assertTrue(obj.at_eof()) def test_read_respects_content_length(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {'CONTENT-LENGTH': 100500}, Stream(b'.' * 100500 + b'\r\n--:--')) result = yield from obj.read() self.assertEqual(b'.' * 100500, result) self.assertTrue(obj.at_eof()) def test_read_with_content_encoding_gzip(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_ENCODING: 'gzip'}, Stream(b'\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03\x0b\xc9\xccMU' b'(\xc9W\x08J\xcdI\xacP\x04\x00$\xfb\x9eV\x0e\x00\x00\x00' b'\r\n--:--')) result = yield from obj.read(decode=True) self.assertEqual(b'Time to Relax!', result) def test_read_with_content_encoding_deflate(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_ENCODING: 'deflate'}, Stream(b'\x0b\xc9\xccMU(\xc9W\x08J\xcdI\xacP\x04\x00\r\n--:--')) result = yield from obj.read(decode=True) self.assertEqual(b'Time to Relax!', result) def test_read_with_content_encoding_identity(self): thing = (b'\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03\x0b\xc9\xccMU' b'(\xc9W\x08J\xcdI\xacP\x04\x00$\xfb\x9eV\x0e\x00\x00\x00' b'\r\n') obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_ENCODING: 'identity'}, Stream(thing + b'--:--')) result = yield from obj.read(decode=True) self.assertEqual(thing[:-2], result) def test_read_with_content_encoding_unknown(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_ENCODING: 'snappy'}, Stream(b'\x0e4Time to Relax!\r\n--:--')) with self.assertRaises(RuntimeError): yield from obj.read(decode=True) def test_read_with_content_transfer_encoding_base64(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_TRANSFER_ENCODING: 'base64'}, Stream(b'VGltZSB0byBSZWxheCE=\r\n--:--')) result = yield from obj.read(decode=True) self.assertEqual(b'Time to Relax!', result) def test_read_with_content_transfer_encoding_quoted_printable(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_TRANSFER_ENCODING: 'quoted-printable'}, Stream(b'=D0=9F=D1=80=D0=B8=D0=B2=D0=B5=D1=82,' b' =D0=BC=D0=B8=D1=80!\r\n--:--')) result = yield from obj.read(decode=True) self.assertEqual(b'\xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82,' b' \xd0\xbc\xd0\xb8\xd1\x80!', result) def test_read_with_content_transfer_encoding_binary(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_TRANSFER_ENCODING: 'binary'}, Stream(b'\xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82,' b' \xd0\xbc\xd0\xb8\xd1\x80!\r\n--:--')) result = yield from obj.read(decode=True) self.assertEqual(b'\xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82,' b' \xd0\xbc\xd0\xb8\xd1\x80!', result) def test_read_with_content_transfer_encoding_unknown(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_TRANSFER_ENCODING: 'unknown'}, Stream(b'\x0e4Time to Relax!\r\n--:--')) with self.assertRaises(RuntimeError): yield from obj.read(decode=True) def test_read_text(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {}, Stream(b'Hello, world!\r\n--:--')) result = yield from obj.text() self.assertEqual('Hello, world!', result) def test_read_text_default_encoding(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {}, Stream('Привет, Мир!\r\n--:--'.encode('utf-8'))) result = yield from obj.text() self.assertEqual('Привет, Мир!', result) def test_read_text_encoding(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {}, Stream('Привет, Мир!\r\n--:--'.encode('cp1251'))) result = yield from obj.text(encoding='cp1251') self.assertEqual('Привет, Мир!', result) def test_read_text_guess_encoding(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_TYPE: 'text/plain;charset=cp1251'}, Stream('Привет, Мир!\r\n--:--'.encode('cp1251'))) result = yield from obj.text() self.assertEqual('Привет, Мир!', result) def test_read_text_compressed(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_ENCODING: 'deflate', CONTENT_TYPE: 'text/plain'}, Stream(b'\x0b\xc9\xccMU(\xc9W\x08J\xcdI\xacP\x04\x00\r\n--:--')) result = yield from obj.text() self.assertEqual('Time to Relax!', result) def test_read_text_while_closed(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_TYPE: 'text/plain'}, Stream(b'')) obj._at_eof = True result = yield from obj.text() self.assertEqual('', result) def test_read_json(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_TYPE: 'application/json'}, Stream(b'{"test": "passed"}\r\n--:--')) result = yield from obj.json() self.assertEqual({'test': 'passed'}, result) def test_read_json_encoding(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_TYPE: 'application/json'}, Stream('{"тест": "пассед"}\r\n--:--'.encode('cp1251'))) result = yield from obj.json(encoding='cp1251') self.assertEqual({'тест': 'пассед'}, result) def test_read_json_guess_encoding(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_TYPE: 'application/json; charset=cp1251'}, Stream('{"тест": "пассед"}\r\n--:--'.encode('cp1251'))) result = yield from obj.json() self.assertEqual({'тест': 'пассед'}, result) def test_read_json_compressed(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_ENCODING: 'deflate', CONTENT_TYPE: 'application/json'}, Stream(b'\xabV*I-.Q\xb2RP*H,.NMQ\xaa\x05\x00\r\n--:--')) result = yield from obj.json() self.assertEqual({'test': 'passed'}, result) def test_read_json_while_closed(self): stream = Stream(b'') obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_TYPE: 'application/json'}, stream) obj._at_eof = True result = yield from obj.json() self.assertEqual(None, result) def test_read_form(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_TYPE: 'application/x-www-form-urlencoded'}, Stream(b'foo=bar&foo=baz&boo=zoo\r\n--:--')) result = yield from obj.form() self.assertEqual([('foo', 'bar'), ('foo', 'baz'), ('boo', 'zoo')], result) def test_read_form_encoding(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_TYPE: 'application/x-www-form-urlencoded'}, Stream('foo=bar&foo=baz&boo=zoo\r\n--:--'.encode('cp1251'))) result = yield from obj.form(encoding='cp1251') self.assertEqual([('foo', 'bar'), ('foo', 'baz'), ('boo', 'zoo')], result) def test_read_form_guess_encoding(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_TYPE: 'application/x-www-form-urlencoded; charset=utf-8'}, Stream('foo=bar&foo=baz&boo=zoo\r\n--:--'.encode('utf-8'))) result = yield from obj.form() self.assertEqual([('foo', 'bar'), ('foo', 'baz'), ('boo', 'zoo')], result) def test_read_form_while_closed(self): stream = Stream(b'') obj = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_TYPE: 'application/x-www-form-urlencoded'}, stream) obj._at_eof = True result = yield from obj.form() self.assertEqual(None, result) def test_release(self): stream = Stream(b'Hello,\r\n--:\r\n\r\nworld!\r\n--:--') obj = aiohttp.multipart.BodyPartReader( self.boundary, {}, stream) yield from obj.release() self.assertTrue(obj.at_eof()) self.assertEqual(b'\r\nworld!\r\n--:--', stream.content.read()) self.assertEqual([b'--:\r\n'], list(obj._unread)) def test_release_respects_content_length(self): obj = aiohttp.multipart.BodyPartReader( self.boundary, {'CONTENT-LENGTH': 100500}, Stream(b'.' * 100500 + b'\r\n--:--')) result = yield from obj.release() self.assertIsNone(result) self.assertTrue(obj.at_eof()) def test_release_release(self): stream = Stream(b'Hello,\r\n--:\r\n\r\nworld!\r\n--:--') obj = aiohttp.multipart.BodyPartReader( self.boundary, {}, stream) yield from obj.release() yield from obj.release() self.assertEqual(b'\r\nworld!\r\n--:--', stream.content.read()) self.assertEqual([b'--:\r\n'], list(obj._unread)) def test_filename(self): part = aiohttp.multipart.BodyPartReader( self.boundary, {CONTENT_DISPOSITION: 'attachment; filename=foo.html'}, None) self.assertEqual('foo.html', part.filename) class MultipartReaderTestCase(TestCase): def test_from_response(self): resp = Response({CONTENT_TYPE: 'multipart/related;boundary=":"'}, Stream(b'--:\r\n\r\nhello\r\n--:--')) res = aiohttp.multipart.MultipartReader.from_response(resp) self.assertIsInstance(res, aiohttp.multipart.MultipartResponseWrapper) self.assertIsInstance(res.stream, aiohttp.multipart.MultipartReader) def test_bad_boundary(self): resp = Response( {CONTENT_TYPE: 'multipart/related;boundary=' + 'a' * 80}, Stream(b'')) with self.assertRaises(ValueError): aiohttp.multipart.MultipartReader.from_response(resp) def test_dispatch(self): reader = aiohttp.multipart.MultipartReader( {CONTENT_TYPE: 'multipart/related;boundary=":"'}, Stream(b'--:\r\n\r\necho\r\n--:--')) res = reader._get_part_reader({CONTENT_TYPE: 'text/plain'}) self.assertIsInstance(res, reader.part_reader_cls) def test_dispatch_bodypart(self): reader = aiohttp.multipart.MultipartReader( {CONTENT_TYPE: 'multipart/related;boundary=":"'}, Stream(b'--:\r\n\r\necho\r\n--:--')) res = reader._get_part_reader({CONTENT_TYPE: 'text/plain'}) self.assertIsInstance(res, reader.part_reader_cls) def test_dispatch_multipart(self): reader = aiohttp.multipart.MultipartReader( {CONTENT_TYPE: 'multipart/related;boundary=":"'}, Stream(b'----:--\r\n' b'\r\n' b'test\r\n' b'----:--\r\n' b'\r\n' b'passed\r\n' b'----:----\r\n' b'--:--')) res = reader._get_part_reader( {CONTENT_TYPE: 'multipart/related;boundary=--:--'}) self.assertIsInstance(res, reader.__class__) def test_dispatch_custom_multipart_reader(self): class CustomReader(aiohttp.multipart.MultipartReader): pass reader = aiohttp.multipart.MultipartReader( {CONTENT_TYPE: 'multipart/related;boundary=":"'}, Stream(b'----:--\r\n' b'\r\n' b'test\r\n' b'----:--\r\n' b'\r\n' b'passed\r\n' b'----:----\r\n' b'--:--')) reader.multipart_reader_cls = CustomReader res = reader._get_part_reader( {CONTENT_TYPE: 'multipart/related;boundary=--:--'}) self.assertIsInstance(res, CustomReader) def test_emit_next(self): reader = aiohttp.multipart.MultipartReader( {CONTENT_TYPE: 'multipart/related;boundary=":"'}, Stream(b'--:\r\n\r\necho\r\n--:--')) res = yield from reader.next() self.assertIsInstance(res, reader.part_reader_cls) def test_invalid_boundary(self): reader = aiohttp.multipart.MultipartReader( {CONTENT_TYPE: 'multipart/related;boundary=":"'}, Stream(b'---:\r\n\r\necho\r\n---:--')) with self.assertRaises(ValueError): yield from reader.next() def test_release(self): reader = aiohttp.multipart.MultipartReader( {CONTENT_TYPE: 'multipart/mixed;boundary=":"'}, Stream(b'--:\r\n' b'Content-Type: multipart/related;boundary=--:--\r\n' b'\r\n' b'----:--\r\n' b'\r\n' b'test\r\n' b'----:--\r\n' b'\r\n' b'passed\r\n' b'----:----\r\n' b'--:--')) yield from reader.release() self.assertTrue(reader.at_eof()) def test_release_release(self): reader = aiohttp.multipart.MultipartReader( {CONTENT_TYPE: 'multipart/related;boundary=":"'}, Stream(b'--:\r\n\r\necho\r\n--:--')) yield from reader.release() self.assertTrue(reader.at_eof()) yield from reader.release() self.assertTrue(reader.at_eof()) def test_release_next(self): reader = aiohttp.multipart.MultipartReader( {CONTENT_TYPE: 'multipart/related;boundary=":"'}, Stream(b'--:\r\n\r\necho\r\n--:--')) yield from reader.release() self.assertTrue(reader.at_eof()) res = yield from reader.next() self.assertIsNone(res) def test_second_next_releases_previous_object(self): reader = aiohttp.multipart.MultipartReader( {CONTENT_TYPE: 'multipart/related;boundary=":"'}, Stream(b'--:\r\n' b'\r\n' b'test\r\n' b'--:\r\n' b'\r\n' b'passed\r\n' b'--:--')) first = yield from reader.next() self.assertIsInstance(first, aiohttp.multipart.BodyPartReader) second = yield from reader.next() self.assertTrue(first.at_eof()) self.assertFalse(second.at_eof()) def test_release_without_read_the_last_object(self): reader = aiohttp.multipart.MultipartReader( {CONTENT_TYPE: 'multipart/related;boundary=":"'}, Stream(b'--:\r\n' b'\r\n' b'test\r\n' b'--:\r\n' b'\r\n' b'passed\r\n' b'--:--')) first = yield from reader.next() second = yield from reader.next() third = yield from reader.next() self.assertTrue(first.at_eof()) self.assertTrue(second.at_eof()) self.assertTrue(second.at_eof()) self.assertIsNone(third) def test_read_chunk_by_length_doesnt_breaks_reader(self): reader = aiohttp.multipart.MultipartReader( {CONTENT_TYPE: 'multipart/related;boundary=":"'}, Stream(b'--:\r\n' b'Content-Length: 4\r\n\r\n' b'test' b'\r\n--:\r\n' b'Content-Length: 6\r\n\r\n' b'passed' b'\r\n--:--')) body_parts = [] while True: read_part = b'' part = yield from reader.next() if part is None: break while not part.at_eof(): read_part += yield from part.read_chunk(3) body_parts.append(read_part) self.assertListEqual(body_parts, [b'test', b'passed']) def test_read_chunk_from_stream_doesnt_breaks_reader(self): reader = aiohttp.multipart.MultipartReader( {CONTENT_TYPE: 'multipart/related;boundary=":"'}, Stream(b'--:\r\n' b'\r\n' b'chunk' b'\r\n--:\r\n' b'\r\n' b'two_chunks' b'\r\n--:--')) body_parts = [] while True: read_part = b'' part = yield from reader.next() if part is None: break while not part.at_eof(): chunk = yield from part.read_chunk(5) self.assertTrue(chunk) read_part += chunk body_parts.append(read_part) self.assertListEqual(body_parts, [b'chunk', b'two_chunks']) def test_reading_skips_prelude(self): reader = aiohttp.multipart.MultipartReader( {CONTENT_TYPE: 'multipart/related;boundary=":"'}, Stream(b'Multi-part data is not supported.\r\n' b'\r\n' b'--:\r\n' b'\r\n' b'test\r\n' b'--:\r\n' b'\r\n' b'passed\r\n' b'--:--')) first = yield from reader.next() self.assertIsInstance(first, aiohttp.multipart.BodyPartReader) second = yield from reader.next() self.assertTrue(first.at_eof()) self.assertFalse(second.at_eof()) class BodyPartWriterTestCase(unittest.TestCase): def setUp(self): self.part = aiohttp.multipart.BodyPartWriter(b'') def test_guess_content_length(self): self.part.headers[CONTENT_TYPE] = 'text/plain; charset=utf-8' self.assertIsNone(self.part._guess_content_length({})) self.assertIsNone(self.part._guess_content_length(object())) self.assertEqual(3, self.part._guess_content_length(io.BytesIO(b'foo'))) self.assertEqual(3, self.part._guess_content_length(io.StringIO('foo'))) self.assertEqual(6, self.part._guess_content_length(io.StringIO('мяу'))) self.assertEqual(3, self.part._guess_content_length(b'bar')) self.assertEqual(12, self.part._guess_content_length('пассед')) with open(__file__, 'rb') as f: self.assertEqual(os.fstat(f.fileno()).st_size, self.part._guess_content_length(f)) def test_guess_content_type(self): default = 'application/octet-stream' self.assertEqual(default, self.part._guess_content_type(b'foo')) self.assertEqual('text/plain; charset=utf-8', self.part._guess_content_type('foo')) here = os.path.dirname(__file__) filename = os.path.join(here, 'software_development_in_picture.jpg') with open(filename, 'rb') as f: self.assertEqual('image/jpeg', self.part._guess_content_type(f)) def test_guess_filename(self): class Named: name = 'foo' self.assertIsNone(self.part._guess_filename({})) self.assertIsNone(self.part._guess_filename(object())) self.assertIsNone(self.part._guess_filename(io.BytesIO(b'foo'))) self.assertIsNone(self.part._guess_filename(Named())) with open(__file__, 'rb') as f: self.assertEqual(os.path.basename(f.name), self.part._guess_filename(f)) def test_autoset_content_disposition(self): self.part.obj = open(__file__, 'rb') self.addCleanup(self.part.obj.close) self.part._fill_headers_with_defaults() self.assertIn(CONTENT_DISPOSITION, self.part.headers) fname = os.path.basename(self.part.obj.name) self.assertEqual( 'attachment; filename="{0}"; filename*=utf-8\'\'{0}'.format(fname), self.part.headers[CONTENT_DISPOSITION]) def test_set_content_disposition(self): self.part.set_content_disposition('attachment', foo='bar') self.assertEqual( 'attachment; foo="bar"', self.part.headers[CONTENT_DISPOSITION]) def test_set_content_disposition_bad_type(self): with self.assertRaises(ValueError): self.part.set_content_disposition('foo bar') with self.assertRaises(ValueError): self.part.set_content_disposition('тест') with self.assertRaises(ValueError): self.part.set_content_disposition('foo\x00bar') with self.assertRaises(ValueError): self.part.set_content_disposition('') def test_set_content_disposition_bad_param(self): with self.assertRaises(ValueError): self.part.set_content_disposition('inline', **{'foo bar': 'baz'}) with self.assertRaises(ValueError): self.part.set_content_disposition('inline', **{'тест': 'baz'}) with self.assertRaises(ValueError): self.part.set_content_disposition('inline', **{'': 'baz'}) with self.assertRaises(ValueError): self.part.set_content_disposition('inline', **{'foo\x00bar': 'baz'}) def test_serialize_bytes(self): self.assertEqual(b'foo', next(self.part._serialize_bytes(b'foo'))) def test_serialize_str(self): self.assertEqual(b'foo', next(self.part._serialize_str('foo'))) def test_serialize_str_custom_encoding(self): self.part.headers[CONTENT_TYPE] = \ 'text/plain;charset=cp1251' self.assertEqual('привет'.encode('cp1251'), next(self.part._serialize_str('привет'))) def test_serialize_io(self): self.assertEqual(b'foo', next(self.part._serialize_io(io.BytesIO(b'foo')))) self.assertEqual(b'foo', next(self.part._serialize_io(io.StringIO('foo')))) def test_serialize_io_chunk(self): flo = io.BytesIO(b'foobarbaz') self.part._chunk_size = 3 self.assertEqual([b'foo', b'bar', b'baz'], list(self.part._serialize_io(flo))) def test_serialize_json(self): self.assertEqual(b'{"\\u043f\\u0440\\u0438\\u0432\\u0435\\u0442":' b' "\\u043c\\u0438\\u0440"}', next(self.part._serialize_json({'привет': 'мир'}))) def test_serialize_form(self): data = [('foo', 'bar'), ('foo', 'baz'), ('boo', 'zoo')] self.assertEqual(b'foo=bar&foo=baz&boo=zoo', next(self.part._serialize_form(data))) def test_serialize_form_dict(self): data = {'hello': 'мир'} self.assertEqual(b'hello=%D0%BC%D0%B8%D1%80', next(self.part._serialize_form(data))) def test_serialize_multipart(self): multipart = aiohttp.multipart.MultipartWriter(boundary=':') multipart.append('foo-bar-baz') multipart.append_json({'test': 'passed'}) self.assertEqual( [b'--:\r\n', b'Content-Type: text/plain; charset=utf-8\r\n' b'Content-Length: 11', b'\r\n\r\n', b'foo-bar-baz', b'\r\n', b'--:\r\n', b'Content-Type: application/json', b'\r\n\r\n', b'{"test": "passed"}', b'\r\n', b'--:--\r\n', b''], list(self.part._serialize_multipart(multipart)) ) def test_serialize_default(self): with self.assertRaises(TypeError): self.part.obj = object() list(self.part.serialize()) with self.assertRaises(TypeError): next(self.part._serialize_default(object())) def test_serialize_with_content_encoding_gzip(self): part = aiohttp.multipart.BodyPartWriter( 'Time to Relax!', {CONTENT_ENCODING: 'gzip'}) stream = part.serialize() self.assertEqual(b'Content-Encoding: gzip\r\n' b'Content-Type: text/plain; charset=utf-8', next(stream)) self.assertEqual(b'\r\n\r\n', next(stream)) result = b''.join(stream) decompressor = zlib.decompressobj(wbits=16+zlib.MAX_WBITS) data = decompressor.decompress(result) self.assertEqual(b'Time to Relax!', data) self.assertIsNone(next(stream, None)) def test_serialize_with_content_encoding_deflate(self): part = aiohttp.multipart.BodyPartWriter( 'Time to Relax!', {CONTENT_ENCODING: 'deflate'}) stream = part.serialize() self.assertEqual(b'Content-Encoding: deflate\r\n' b'Content-Type: text/plain; charset=utf-8', next(stream)) self.assertEqual(b'\r\n\r\n', next(stream)) thing = b'\x0b\xc9\xccMU(\xc9W\x08J\xcdI\xacP\x04\x00\r\n' self.assertEqual(thing, b''.join(stream)) self.assertIsNone(next(stream, None)) def test_serialize_with_content_encoding_identity(self): thing = b'\x0b\xc9\xccMU(\xc9W\x08J\xcdI\xacP\x04\x00' part = aiohttp.multipart.BodyPartWriter( thing, {CONTENT_ENCODING: 'identity'}) stream = part.serialize() self.assertEqual(b'Content-Encoding: identity\r\n' b'Content-Type: application/octet-stream\r\n' b'Content-Length: 16', next(stream)) self.assertEqual(b'\r\n\r\n', next(stream)) self.assertEqual(thing, next(stream)) self.assertEqual(b'\r\n', next(stream)) self.assertIsNone(next(stream, None)) def test_serialize_with_content_encoding_unknown(self): part = aiohttp.multipart.BodyPartWriter( 'Time to Relax!', {CONTENT_ENCODING: 'snappy'}) with self.assertRaises(RuntimeError): list(part.serialize()) def test_serialize_with_content_transfer_encoding_base64(self): part = aiohttp.multipart.BodyPartWriter( 'Time to Relax!', {CONTENT_TRANSFER_ENCODING: 'base64'}) stream = part.serialize() self.assertEqual(b'Content-Transfer-Encoding: base64\r\n' b'Content-Type: text/plain; charset=utf-8', next(stream)) self.assertEqual(b'\r\n\r\n', next(stream)) self.assertEqual(b'VGltZSB0byBSZWxh', next(stream)) self.assertEqual(b'eCE=', next(stream)) self.assertEqual(b'\r\n', next(stream)) self.assertIsNone(next(stream, None)) def test_serialize_io_with_content_transfer_encoding_base64(self): part = aiohttp.multipart.BodyPartWriter( io.BytesIO(b'Time to Relax!'), {CONTENT_TRANSFER_ENCODING: 'base64'}) part._chunk_size = 6 stream = part.serialize() self.assertEqual(b'Content-Transfer-Encoding: base64\r\n' b'Content-Type: application/octet-stream', next(stream)) self.assertEqual(b'\r\n\r\n', next(stream)) self.assertEqual(b'VGltZSB0', next(stream)) self.assertEqual(b'byBSZWxh', next(stream)) self.assertEqual(b'eCE=', next(stream)) self.assertEqual(b'\r\n', next(stream)) self.assertIsNone(next(stream, None)) def test_serialize_with_content_transfer_encoding_quote_printable(self): part = aiohttp.multipart.BodyPartWriter( 'Привет, мир!', {CONTENT_TRANSFER_ENCODING: 'quoted-printable'}) stream = part.serialize() self.assertEqual(b'Content-Transfer-Encoding: quoted-printable\r\n' b'Content-Type: text/plain; charset=utf-8', next(stream)) self.assertEqual(b'\r\n\r\n', next(stream)) self.assertEqual(b'=D0=9F=D1=80=D0=B8=D0=B2=D0=B5=D1=82,' b' =D0=BC=D0=B8=D1=80!', next(stream)) self.assertEqual(b'\r\n', next(stream)) self.assertIsNone(next(stream, None)) def test_serialize_with_content_transfer_encoding_binary(self): part = aiohttp.multipart.BodyPartWriter( 'Привет, мир!'.encode('utf-8'), {CONTENT_TRANSFER_ENCODING: 'binary'}) stream = part.serialize() self.assertEqual(b'Content-Transfer-Encoding: binary\r\n' b'Content-Type: application/octet-stream', next(stream)) self.assertEqual(b'\r\n\r\n', next(stream)) self.assertEqual(b'\xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82,' b' \xd0\xbc\xd0\xb8\xd1\x80!', next(stream)) self.assertEqual(b'\r\n', next(stream)) self.assertIsNone(next(stream, None)) def test_serialize_with_content_transfer_encoding_unknown(self): part = aiohttp.multipart.BodyPartWriter( 'Time to Relax!', {CONTENT_TRANSFER_ENCODING: 'unknown'}) with self.assertRaises(RuntimeError): list(part.serialize()) def test_filename(self): self.part.set_content_disposition('related', filename='foo.html') self.assertEqual('foo.html', self.part.filename) class MultipartWriterTestCase(unittest.TestCase): def setUp(self): self.writer = aiohttp.multipart.MultipartWriter(boundary=':') def test_default_subtype(self): mtype, stype, *_ = parse_mimetype( self.writer.headers.get(CONTENT_TYPE)) self.assertEqual('multipart', mtype) self.assertEqual('mixed', stype) def test_bad_boundary(self): with self.assertRaises(ValueError): aiohttp.multipart.MultipartWriter(boundary='тест') def test_default_headers(self): self.assertEqual({CONTENT_TYPE: 'multipart/mixed; boundary=":"'}, self.writer.headers) def test_iter_parts(self): self.writer.append('foo') self.writer.append('bar') self.writer.append('baz') self.assertEqual(3, len(list(self.writer))) def test_append(self): self.assertEqual(0, len(self.writer)) self.writer.append('hello, world!') self.assertEqual(1, len(self.writer)) self.assertIsInstance(self.writer.parts[0], self.writer.part_writer_cls) def test_append_with_headers(self): self.writer.append('hello, world!', {'x-foo': 'bar'}) self.assertEqual(1, len(self.writer)) self.assertIn('x-foo', self.writer.parts[0].headers) self.assertEqual(self.writer.parts[0].headers['x-foo'], 'bar') def test_append_json(self): self.writer.append_json({'foo': 'bar'}) self.assertEqual(1, len(self.writer)) part = self.writer.parts[0] self.assertEqual(part.headers[CONTENT_TYPE], 'application/json') def test_append_part(self): part = aiohttp.multipart.BodyPartWriter('test', {CONTENT_TYPE: 'text/plain'}) self.writer.append(part, {CONTENT_TYPE: 'test/passed'}) self.assertEqual(1, len(self.writer)) part = self.writer.parts[0] self.assertEqual(part.headers[CONTENT_TYPE], 'test/passed') def test_append_json_overrides_content_type(self): self.writer.append_json({'foo': 'bar'}, {CONTENT_TYPE: 'test/passed'}) self.assertEqual(1, len(self.writer)) part = self.writer.parts[0] self.assertEqual(part.headers[CONTENT_TYPE], 'application/json') def test_append_form(self): self.writer.append_form({'foo': 'bar'}, {CONTENT_TYPE: 'test/passed'}) self.assertEqual(1, len(self.writer)) part = self.writer.parts[0] self.assertEqual(part.headers[CONTENT_TYPE], 'application/x-www-form-urlencoded') def test_serialize(self): self.assertEqual([b''], list(self.writer.serialize())) def test_with(self): with aiohttp.multipart.MultipartWriter(boundary=':') as writer: writer.append('foo') writer.append(b'bar') writer.append_json({'baz': True}) self.assertEqual(3, len(writer)) class ParseContentDispositionTestCase(unittest.TestCase): # http://greenbytes.de/tech/tc2231/ def test_parse_empty(self): disptype, params = parse_content_disposition(None) self.assertEqual(None, disptype) self.assertEqual({}, params) def test_inlonly(self): disptype, params = parse_content_disposition('inline') self.assertEqual('inline', disptype) self.assertEqual({}, params) def test_inlonlyquoted(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition('"inline"') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_inlwithasciifilename(self): disptype, params = parse_content_disposition( 'inline; filename="foo.html"') self.assertEqual('inline', disptype) self.assertEqual({'filename': 'foo.html'}, params) def test_inlwithfnattach(self): disptype, params = parse_content_disposition( 'inline; filename="Not an attachment!"') self.assertEqual('inline', disptype) self.assertEqual({'filename': 'Not an attachment!'}, params) def test_attonly(self): disptype, params = parse_content_disposition('attachment') self.assertEqual('attachment', disptype) self.assertEqual({}, params) def test_attonlyquoted(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition('"attachment"') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attonlyucase(self): disptype, params = parse_content_disposition('ATTACHMENT') self.assertEqual('attachment', disptype) self.assertEqual({}, params) def test_attwithasciifilename(self): disptype, params = parse_content_disposition( 'attachment; filename="foo.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo.html'}, params) def test_inlwithasciifilenamepdf(self): disptype, params = parse_content_disposition( 'attachment; filename="foo.pdf"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo.pdf'}, params) def test_attwithasciifilename25(self): disptype, params = parse_content_disposition( 'attachment; filename="0000000000111111111122222"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': '0000000000111111111122222'}, params) def test_attwithasciifilename35(self): disptype, params = parse_content_disposition( 'attachment; filename="00000000001111111111222222222233333"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': '00000000001111111111222222222233333'}, params) def test_attwithasciifnescapedchar(self): disptype, params = parse_content_disposition( r'attachment; filename="f\oo.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo.html'}, params) def test_attwithasciifnescapedquote(self): disptype, params = parse_content_disposition( 'attachment; filename="\"quoting\" tested.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': '"quoting" tested.html'}, params) @unittest.skip('need more smart parser which respects quoted text') def test_attwithquotedsemicolon(self): disptype, params = parse_content_disposition( 'attachment; filename="Here\'s a semicolon;.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'Here\'s a semicolon;.html'}, params) def test_attwithfilenameandextparam(self): disptype, params = parse_content_disposition( 'attachment; foo="bar"; filename="foo.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo.html', 'foo': 'bar'}, params) def test_attwithfilenameandextparamescaped(self): disptype, params = parse_content_disposition( 'attachment; foo="\"\\";filename="foo.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo.html', 'foo': '"\\'}, params) def test_attwithasciifilenameucase(self): disptype, params = parse_content_disposition( 'attachment; FILENAME="foo.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo.html'}, params) def test_attwithasciifilenamenq(self): disptype, params = parse_content_disposition( 'attachment; filename=foo.html') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo.html'}, params) def test_attwithtokfncommanq(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment; filename=foo,bar.html') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attwithasciifilenamenqs(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment; filename=foo.html ;') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attemptyparam(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment; ;filename=foo') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attwithasciifilenamenqws(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment; filename=foo bar.html') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attwithfntokensq(self): disptype, params = parse_content_disposition( "attachment; filename='foo.html'") self.assertEqual('attachment', disptype) self.assertEqual({'filename': "'foo.html'"}, params) def test_attwithisofnplain(self): disptype, params = parse_content_disposition( 'attachment; filename="foo-ä.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo-ä.html'}, params) def test_attwithutf8fnplain(self): disptype, params = parse_content_disposition( 'attachment; filename="foo-ä.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo-ä.html'}, params) def test_attwithfnrawpctenca(self): disptype, params = parse_content_disposition( 'attachment; filename="foo-%41.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo-%41.html'}, params) def test_attwithfnusingpct(self): disptype, params = parse_content_disposition( 'attachment; filename="50%.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': '50%.html'}, params) def test_attwithfnrawpctencaq(self): disptype, params = parse_content_disposition( r'attachment; filename="foo-%\41.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': r'foo-%41.html'}, params) def test_attwithnamepct(self): disptype, params = parse_content_disposition( 'attachment; filename="foo-%41.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo-%41.html'}, params) def test_attwithfilenamepctandiso(self): disptype, params = parse_content_disposition( 'attachment; filename="ä-%41.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'ä-%41.html'}, params) def test_attwithfnrawpctenclong(self): disptype, params = parse_content_disposition( 'attachment; filename="foo-%c3%a4-%e2%82%ac.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo-%c3%a4-%e2%82%ac.html'}, params) def test_attwithasciifilenamews1(self): disptype, params = parse_content_disposition( 'attachment; filename ="foo.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo.html'}, params) def test_attwith2filenames(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment; filename="foo.html"; filename="bar.html"') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attfnbrokentoken(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment; filename=foo[1](2).html') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attfnbrokentokeniso(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment; filename=foo-ä.html') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attfnbrokentokenutf(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment; filename=foo-ä.html') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attmissingdisposition(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'filename=foo.html') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attmissingdisposition2(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'x=y; filename=foo.html') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attmissingdisposition3(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( '"foo; filename=bar;baz"; filename=qux') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attmissingdisposition4(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'filename=foo.html, filename=bar.html') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_emptydisposition(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( '; filename=foo.html') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_doublecolon(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( ': inline; attachment; filename=foo.html') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attandinline(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'inline; attachment; filename=foo.html') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attandinline2(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment; inline; filename=foo.html') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attbrokenquotedfn(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment; filename="foo.html".txt') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attbrokenquotedfn2(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment; filename="bar') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attbrokenquotedfn3(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment; filename=foo"bar;baz"qux') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attmultinstances(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment; filename=foo.html, attachment; filename=bar.html') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attmissingdelim(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment; foo=foo filename=bar') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attmissingdelim2(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment; filename=bar foo=foo') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attmissingdelim3(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment filename=bar') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attreversed(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'filename=foo.html; attachment') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attconfusedparam(self): disptype, params = parse_content_disposition( 'attachment; xfilename=foo.html') self.assertEqual('attachment', disptype) self.assertEqual({'xfilename': 'foo.html'}, params) def test_attabspath(self): disptype, params = parse_content_disposition( 'attachment; filename="/foo.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo.html'}, params) def test_attabspathwin(self): disptype, params = parse_content_disposition( 'attachment; filename="\\foo.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo.html'}, params) def test_attcdate(self): disptype, params = parse_content_disposition( 'attachment; creation-date="Wed, 12 Feb 1997 16:29:51 -0500"') self.assertEqual('attachment', disptype) self.assertEqual({'creation-date': 'Wed, 12 Feb 1997 16:29:51 -0500'}, params) def test_attmdate(self): disptype, params = parse_content_disposition( 'attachment; modification-date="Wed, 12 Feb 1997 16:29:51 -0500"') self.assertEqual('attachment', disptype) self.assertEqual( {'modification-date': 'Wed, 12 Feb 1997 16:29:51 -0500'}, params) def test_dispext(self): disptype, params = parse_content_disposition('foobar') self.assertEqual('foobar', disptype) self.assertEqual({}, params) def test_dispextbadfn(self): disptype, params = parse_content_disposition( 'attachment; example="filename=example.txt"') self.assertEqual('attachment', disptype) self.assertEqual({'example': 'filename=example.txt'}, params) def test_attwithisofn2231iso(self): disptype, params = parse_content_disposition( "attachment; filename*=iso-8859-1''foo-%E4.html") self.assertEqual('attachment', disptype) self.assertEqual({'filename*': 'foo-ä.html'}, params) def test_attwithfn2231utf8(self): disptype, params = parse_content_disposition( "attachment; filename*=UTF-8''foo-%c3%a4-%e2%82%ac.html") self.assertEqual('attachment', disptype) self.assertEqual({'filename*': 'foo-ä-€.html'}, params) def test_attwithfn2231noc(self): disptype, params = parse_content_disposition( "attachment; filename*=''foo-%c3%a4-%e2%82%ac.html") self.assertEqual('attachment', disptype) self.assertEqual({'filename*': 'foo-ä-€.html'}, params) def test_attwithfn2231utf8comp(self): disptype, params = parse_content_disposition( "attachment; filename*=UTF-8''foo-a%cc%88.html") self.assertEqual('attachment', disptype) self.assertEqual({'filename*': 'foo-ä.html'}, params) @unittest.skip('should raise decoding error: %82 is invalid for latin1') def test_attwithfn2231utf8_bad(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionParam): disptype, params = parse_content_disposition( "attachment; filename*=iso-8859-1''foo-%c3%a4-%e2%82%ac.html") self.assertEqual('attachment', disptype) self.assertEqual({}, params) @unittest.skip('should raise decoding error: %E4 is invalid for utf-8') def test_attwithfn2231iso_bad(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionParam): disptype, params = parse_content_disposition( "attachment; filename*=utf-8''foo-%E4.html") self.assertEqual('attachment', disptype) self.assertEqual({}, params) def test_attwithfn2231ws1(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionParam): disptype, params = parse_content_disposition( "attachment; filename *=UTF-8''foo-%c3%a4.html") self.assertEqual('attachment', disptype) self.assertEqual({}, params) def test_attwithfn2231ws2(self): disptype, params = parse_content_disposition( "attachment; filename*= UTF-8''foo-%c3%a4.html") self.assertEqual('attachment', disptype) self.assertEqual({'filename*': 'foo-ä.html'}, params) def test_attwithfn2231ws3(self): disptype, params = parse_content_disposition( "attachment; filename* =UTF-8''foo-%c3%a4.html") self.assertEqual('attachment', disptype) self.assertEqual({'filename*': 'foo-ä.html'}, params) def test_attwithfn2231quot(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionParam): disptype, params = parse_content_disposition( "attachment; filename*=\"UTF-8''foo-%c3%a4.html\"") self.assertEqual('attachment', disptype) self.assertEqual({}, params) def test_attwithfn2231quot2(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionParam): disptype, params = parse_content_disposition( "attachment; filename*=\"foo%20bar.html\"") self.assertEqual('attachment', disptype) self.assertEqual({}, params) def test_attwithfn2231singleqmissing(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionParam): disptype, params = parse_content_disposition( "attachment; filename*=UTF-8'foo-%c3%a4.html") self.assertEqual('attachment', disptype) self.assertEqual({}, params) @unittest.skip('urllib.parse.unquote is tolerate to standalone % chars') def test_attwithfn2231nbadpct1(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionParam): disptype, params = parse_content_disposition( "attachment; filename*=UTF-8''foo%") self.assertEqual('attachment', disptype) self.assertEqual({}, params) @unittest.skip('urllib.parse.unquote is tolerate to standalone % chars') def test_attwithfn2231nbadpct2(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionParam): disptype, params = parse_content_disposition( "attachment; filename*=UTF-8''f%oo.html") self.assertEqual('attachment', disptype) self.assertEqual({}, params) def test_attwithfn2231dpct(self): disptype, params = parse_content_disposition( "attachment; filename*=UTF-8''A-%2541.html") self.assertEqual('attachment', disptype) self.assertEqual({'filename*': 'A-%41.html'}, params) def test_attwithfn2231abspathdisguised(self): disptype, params = parse_content_disposition( "attachment; filename*=UTF-8''%5cfoo.html") self.assertEqual('attachment', disptype) self.assertEqual({'filename*': '\\foo.html'}, params) def test_attfncont(self): disptype, params = parse_content_disposition( 'attachment; filename*0="foo."; filename*1="html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename*0': 'foo.', 'filename*1': 'html'}, params) def test_attfncontqs(self): disptype, params = parse_content_disposition( r'attachment; filename*0="foo"; filename*1="\b\a\r.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename*0': 'foo', 'filename*1': 'bar.html'}, params) def test_attfncontenc(self): disptype, params = parse_content_disposition( 'attachment; filename*0*=UTF-8''foo-%c3%a4; filename*1=".html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename*0*': 'UTF-8''foo-%c3%a4', 'filename*1': '.html'}, params) def test_attfncontlz(self): disptype, params = parse_content_disposition( 'attachment; filename*0="foo"; filename*01="bar"') self.assertEqual('attachment', disptype) self.assertEqual({'filename*0': 'foo', 'filename*01': 'bar'}, params) def test_attfncontnc(self): disptype, params = parse_content_disposition( 'attachment; filename*0="foo"; filename*2="bar"') self.assertEqual('attachment', disptype) self.assertEqual({'filename*0': 'foo', 'filename*2': 'bar'}, params) def test_attfnconts1(self): disptype, params = parse_content_disposition( 'attachment; filename*0="foo."; filename*2="html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename*0': 'foo.', 'filename*2': 'html'}, params) def test_attfncontord(self): disptype, params = parse_content_disposition( 'attachment; filename*1="bar"; filename*0="foo"') self.assertEqual('attachment', disptype) self.assertEqual({'filename*0': 'foo', 'filename*1': 'bar'}, params) def test_attfnboth(self): disptype, params = parse_content_disposition( 'attachment; filename="foo-ae.html";' " filename*=UTF-8''foo-%c3%a4.html") self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo-ae.html', 'filename*': 'foo-ä.html'}, params) def test_attfnboth2(self): disptype, params = parse_content_disposition( "attachment; filename*=UTF-8''foo-%c3%a4.html;" ' filename="foo-ae.html"') self.assertEqual('attachment', disptype) self.assertEqual({'filename': 'foo-ae.html', 'filename*': 'foo-ä.html'}, params) def test_attfnboth3(self): disptype, params = parse_content_disposition( "attachment; filename*0*=ISO-8859-15''euro-sign%3d%a4;" " filename*=ISO-8859-1''currency-sign%3d%a4") self.assertEqual('attachment', disptype) self.assertEqual({'filename*': 'currency-sign=¤', 'filename*0*': "ISO-8859-15''euro-sign%3d%a4"}, params) def test_attnewandfn(self): disptype, params = parse_content_disposition( 'attachment; foobar=x; filename="foo.html"') self.assertEqual('attachment', disptype) self.assertEqual({'foobar': 'x', 'filename': 'foo.html'}, params) def test_attrfc2047token(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionHeader): disptype, params = parse_content_disposition( 'attachment; filename==?ISO-8859-1?Q?foo-=E4.html?=') self.assertEqual(None, disptype) self.assertEqual({}, params) def test_attrfc2047quoted(self): disptype, params = parse_content_disposition( 'attachment; filename="=?ISO-8859-1?Q?foo-=E4.html?="') self.assertEqual('attachment', disptype) self.assertEqual({'filename': '=?ISO-8859-1?Q?foo-=E4.html?='}, params) def test_bad_continuous_param(self): with self.assertWarns(aiohttp.multipart.BadContentDispositionParam): disptype, params = parse_content_disposition( 'attachment; filename*0=foo bar') self.assertEqual('attachment', disptype) self.assertEqual({}, params) class ContentDispositionFilenameTestCase(unittest.TestCase): # http://greenbytes.de/tech/tc2231/ def test_no_filename(self): self.assertIsNone(content_disposition_filename({})) self.assertIsNone(content_disposition_filename({'foo': 'bar'})) def test_filename(self): params = {'filename': 'foo.html'} self.assertEqual('foo.html', content_disposition_filename(params)) def test_filename_ext(self): params = {'filename*': 'файл.html'} self.assertEqual('файл.html', content_disposition_filename(params)) def test_attfncont(self): params = {'filename*0': 'foo.', 'filename*1': 'html'} self.assertEqual('foo.html', content_disposition_filename(params)) def test_attfncontqs(self): params = {'filename*0': 'foo', 'filename*1': 'bar.html'} self.assertEqual('foobar.html', content_disposition_filename(params)) def test_attfncontenc(self): params = {'filename*0*': "UTF-8''foo-%c3%a4", 'filename*1': '.html'} self.assertEqual('foo-ä.html', content_disposition_filename(params)) def test_attfncontlz(self): params = {'filename*0': 'foo', 'filename*01': 'bar'} self.assertEqual('foo', content_disposition_filename(params)) def test_attfncontnc(self): params = {'filename*0': 'foo', 'filename*2': 'bar'} self.assertEqual('foo', content_disposition_filename(params)) def test_attfnconts1(self): params = {'filename*1': 'foo', 'filename*2': 'bar'} self.assertEqual(None, content_disposition_filename(params)) def test_attfnboth(self): params = {'filename': 'foo-ae.html', 'filename*': 'foo-ä.html'} self.assertEqual('foo-ä.html', content_disposition_filename(params)) def test_attfnboth3(self): params = {'filename*0*': "ISO-8859-15''euro-sign%3d%a4", 'filename*': 'currency-sign=¤'} self.assertEqual('currency-sign=¤', content_disposition_filename(params)) def test_attrfc2047quoted(self): params = {'filename': '=?ISO-8859-1?Q?foo-=E4.html?='} self.assertEqual('=?ISO-8859-1?Q?foo-=E4.html?=', content_disposition_filename(params)) aiohttp-1.2.0/tests/test_stream_parser.py0000664000175000017500000002205013025134363021447 0ustar travistravis00000000000000"""Tests for parsers.py""" from unittest import mock import pytest from aiohttp import parsers DATA = b'line1\nline2\nline3\n' class LinesParser: """Lines parser. Lines parser splits a bytes stream into a chunks of data, each chunk ends with \\n symbol.""" def __init__(self): pass def __call__(self, out, buf): try: while True: chunk = yield from buf.readuntil(b'\n', 0xffff) out.feed_data(chunk, len(chunk)) except parsers.EofStream: pass @pytest.fixture def lines_parser(): return LinesParser() def test_at_eof(loop): proto = parsers.StreamParser(loop=loop) assert not proto.at_eof() proto.feed_eof() assert proto.at_eof() def test_exception(loop): stream = parsers.StreamParser(loop=loop) assert stream.exception() is None exc = ValueError() stream.set_exception(exc) assert stream.exception() is exc def test_exception_connection_error(loop): stream = parsers.StreamParser(loop=loop) assert stream.exception() is None exc = ConnectionError() stream.set_exception(exc) assert stream.exception() is not exc assert isinstance(stream.exception(), RuntimeError) assert stream.exception().__cause__ is exc assert stream.exception().__context__ is exc def test_exception_waiter(loop, lines_parser): stream = parsers.StreamParser(loop=loop) stream._parser = lines_parser buf = stream._output = parsers.FlowControlDataQueue( stream, loop=loop) exc = ValueError() stream.set_exception(exc) assert buf.exception() is exc def test_feed_data(loop): stream = parsers.StreamParser(loop=loop) stream.feed_data(DATA) assert DATA == bytes(stream._buffer) def test_feed_none_data(loop): stream = parsers.StreamParser(loop=loop) stream.feed_data(None) assert b'' == bytes(stream._buffer) def test_set_parser_unset_prev(loop, lines_parser): stream = parsers.StreamParser(loop=loop) stream.set_parser(lines_parser) unset = stream.unset_parser = mock.Mock() stream.set_parser(lines_parser) assert unset.called def test_set_parser_exception(loop, lines_parser): stream = parsers.StreamParser(loop=loop) exc = ValueError() stream.set_exception(exc) s = stream.set_parser(lines_parser) assert s.exception() is exc def test_set_parser_feed_existing(loop, lines_parser): stream = parsers.StreamParser(loop=loop) stream.feed_data(b'line1') stream.feed_data(b'\r\nline2\r\ndata') s = stream.set_parser(lines_parser) assert ([(bytearray(b'line1\r\n'), 7), (bytearray(b'line2\r\n'), 7)] == list(s._buffer)) assert b'data' == bytes(stream._buffer) assert stream._parser is not None stream.unset_parser() assert stream._parser is None assert b'data' == bytes(stream._buffer) assert s._eof def test_set_parser_feed_existing_exc(loop): def p(out, buf): yield from buf.read(1) raise ValueError() stream = parsers.StreamParser(loop=loop) stream.feed_data(b'line1') s = stream.set_parser(p) assert isinstance(s.exception(), ValueError) def test_set_parser_feed_existing_eof(loop, lines_parser): stream = parsers.StreamParser(loop=loop) stream.feed_data(b'line1') stream.feed_data(b'\r\nline2\r\ndata') stream.feed_eof() s = stream.set_parser(lines_parser) assert ([(bytearray(b'line1\r\n'), 7), (bytearray(b'line2\r\n'), 7)] == list(s._buffer)) assert b'data' == bytes(stream._buffer) assert stream._parser is None def test_set_parser_feed_existing_eof_exc(loop): def p(out, buf): try: while True: yield # read chunk except parsers.EofStream: raise ValueError() stream = parsers.StreamParser(loop=loop) stream.feed_data(b'line1') stream.feed_eof() s = stream.set_parser(p) assert isinstance(s.exception(), ValueError) def test_set_parser_feed_existing_eof_unhandled_eof(loop): def p(out, buf): while True: yield # read chunk stream = parsers.StreamParser(loop=loop) stream.feed_data(b'line1') stream.feed_eof() s = stream.set_parser(p) assert not s.is_eof() assert isinstance(s.exception(), RuntimeError) def test_set_parser_unset(loop, lines_parser): stream = parsers.StreamParser(loop=loop) s = stream.set_parser(lines_parser) stream.feed_data(b'line1\r\nline2\r\n') assert ([(bytearray(b'line1\r\n'), 7), (bytearray(b'line2\r\n'), 7)] == list(s._buffer)) assert b'' == bytes(stream._buffer) stream.unset_parser() assert s._eof assert b'' == bytes(stream._buffer) def test_set_parser_feed_existing_stop(loop): def LinesParser(out, buf): try: chunk = yield from buf.readuntil(b'\n') out.feed_data(chunk, len(chunk)) chunk = yield from buf.readuntil(b'\n') out.feed_data(chunk, len(chunk)) finally: out.feed_eof() stream = parsers.StreamParser(loop=loop) stream.feed_data(b'line1') stream.feed_data(b'\r\nline2\r\ndata') s = stream.set_parser(LinesParser) assert b'line1\r\nline2\r\n' == b''.join(d for d, _ in s._buffer) assert b'data' == bytes(stream._buffer) assert stream._parser is None assert s._eof def test_feed_parser(loop, lines_parser): stream = parsers.StreamParser(loop=loop) s = stream.set_parser(lines_parser) stream.feed_data(b'line1') stream.feed_data(b'\r\nline2\r\ndata') assert b'data' == bytes(stream._buffer) stream.feed_eof() assert ([(bytearray(b'line1\r\n'), 7), (bytearray(b'line2\r\n'), 7)] == list(s._buffer)) assert b'data' == bytes(stream._buffer) assert s.is_eof() def test_feed_parser_exc(loop): def p(out, buf): yield # read chunk raise ValueError() stream = parsers.StreamParser(loop=loop) s = stream.set_parser(p) stream.feed_data(b'line1') assert isinstance(s.exception(), ValueError) assert b'' == bytes(stream._buffer) def test_feed_parser_stop(loop): def p(out, buf): yield # chunk stream = parsers.StreamParser(loop=loop) stream.set_parser(p) stream.feed_data(b'line1') assert stream._parser is None assert b'' == bytes(stream._buffer) def test_feed_eof_exc(loop): def p(out, buf): try: while True: yield # read chunk except parsers.EofStream: raise ValueError() stream = parsers.StreamParser(loop=loop) s = stream.set_parser(p) stream.feed_data(b'line1') assert s.exception() is None stream.feed_eof() assert isinstance(s.exception(), ValueError) def test_feed_eof_stop(loop): def p(out, buf): try: while True: yield # read chunk except parsers.EofStream: out.feed_eof() stream = parsers.StreamParser(loop=loop) s = stream.set_parser(p) stream.feed_data(b'line1') stream.feed_eof() assert s._eof def test_feed_eof_unhandled_eof(loop): def p(out, buf): while True: yield # read chunk stream = parsers.StreamParser(loop=loop) s = stream.set_parser(p) stream.feed_data(b'line1') stream.feed_eof() assert not s.is_eof() assert isinstance(s.exception(), RuntimeError) def test_feed_parser2(loop, lines_parser): stream = parsers.StreamParser(loop=loop) s = stream.set_parser(lines_parser) stream.feed_data(b'line1\r\nline2\r\n') stream.feed_eof() assert ([(bytearray(b'line1\r\n'), 7), (bytearray(b'line2\r\n'), 7)] == list(s._buffer)) assert b'' == bytes(stream._buffer) assert s._eof def test_unset_parser_eof_exc(loop): def p(out, buf): try: while True: yield # read chunk except parsers.EofStream: raise ValueError() stream = parsers.StreamParser(loop=loop) s = stream.set_parser(p) stream.feed_data(b'line1') stream.unset_parser() assert isinstance(s.exception(), ValueError) assert stream._parser is None def test_unset_parser_eof_unhandled_eof(loop): def p(out, buf): while True: yield # read chunk stream = parsers.StreamParser(loop=loop) s = stream.set_parser(p) stream.feed_data(b'line1') stream.unset_parser() assert isinstance(s.exception(), RuntimeError) assert not s.is_eof() def test_unset_parser_stop(loop): def p(out, buf): try: while True: yield # read chunk except parsers.EofStream: out.feed_eof() stream = parsers.StreamParser(loop=loop) s = stream.set_parser(p) stream.feed_data(b'line1') stream.unset_parser() assert s._eof def test_eof_exc(loop): def p(out, buf): while True: yield # read chunk class CustomEofErr(Exception): pass stream = parsers.StreamParser(eof_exc_class=CustomEofErr, loop=loop) s = stream.set_parser(p) stream.feed_eof() assert isinstance(s.exception(), CustomEofErr) aiohttp-1.2.0/tests/test_connector.py0000664000175000017500000007061613025134363020605 0ustar travistravis00000000000000"""Tests of http client with custom Connector""" import asyncio import gc import os.path import shutil import socket import ssl import tempfile import unittest from unittest import mock import pytest from yarl import URL import aiohttp from aiohttp import client, helpers, web from aiohttp.client import ClientRequest from aiohttp.connector import Connection from aiohttp.test_utils import unused_port def test_del(loop): conn = aiohttp.BaseConnector(loop=loop) transp = unittest.mock.Mock() conn._conns['a'] = [(transp, 'proto', 123)] conns_impl = conn._conns exc_handler = unittest.mock.Mock() loop.set_exception_handler(exc_handler) with pytest.warns(ResourceWarning): del conn gc.collect() assert not conns_impl transp.close.assert_called_with() msg = {'connector': unittest.mock.ANY, # conn was deleted 'connections': unittest.mock.ANY, 'message': 'Unclosed connector'} if loop.get_debug(): msg['source_traceback'] = unittest.mock.ANY exc_handler.assert_called_with(loop, msg) @pytest.mark.xfail @asyncio.coroutine def test_del_with_scheduled_cleanup(loop): conn = aiohttp.BaseConnector(loop=loop, keepalive_timeout=0.01) transp = unittest.mock.Mock() conn._conns['a'] = [(transp, 'proto', 123)] conns_impl = conn._conns conn._start_cleanup_task() exc_handler = unittest.mock.Mock() loop.set_exception_handler(exc_handler) with pytest.warns(ResourceWarning): # obviously doesn't deletion because loop has a strong # reference to connector's instance method, isn't it? del conn yield from asyncio.sleep(0.01, loop=loop) gc.collect() assert not conns_impl transp.close.assert_called_with() msg = {'connector': unittest.mock.ANY, # conn was deleted 'message': 'Unclosed connector'} if loop.get_debug(): msg['source_traceback'] = unittest.mock.ANY exc_handler.assert_called_with(loop, msg) def test_del_with_closed_loop(loop): conn = aiohttp.BaseConnector(loop=loop) transp = unittest.mock.Mock() conn._conns['a'] = [(transp, 'proto', 123)] conns_impl = conn._conns conn._start_cleanup_task() exc_handler = unittest.mock.Mock() loop.set_exception_handler(exc_handler) loop.close() with pytest.warns(ResourceWarning): del conn gc.collect() assert not conns_impl assert not transp.close.called assert exc_handler.called def test_del_empty_conector(loop): conn = aiohttp.BaseConnector(loop=loop) exc_handler = unittest.mock.Mock() loop.set_exception_handler(exc_handler) del conn assert not exc_handler.called @asyncio.coroutine def test_create_conn(loop): conn = aiohttp.BaseConnector(loop=loop) with pytest.raises(NotImplementedError): yield from conn._create_connection(object()) def test_ctor_loop(): with unittest.mock.patch('aiohttp.connector.asyncio') as m_asyncio: session = aiohttp.BaseConnector() assert session._loop is m_asyncio.get_event_loop.return_value def test_close(loop): tr = unittest.mock.Mock() conn = aiohttp.BaseConnector(loop=loop) assert not conn.closed conn._conns[1] = [(tr, object(), object())] conn.close() assert not conn._conns assert tr.close.called assert conn.closed def test_get(loop): conn = aiohttp.BaseConnector(loop=loop) assert conn._get(1) == (None, None) tr, proto = unittest.mock.Mock(), unittest.mock.Mock() conn._conns[1] = [(tr, proto, loop.time())] assert conn._get(1) == (tr, proto) conn.close() def test_get_expired(loop): conn = aiohttp.BaseConnector(loop=loop) assert conn._get(1) == (None, None) tr, proto = unittest.mock.Mock(), unittest.mock.Mock() conn._conns[1] = [(tr, proto, loop.time() - 1000)] assert conn._get(1) == (None, None) assert not conn._conns conn.close() def test_release_acquired(loop): conn = aiohttp.BaseConnector(loop=loop, limit=5) conn._release_waiter = unittest.mock.Mock() key, tr = 1, unittest.mock.Mock() conn._acquired[key].add(tr) acquired = conn._release_acquired(key, tr) assert 0 == len(conn._acquired[key]) assert acquired == conn._acquired[key] assert not conn._release_waiter.called acquired = conn._release_acquired(key, tr) assert 0 == len(conn._acquired[key]) assert acquired is None conn.close() def test_release_acquired_closed(loop): conn = aiohttp.BaseConnector(loop=loop, limit=5) conn._release_waiter = unittest.mock.Mock() key, tr = 1, unittest.mock.Mock() conn._acquired[key].add(tr) conn._closed = True conn._release_acquired(key, tr) assert 1 == len(conn._acquired[key]) assert not conn._release_waiter.called conn.close() def test_release(loop): loop.time = mock.Mock(return_value=10) conn = aiohttp.BaseConnector(loop=loop) conn._start_cleanup_task = unittest.mock.Mock() conn._release_waiter = unittest.mock.Mock() req = unittest.mock.Mock() resp = req.response = unittest.mock.Mock() resp._should_close = False tr, proto = unittest.mock.Mock(), unittest.mock.Mock() key = 1 conn._acquired[key].add(tr) conn._release(key, req, tr, proto) assert conn._release_waiter.called assert conn._conns[1][0] == (tr, proto, 10) assert conn._start_cleanup_task.called conn.close() def test_release_already_closed(loop): conn = aiohttp.BaseConnector(loop=loop) tr, proto = unittest.mock.Mock(), unittest.mock.Mock() key = 1 conn._acquired[key].add(tr) conn.close() conn._start_cleanup_task = unittest.mock.Mock() conn._release_waiter = unittest.mock.Mock() conn._release_acquired = unittest.mock.Mock() req = unittest.mock.Mock() conn._release(key, req, tr, proto) assert not conn._release_waiter.called assert not conn._start_cleanup_task.called assert not conn._release_acquired.called def test_release_do_not_call_release_waiter(loop): req = unittest.mock.Mock() resp = req.response = unittest.mock.Mock() resp._should_close = False tr, proto = unittest.mock.Mock(), unittest.mock.Mock() key = 1 # limit is None conn = aiohttp.BaseConnector(limit=None, loop=loop) conn._release_waiter = unittest.mock.Mock() conn._acquired[key].add(tr) conn._release(key, req, tr, proto) assert not conn._release_waiter.called conn.close() # acquired key error conn = aiohttp.BaseConnector(loop=loop) conn._release_waiter = unittest.mock.Mock() conn._release(key, req, tr, proto) assert not conn._release_waiter.called conn.close() # acquired len >= limit conn = aiohttp.BaseConnector(limit=1, loop=loop) conn._release_waiter = unittest.mock.Mock() conn._acquired[key].add(unittest.mock.Mock()) conn._acquired[key].add(tr) conn._release(key, req, tr, proto) assert not conn._release_waiter.called conn.close() def test_release_close(loop): conn = aiohttp.BaseConnector(loop=loop) req = unittest.mock.Mock() resp = unittest.mock.Mock() resp.message.should_close = True req.response = resp tr, proto = unittest.mock.Mock(), unittest.mock.Mock() key = 1 conn._acquired[key].add(tr) conn._release(key, req, tr, proto) assert not conn._conns assert tr.close.called @asyncio.coroutine def test_tcp_connector_resolve_host_use_dns_cache(loop): conn = aiohttp.TCPConnector(loop=loop, use_dns_cache=True) res = yield from conn._resolve_host('localhost', 8080) assert res for rec in res: if rec['family'] == socket.AF_INET: assert rec['host'] == '127.0.0.1' assert rec['hostname'] == 'localhost' assert rec['port'] == 8080 elif rec['family'] == socket.AF_INET6: assert rec['host'] == '::1' assert rec['hostname'] == 'localhost' assert rec['port'] == 8080 @asyncio.coroutine def test_tcp_connector_resolve_host_twice_use_dns_cache(loop): conn = aiohttp.TCPConnector(loop=loop, use_dns_cache=True) res = yield from conn._resolve_host('localhost', 8080) res2 = yield from conn._resolve_host('localhost', 8080) assert res is res2 def test_get_pop_empty_conns(loop): # see issue #473 conn = aiohttp.BaseConnector(loop=loop) key = ('127.0.0.1', 80, False) conn._conns[key] = [] tr, proto = conn._get(key) assert (None, None) == (tr, proto) assert not conn._conns def test_release_close_do_not_add_to_pool(loop): # see issue #473 conn = aiohttp.BaseConnector(loop=loop) req = unittest.mock.Mock() resp = unittest.mock.Mock() resp.message.should_close = True req.response = resp key = ('127.0.0.1', 80, False) tr, proto = unittest.mock.Mock(), unittest.mock.Mock() conn._acquired[key].add(tr) conn._release(key, req, tr, proto) assert not conn._conns def test_release_close_do_not_delete_existing_connections(loop): key = ('127.0.0.1', 80, False) tr1, proto1 = unittest.mock.Mock(), unittest.mock.Mock() conn = aiohttp.BaseConnector(loop=loop) conn._conns[key] = [(tr1, proto1, 1)] req = unittest.mock.Mock() resp = unittest.mock.Mock() resp.message.should_close = True req.response = resp tr, proto = unittest.mock.Mock(), unittest.mock.Mock() conn._acquired[key].add(tr1) conn._release(key, req, tr, proto) assert conn._conns[key] == [(tr1, proto1, 1)] assert tr.close.called conn.close() def test_release_not_started(loop): loop.time = mock.Mock(return_value=10) conn = aiohttp.BaseConnector(loop=loop) req = unittest.mock.Mock() req.response = None tr, proto = unittest.mock.Mock(), unittest.mock.Mock() key = 1 conn._acquired[key].add(tr) conn._release(key, req, tr, proto) assert conn._conns == {1: [(tr, proto, 10)]} assert not tr.close.called conn.close() def test_release_not_opened(loop): conn = aiohttp.BaseConnector(loop=loop) req = unittest.mock.Mock() req.response = unittest.mock.Mock() req.response.message = None tr, proto = unittest.mock.Mock(), unittest.mock.Mock() key = 1 conn._acquired[key].add(tr) conn._release(key, req, tr, proto) assert tr.close.called @asyncio.coroutine def test_connect(loop): tr, proto = unittest.mock.Mock(), unittest.mock.Mock() proto.is_connected.return_value = True req = ClientRequest('GET', URL('http://host:80'), loop=loop, response_class=unittest.mock.Mock()) conn = aiohttp.BaseConnector(loop=loop) key = ('host', 80, False) conn._conns[key] = [(tr, proto, loop.time())] conn._create_connection = unittest.mock.Mock() conn._create_connection.return_value = helpers.create_future(loop) conn._create_connection.return_value.set_result((tr, proto)) connection = yield from conn.connect(req) assert not conn._create_connection.called assert connection._transport is tr assert connection._protocol is proto assert isinstance(connection, Connection) connection.close() @asyncio.coroutine def test_connect_timeout(loop): conn = aiohttp.BaseConnector(loop=loop) conn._create_connection = unittest.mock.Mock() conn._create_connection.return_value = helpers.create_future(loop) conn._create_connection.return_value.set_exception( asyncio.TimeoutError()) with pytest.raises(aiohttp.ClientTimeoutError): req = unittest.mock.Mock() yield from conn.connect(req) @asyncio.coroutine def test_connect_oserr(loop): conn = aiohttp.BaseConnector(loop=loop) conn._create_connection = unittest.mock.Mock() conn._create_connection.return_value = helpers.create_future(loop) err = OSError(1, 'permission error') conn._create_connection.return_value.set_exception(err) with pytest.raises(aiohttp.ClientOSError) as ctx: req = unittest.mock.Mock() yield from conn.connect(req) assert 1 == ctx.value.errno assert ctx.value.strerror.startswith('Cannot connect to') assert ctx.value.strerror.endswith('[permission error]') def test_start_cleanup_task(): loop = unittest.mock.Mock() loop.time.return_value = 1.5 conn = aiohttp.BaseConnector(loop=loop, keepalive_timeout=10) assert conn._cleanup_handle is None conn._start_cleanup_task() assert conn._cleanup_handle is not None loop.call_at.assert_called_with( 12, conn._cleanup) def test_cleanup(): testset = { 1: [(unittest.mock.Mock(), unittest.mock.Mock(), 10), (unittest.mock.Mock(), unittest.mock.Mock(), 300), (None, unittest.mock.Mock(), 300)], } testset[1][0][1].is_connected.return_value = True testset[1][1][1].is_connected.return_value = False loop = unittest.mock.Mock() loop.time.return_value = 300 conn = aiohttp.BaseConnector(loop=loop) conn._conns = testset existing_handle = conn._cleanup_handle = unittest.mock.Mock() conn._cleanup() assert existing_handle.cancel.called assert conn._conns == {} assert conn._cleanup_handle is None def test_cleanup2(): testset = {1: [(unittest.mock.Mock(), unittest.mock.Mock(), 300)]} testset[1][0][1].is_connected.return_value = True loop = unittest.mock.Mock() loop.time.return_value = 300.1 conn = aiohttp.BaseConnector(loop=loop, keepalive_timeout=10) conn._conns = testset conn._cleanup() assert conn._conns == testset assert conn._cleanup_handle is not None loop.call_at.assert_called_with( 310, conn._cleanup) conn.close() def test_cleanup3(): testset = {1: [(unittest.mock.Mock(), unittest.mock.Mock(), 290.1), (unittest.mock.Mock(), unittest.mock.Mock(), 305.1)]} testset[1][0][1].is_connected.return_value = True loop = unittest.mock.Mock() loop.time.return_value = 308.5 conn = aiohttp.BaseConnector(loop=loop, keepalive_timeout=10) conn._conns = testset conn._cleanup() assert conn._conns == {1: [testset[1][1]]} assert conn._cleanup_handle is not None loop.call_at.assert_called_with( 316, conn._cleanup) conn.close() def test_tcp_connector_ctor(loop): conn = aiohttp.TCPConnector(loop=loop) assert conn.verify_ssl assert conn.fingerprint is None with pytest.warns(DeprecationWarning): assert conn.resolve assert conn.use_dns_cache assert conn.family == 0 with pytest.warns(DeprecationWarning): assert conn.resolved_hosts == {} assert conn.resolved_hosts == {} def test_tcp_connector_ctor_fingerprint_valid(loop): valid = b'\xa2\x06G\xad\xaa\xf5\xd8\\J\x99^by;\x06=' conn = aiohttp.TCPConnector(loop=loop, fingerprint=valid) assert conn.fingerprint == valid def test_tcp_connector_fingerprint_invalid(loop): invalid = b'\x00' with pytest.raises(ValueError): aiohttp.TCPConnector(loop=loop, fingerprint=invalid) def test_tcp_connector_clear_resolved_hosts(loop): conn = aiohttp.TCPConnector(loop=loop) info = object() conn._cached_hosts[('localhost', 123)] = info conn._cached_hosts[('localhost', 124)] = info conn.clear_resolved_hosts('localhost', 123) assert conn.resolved_hosts == {('localhost', 124): info} conn.clear_resolved_hosts('localhost', 123) assert conn.resolved_hosts == {('localhost', 124): info} with pytest.warns(DeprecationWarning): conn.clear_resolved_hosts() assert conn.resolved_hosts == {} def test_tcp_connector_clear_dns_cache(loop): conn = aiohttp.TCPConnector(loop=loop) info = object() conn._cached_hosts[('localhost', 123)] = info conn._cached_hosts[('localhost', 124)] = info conn.clear_dns_cache('localhost', 123) assert conn.cached_hosts == {('localhost', 124): info} conn.clear_dns_cache('localhost', 123) assert conn.cached_hosts == {('localhost', 124): info} conn.clear_dns_cache() assert conn.cached_hosts == {} def test_tcp_connector_clear_dns_cache_bad_args(loop): conn = aiohttp.TCPConnector(loop=loop) with pytest.raises(ValueError): conn.clear_dns_cache('localhost') def test_ambigous_verify_ssl_and_ssl_context(loop): with pytest.raises(ValueError): aiohttp.TCPConnector( verify_ssl=False, ssl_context=ssl.SSLContext(ssl.PROTOCOL_SSLv23), loop=loop) def test_dont_recreate_ssl_context(loop): conn = aiohttp.TCPConnector(loop=loop) ctx = conn.ssl_context assert ctx is conn.ssl_context def test_respect_precreated_ssl_context(loop): ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23) conn = aiohttp.TCPConnector(loop=loop, ssl_context=ctx) assert ctx is conn.ssl_context def test_close_twice(loop): tr = unittest.mock.Mock() conn = aiohttp.BaseConnector(loop=loop) conn._conns[1] = [(tr, object(), object())] conn.close() assert not conn._conns assert tr.close.called assert conn.closed conn._conns = 'Invalid' # fill with garbage conn.close() assert conn.closed def test_close_cancels_cleanup_handle(loop): conn = aiohttp.BaseConnector(loop=loop) conn._start_cleanup_task() assert conn._cleanup_handle is not None conn.close() assert conn._cleanup_handle is None def test_ctor_with_default_loop(): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) conn = aiohttp.BaseConnector() assert loop is conn._loop loop.close() @asyncio.coroutine def test_connect_with_limit(loop): tr, proto = unittest.mock.Mock(), unittest.mock.Mock() proto.is_connected.return_value = True req = ClientRequest('GET', URL('http://host:80'), loop=loop, response_class=unittest.mock.Mock()) conn = aiohttp.BaseConnector(loop=loop, limit=1) key = ('host', 80, False) conn._conns[key] = [(tr, proto, loop.time())] conn._create_connection = unittest.mock.Mock() conn._create_connection.return_value = helpers.create_future(loop) conn._create_connection.return_value.set_result((tr, proto)) connection1 = yield from conn.connect(req) assert connection1._transport == tr assert 1 == len(conn._acquired[key]) acquired = False @asyncio.coroutine def f(): nonlocal acquired connection2 = yield from conn.connect(req) acquired = True assert 1 == len(conn._acquired[key]) connection2.release() task = helpers.ensure_future(f(), loop=loop) yield from asyncio.sleep(0.01, loop=loop) assert not acquired connection1.release() yield from asyncio.sleep(0, loop=loop) assert acquired yield from task conn.close() @asyncio.coroutine def test_connect_with_limit_cancelled(loop): tr, proto = unittest.mock.Mock(), unittest.mock.Mock() proto.is_connected.return_value = True req = ClientRequest('GET', URL('http://host:80'), loop=loop, response_class=unittest.mock.Mock()) conn = aiohttp.BaseConnector(loop=loop, limit=1) key = ('host', 80, False) conn._conns[key] = [(tr, proto, loop.time())] conn._create_connection = unittest.mock.Mock() conn._create_connection.return_value = helpers.create_future(loop) conn._create_connection.return_value.set_result((tr, proto)) connection = yield from conn.connect(req) assert connection._transport == tr assert 1 == len(conn._acquired[key]) with pytest.raises(asyncio.TimeoutError): # limit exhausted yield from asyncio.wait_for(conn.connect(req), 0.01, loop=loop) connection.close() @asyncio.coroutine def test_connect_with_limit_release_waiters(loop): def check_with_exc(err): conn = aiohttp.BaseConnector(limit=1, loop=loop) conn._create_connection = unittest.mock.Mock() conn._create_connection.return_value = \ helpers.create_future(loop) conn._create_connection.return_value.set_exception(err) with pytest.raises(Exception): req = unittest.mock.Mock() yield from conn.connect(req) key = (req.host, req.port, req.ssl) assert not conn._waiters[key] check_with_exc(OSError(1, 'permission error')) check_with_exc(RuntimeError()) check_with_exc(asyncio.TimeoutError()) @asyncio.coroutine def test_connect_with_limit_concurrent(loop): proto = unittest.mock.Mock() proto.is_connected.return_value = True req = ClientRequest('GET', URL('http://host:80'), loop=loop, response_class=unittest.mock.Mock( _should_close=False)) max_connections = 2 num_connections = 0 conn = aiohttp.BaseConnector(limit=max_connections, loop=loop) # Use a real coroutine for _create_connection; a mock would mask # problems that only happen when the method yields. @asyncio.coroutine def create_connection(req): nonlocal num_connections num_connections += 1 yield from asyncio.sleep(0, loop=loop) # Make a new transport mock each time because acquired # transports are stored in a set. Reusing the same object # messes with the count. tr = unittest.mock.Mock() return tr, proto conn._create_connection = create_connection # Simulate something like a crawler. It opens a connection, does # something with it, closes it, then creates tasks that make more # connections and waits for them to finish. The crawler is started # with multiple concurrent requests and stops when it hits a # predefined maximum number of requests. max_requests = 10 num_requests = 0 start_requests = max_connections + 1 @asyncio.coroutine def f(start=True): nonlocal num_requests if num_requests == max_requests: return num_requests += 1 if not start: connection = yield from conn.connect(req) yield from asyncio.sleep(0, loop=loop) connection.release() tasks = [ helpers.ensure_future(f(start=False), loop=loop) for i in range(start_requests) ] yield from asyncio.wait(tasks, loop=loop) yield from f() conn.close() assert max_connections == num_connections @asyncio.coroutine def test_close_with_acquired_connection(loop): tr, proto = unittest.mock.Mock(), unittest.mock.Mock() proto.is_connected.return_value = True req = ClientRequest('GET', URL('http://host:80'), loop=loop, response_class=unittest.mock.Mock()) conn = aiohttp.BaseConnector(loop=loop, limit=1) key = ('host', 80, False) conn._conns[key] = [(tr, proto, loop.time())] conn._create_connection = unittest.mock.Mock() conn._create_connection.return_value = helpers.create_future(loop) conn._create_connection.return_value.set_result((tr, proto)) connection = yield from conn.connect(req) assert 1 == len(conn._acquired) conn.close() assert 0 == len(conn._acquired) assert conn.closed tr.close.assert_called_with() assert not connection.closed connection.close() assert connection.closed def test_default_force_close(loop): connector = aiohttp.BaseConnector(loop=loop) assert not connector.force_close def test_limit_property(loop): conn = aiohttp.BaseConnector(loop=loop, limit=15) assert 15 == conn.limit conn.close() def test_limit_property_default(loop): conn = aiohttp.BaseConnector(loop=loop) assert conn.limit == 20 conn.close() def test_limitless(loop): with aiohttp.BaseConnector(loop=loop, limit=None) as conn: assert conn.limit is None def test_force_close_and_explicit_keep_alive(loop): with pytest.raises(ValueError): aiohttp.BaseConnector(loop=loop, keepalive_timeout=30, force_close=True) conn = aiohttp.BaseConnector(loop=loop, force_close=True, keepalive_timeout=None) assert conn conn = aiohttp.BaseConnector(loop=loop, force_close=True) assert conn @asyncio.coroutine def test_tcp_connector(test_client, loop): @asyncio.coroutine def handler(request): return web.HTTPOk() app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) r = yield from client.get('/') assert r.status == 200 def test_ambiguous_ctor_params(loop): with pytest.raises(ValueError): aiohttp.TCPConnector(resolve=True, use_dns_cache=False, loop=loop) def test_both_resolve_and_use_dns_cache(loop): conn = aiohttp.TCPConnector(resolve=True, use_dns_cache=True, loop=loop) assert conn.use_dns_cache with pytest.warns(DeprecationWarning): assert conn.resolve def test_both_use_dns_cache_only(loop): conn = aiohttp.TCPConnector(use_dns_cache=True, loop=loop) assert conn.use_dns_cache with pytest.warns(DeprecationWarning): assert conn.resolve def test_default_use_dns_cache(loop): conn = aiohttp.TCPConnector(loop=loop) assert conn.use_dns_cache class TestHttpClientConnector(unittest.TestCase): def setUp(self): self.handler = None self.loop = asyncio.new_event_loop() asyncio.set_event_loop(None) def tearDown(self): if self.handler: self.loop.run_until_complete(self.handler.finish_connections()) self.loop.stop() self.loop.run_forever() self.loop.close() gc.collect() @asyncio.coroutine def create_server(self, method, path, handler): app = web.Application(loop=self.loop) app.router.add_route(method, path, handler) port = unused_port() self.handler = app.make_handler(keep_alive_on=False) srv = yield from self.loop.create_server( self.handler, '127.0.0.1', port) url = "http://127.0.0.1:{}".format(port) + path self.addCleanup(srv.close) return app, srv, url @asyncio.coroutine def create_unix_server(self, method, path, handler): tmpdir = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, tmpdir) app = web.Application(loop=self.loop) app.router.add_route(method, path, handler) self.handler = app.make_handler(keep_alive_on=False, access_log=None) sock_path = os.path.join(tmpdir, 'socket.sock') srv = yield from self.loop.create_unix_server( self.handler, sock_path) url = "http://127.0.0.1" + path self.addCleanup(srv.close) return app, srv, url, sock_path def test_tcp_connector_uses_provided_local_addr(self): @asyncio.coroutine def handler(request): return web.HTTPOk() app, srv, url = self.loop.run_until_complete( self.create_server('get', '/', handler) ) port = unused_port() conn = aiohttp.TCPConnector(loop=self.loop, local_addr=('127.0.0.1', port)) r = self.loop.run_until_complete( aiohttp.request( 'get', url, connector=conn )) self.loop.run_until_complete(r.release()) first_conn = next(iter(conn._conns.values()))[0][0] self.assertEqual(first_conn._sock.getsockname(), ('127.0.0.1', port)) r.close() conn.close() @unittest.skipUnless(hasattr(socket, 'AF_UNIX'), 'requires unix') def test_unix_connector(self): @asyncio.coroutine def handler(request): return web.HTTPOk() app, srv, url, sock_path = self.loop.run_until_complete( self.create_unix_server('get', '/', handler)) connector = aiohttp.UnixConnector(sock_path, loop=self.loop) self.assertEqual(sock_path, connector.path) r = self.loop.run_until_complete( client.request( 'get', url, connector=connector, loop=self.loop)) self.assertEqual(r.status, 200) r.close() def test_resolver_not_called_with_address_is_ip(self): resolver = unittest.mock.MagicMock() connector = aiohttp.TCPConnector(resolver=resolver, loop=self.loop) req = ClientRequest('GET', URL('http://127.0.0.1:{}'.format(unused_port())), loop=self.loop, response_class=unittest.mock.Mock()) with self.assertRaises(OSError): self.loop.run_until_complete(connector.connect(req)) resolver.resolve.assert_not_called() aiohttp-1.2.0/tests/test_pytest_plugin.py0000664000175000017500000000700113025134363021505 0ustar travistravis00000000000000pytest_plugins = 'pytester' def test_myplugin(testdir): testdir.makepyfile("""\ import asyncio import pytest from unittest import mock from aiohttp import web pytest_plugins = 'aiohttp.pytest_plugin' @asyncio.coroutine def hello(request): return web.Response(body=b'Hello, world') def create_app(loop): app = web.Application(loop=loop) app.router.add_route('GET', '/', hello) return app @asyncio.coroutine def test_hello(test_client): client = yield from test_client(create_app) resp = yield from client.get('/') assert resp.status == 200 text = yield from resp.text() assert 'Hello, world' in text @asyncio.coroutine def test_hello_from_app(test_client, loop): app = web.Application(loop=loop) app.router.add_get('/', hello) client = yield from test_client(app) resp = yield from client.get('/') assert resp.status == 200 text = yield from resp.text() assert 'Hello, world' in text @asyncio.coroutine def test_hello_with_loop(test_client, loop): client = yield from test_client(create_app) resp = yield from client.get('/') assert resp.status == 200 text = yield from resp.text() assert 'Hello, world' in text @asyncio.coroutine def test_hello_fails(test_client): client = yield from test_client(create_app) resp = yield from client.get('/') assert resp.status == 200 text = yield from resp.text() assert 'Hello, wield' in text @asyncio.coroutine def test_hello_with_fake_loop(test_client): with pytest.raises(AssertionError): fake_loop = mock.Mock() yield from test_client(web.Application(loop=fake_loop)) @asyncio.coroutine def test_set_args(test_client, loop): with pytest.raises(AssertionError): app = web.Application(loop=loop) yield from test_client(app, 1, 2, 3) @asyncio.coroutine def test_set_keyword_args(test_client, loop): app = web.Application(loop=loop) with pytest.raises(TypeError): yield from test_client(app, param=1) @asyncio.coroutine def test_noop(): pass @asyncio.coroutine def previous(request): if request.method == 'POST': request.app['value'] = (yield from request.post())['value'] return web.Response(body=b'thanks for the data') else: v = request.app.get('value', 'unknown') return web.Response(body='value: {}'.format(v).encode()) def create_stateful_app(loop): app = web.Application(loop=loop) app.router.add_route('*', '/', previous) return app @pytest.fixture def cli(loop, test_client): return loop.run_until_complete(test_client(create_stateful_app)) @asyncio.coroutine def test_set_value(cli): resp = yield from cli.post('/', data={'value': 'foo'}) assert resp.status == 200 text = yield from resp.text() assert text == 'thanks for the data' assert cli.server.app['value'] == 'foo' @asyncio.coroutine def test_get_value(cli): resp = yield from cli.get('/') assert resp.status == 200 text = yield from resp.text() assert text == 'value: unknown' cli.server.app['value'] = 'bar' resp = yield from cli.get('/') assert resp.status == 200 text = yield from resp.text() assert text == 'value: bar' def test_noncoro(): assert True @asyncio.coroutine def test_client_failed_to_create(test_client): def make_app(loop): raise RuntimeError() with pytest.raises(RuntimeError): yield from test_client(make_app) """) result = testdir.runpytest('-p', 'no:sugar') result.assert_outcomes(passed=11, failed=1) aiohttp-1.2.0/tests/test_streams.py0000664000175000017500000006471513025134363020274 0ustar travistravis00000000000000"""Tests for streams.py""" import asyncio import unittest from unittest import mock from aiohttp import helpers, streams, test_utils class TestStreamReader(unittest.TestCase): DATA = b'line1\nline2\nline3\n' def setUp(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(None) def tearDown(self): self.loop.close() def _make_one(self, *args, **kwargs): return streams.StreamReader(loop=self.loop, *args, **kwargs) def test_create_waiter(self): stream = self._make_one() stream._waiter = helpers.create_future(self.loop) with self.assertRaises(RuntimeError): self.loop.run_until_complete(stream._wait('test')) @mock.patch('aiohttp.streams.asyncio') def test_ctor_global_loop(self, m_asyncio): stream = streams.StreamReader() self.assertIs(stream._loop, m_asyncio.get_event_loop.return_value) def test_at_eof(self): stream = self._make_one() self.assertFalse(stream.at_eof()) stream.feed_data(b'some data\n') self.assertFalse(stream.at_eof()) self.loop.run_until_complete(stream.readline()) self.assertFalse(stream.at_eof()) stream.feed_data(b'some data\n') stream.feed_eof() self.loop.run_until_complete(stream.readline()) self.assertTrue(stream.at_eof()) def test_wait_eof(self): stream = self._make_one() wait_task = asyncio.Task(stream.wait_eof(), loop=self.loop) def cb(): yield from asyncio.sleep(0.1, loop=self.loop) stream.feed_eof() asyncio.Task(cb(), loop=self.loop) self.loop.run_until_complete(wait_task) self.assertTrue(stream.is_eof()) self.assertIsNone(stream._eof_waiter) def test_wait_eof_eof(self): stream = self._make_one() stream.feed_eof() wait_task = asyncio.Task(stream.wait_eof(), loop=self.loop) self.loop.run_until_complete(wait_task) self.assertTrue(stream.is_eof()) def test_feed_empty_data(self): stream = self._make_one() stream.feed_data(b'') stream.feed_eof() data = self.loop.run_until_complete(stream.read()) self.assertEqual(b'', data) def test_feed_nonempty_data(self): stream = self._make_one() stream.feed_data(self.DATA) stream.feed_eof() data = self.loop.run_until_complete(stream.read()) self.assertEqual(self.DATA, data) def test_read_zero(self): # Read zero bytes. stream = self._make_one() stream.feed_data(self.DATA) data = self.loop.run_until_complete(stream.read(0)) self.assertEqual(b'', data) stream.feed_eof() data = self.loop.run_until_complete(stream.read()) self.assertEqual(self.DATA, data) def test_read(self): # Read bytes. stream = self._make_one() read_task = asyncio.Task(stream.read(30), loop=self.loop) def cb(): stream.feed_data(self.DATA) self.loop.call_soon(cb) data = self.loop.run_until_complete(read_task) self.assertEqual(self.DATA, data) stream.feed_eof() data = self.loop.run_until_complete(stream.read()) self.assertEqual(b'', data) def test_read_line_breaks(self): # Read bytes without line breaks. stream = self._make_one() stream.feed_data(b'line1') stream.feed_data(b'line2') data = self.loop.run_until_complete(stream.read(5)) self.assertEqual(b'line1', data) data = self.loop.run_until_complete(stream.read(5)) self.assertEqual(b'line2', data) def test_read_all(self): # Read all avaliable buffered bytes stream = self._make_one() stream.feed_data(b'line1') stream.feed_data(b'line2') stream.feed_eof() data = self.loop.run_until_complete(stream.read()) self.assertEqual(b'line1line2', data) def test_read_up_to(self): # Read available buffered bytes up to requested amount stream = self._make_one() stream.feed_data(b'line1') stream.feed_data(b'line2') data = self.loop.run_until_complete(stream.read(8)) self.assertEqual(b'line1lin', data) data = self.loop.run_until_complete(stream.read(8)) self.assertEqual(b'e2', data) def test_read_eof(self): # Read bytes, stop at eof. stream = self._make_one() read_task = asyncio.Task(stream.read(1024), loop=self.loop) def cb(): stream.feed_eof() self.loop.call_soon(cb) data = self.loop.run_until_complete(read_task) self.assertEqual(b'', data) data = self.loop.run_until_complete(stream.read()) self.assertEqual(data, b'') @mock.patch('aiohttp.streams.internal_logger') def test_read_eof_infinit(self, internal_logger): # Read bytes. stream = self._make_one() stream.feed_eof() self.loop.run_until_complete(stream.read()) self.loop.run_until_complete(stream.read()) self.loop.run_until_complete(stream.read()) self.loop.run_until_complete(stream.read()) self.loop.run_until_complete(stream.read()) self.loop.run_until_complete(stream.read()) self.assertTrue(internal_logger.warning.called) def test_read_until_eof(self): # Read all bytes until eof. stream = self._make_one() read_task = asyncio.Task(stream.read(-1), loop=self.loop) def cb(): stream.feed_data(b'chunk1\n') stream.feed_data(b'chunk2') stream.feed_eof() self.loop.call_soon(cb) data = self.loop.run_until_complete(read_task) self.assertEqual(b'chunk1\nchunk2', data) data = self.loop.run_until_complete(stream.read()) self.assertEqual(b'', data) def test_read_exception(self): stream = self._make_one() stream.feed_data(b'line\n') data = self.loop.run_until_complete(stream.read(2)) self.assertEqual(b'li', data) stream.set_exception(ValueError()) self.assertRaises( ValueError, self.loop.run_until_complete, stream.read(2)) def test_readline(self): # Read one line. 'readline' will need to wait for the data # to come from 'cb' stream = self._make_one() stream.feed_data(b'chunk1 ') read_task = asyncio.Task(stream.readline(), loop=self.loop) def cb(): stream.feed_data(b'chunk2 ') stream.feed_data(b'chunk3 ') stream.feed_data(b'\n chunk4') self.loop.call_soon(cb) line = self.loop.run_until_complete(read_task) self.assertEqual(b'chunk1 chunk2 chunk3 \n', line) stream.feed_eof() data = self.loop.run_until_complete(stream.read()) self.assertEqual(b' chunk4', data) def test_readline_limit_with_existing_data(self): # Read one line. The data is in StreamReader's buffer # before the event loop is run. stream = self._make_one(limit=3) stream.feed_data(b'li') stream.feed_data(b'ne1\nline2\n') self.assertRaises( ValueError, self.loop.run_until_complete, stream.readline()) # The buffer should contain the remaining data after exception stream.feed_eof() data = self.loop.run_until_complete(stream.read()) self.assertEqual(b'line2\n', data) def test_readline_limit(self): # Read one line. StreamReaders are fed with data after # their 'readline' methods are called. stream = self._make_one(limit=7) def cb(): stream.feed_data(b'chunk1') stream.feed_data(b'chunk2') stream.feed_data(b'chunk3\n') stream.feed_eof() self.loop.call_soon(cb) self.assertRaises( ValueError, self.loop.run_until_complete, stream.readline()) stream = self._make_one(limit=7) def cb(): stream.feed_data(b'chunk1') stream.feed_data(b'chunk2\n') stream.feed_data(b'chunk3\n') stream.feed_eof() self.loop.call_soon(cb) self.assertRaises( ValueError, self.loop.run_until_complete, stream.readline()) data = self.loop.run_until_complete(stream.read()) self.assertEqual(b'chunk3\n', data) def test_readline_nolimit_nowait(self): # All needed data for the first 'readline' call will be # in the buffer. stream = self._make_one() stream.feed_data(self.DATA[:6]) stream.feed_data(self.DATA[6:]) line = self.loop.run_until_complete(stream.readline()) self.assertEqual(b'line1\n', line) stream.feed_eof() data = self.loop.run_until_complete(stream.read()) self.assertEqual(b'line2\nline3\n', data) def test_readline_eof(self): stream = self._make_one() stream.feed_data(b'some data') stream.feed_eof() line = self.loop.run_until_complete(stream.readline()) self.assertEqual(b'some data', line) def test_readline_empty_eof(self): stream = self._make_one() stream.feed_eof() line = self.loop.run_until_complete(stream.readline()) self.assertEqual(b'', line) def test_readline_read_byte_count(self): stream = self._make_one() stream.feed_data(self.DATA) self.loop.run_until_complete(stream.readline()) data = self.loop.run_until_complete(stream.read(7)) self.assertEqual(b'line2\nl', data) stream.feed_eof() data = self.loop.run_until_complete(stream.read()) self.assertEqual(b'ine3\n', data) def test_readline_exception(self): stream = self._make_one() stream.feed_data(b'line\n') data = self.loop.run_until_complete(stream.readline()) self.assertEqual(b'line\n', data) stream.set_exception(ValueError()) self.assertRaises( ValueError, self.loop.run_until_complete, stream.readline()) def test_readexactly_zero_or_less(self): # Read exact number of bytes (zero or less). stream = self._make_one() stream.feed_data(self.DATA) data = self.loop.run_until_complete(stream.readexactly(0)) self.assertEqual(b'', data) stream.feed_eof() data = self.loop.run_until_complete(stream.read()) self.assertEqual(self.DATA, data) stream = self._make_one() stream.feed_data(self.DATA) data = self.loop.run_until_complete(stream.readexactly(-1)) self.assertEqual(b'', data) stream.feed_eof() data = self.loop.run_until_complete(stream.read()) self.assertEqual(self.DATA, data) def test_readexactly(self): # Read exact number of bytes. stream = self._make_one() n = 2 * len(self.DATA) read_task = asyncio.Task(stream.readexactly(n), loop=self.loop) def cb(): stream.feed_data(self.DATA) stream.feed_data(self.DATA) stream.feed_data(self.DATA) self.loop.call_soon(cb) data = self.loop.run_until_complete(read_task) self.assertEqual(self.DATA + self.DATA, data) stream.feed_eof() data = self.loop.run_until_complete(stream.read()) self.assertEqual(self.DATA, data) def test_readexactly_eof(self): # Read exact number of bytes (eof). stream = self._make_one() n = 2 * len(self.DATA) read_task = asyncio.Task(stream.readexactly(n), loop=self.loop) def cb(): stream.feed_data(self.DATA) stream.feed_eof() self.loop.call_soon(cb) with self.assertRaises(asyncio.IncompleteReadError) as cm: self.loop.run_until_complete(read_task) self.assertEqual(cm.exception.partial, self.DATA) self.assertEqual(cm.exception.expected, n) self.assertEqual(str(cm.exception), '18 bytes read on a total of 36 expected bytes') data = self.loop.run_until_complete(stream.read()) self.assertEqual(b'', data) def test_readexactly_exception(self): stream = self._make_one() stream.feed_data(b'line\n') data = self.loop.run_until_complete(stream.readexactly(2)) self.assertEqual(b'li', data) stream.set_exception(ValueError()) self.assertRaises( ValueError, self.loop.run_until_complete, stream.readexactly(2)) def test_unread_data(self): stream = self._make_one() stream.feed_data(b'line1') stream.feed_data(b'line2') stream.feed_data(b'onemoreline') data = self.loop.run_until_complete(stream.read(5)) self.assertEqual(b'line1', data) stream.unread_data(data) data = self.loop.run_until_complete(stream.read(5)) self.assertEqual(b'line1', data) data = self.loop.run_until_complete(stream.read(4)) self.assertEqual(b'line', data) stream.unread_data(b'line1line') data = b'' while len(data) < 10: data += self.loop.run_until_complete(stream.read(10)) self.assertEqual(b'line1line2', data) data = self.loop.run_until_complete(stream.read(7)) self.assertEqual(b'onemore', data) stream.unread_data(data) data = b'' while len(data) < 11: data += self.loop.run_until_complete(stream.read(11)) self.assertEqual(b'onemoreline', data) stream.unread_data(b'line') data = self.loop.run_until_complete(stream.read(4)) self.assertEqual(b'line', data) stream.feed_eof() stream.unread_data(b'at_eof') data = self.loop.run_until_complete(stream.read(6)) self.assertEqual(b'at_eof', data) def test_exception(self): stream = self._make_one() self.assertIsNone(stream.exception()) exc = ValueError() stream.set_exception(exc) self.assertIs(stream.exception(), exc) def test_exception_waiter(self): stream = self._make_one() @asyncio.coroutine def set_err(): stream.set_exception(ValueError()) t1 = asyncio.Task(stream.readline(), loop=self.loop) t2 = asyncio.Task(set_err(), loop=self.loop) self.loop.run_until_complete(asyncio.wait([t1, t2], loop=self.loop)) self.assertRaises(ValueError, t1.result) def test_exception_cancel(self): stream = self._make_one() @asyncio.coroutine def read_a_line(): yield from stream.readline() t = asyncio.Task(read_a_line(), loop=self.loop) test_utils.run_briefly(self.loop) t.cancel() test_utils.run_briefly(self.loop) # The following line fails if set_exception() isn't careful. stream.set_exception(RuntimeError('message')) test_utils.run_briefly(self.loop) self.assertIs(stream._waiter, None) def test_readany_eof(self): stream = self._make_one() read_task = asyncio.Task(stream.readany(), loop=self.loop) self.loop.call_soon(stream.feed_data, b'chunk1\n') data = self.loop.run_until_complete(read_task) self.assertEqual(b'chunk1\n', data) stream.feed_eof() data = self.loop.run_until_complete(stream.read()) self.assertEqual(b'', data) def test_readany_empty_eof(self): stream = self._make_one() stream.feed_eof() read_task = asyncio.Task(stream.readany(), loop=self.loop) data = self.loop.run_until_complete(read_task) self.assertEqual(b'', data) def test_readany_exception(self): stream = self._make_one() stream.feed_data(b'line\n') data = self.loop.run_until_complete(stream.readany()) self.assertEqual(b'line\n', data) stream.set_exception(ValueError()) self.assertRaises( ValueError, self.loop.run_until_complete, stream.readany()) def test_read_nowait(self): stream = self._make_one() stream.feed_data(b'line1\nline2\n') self.assertEqual(stream.read_nowait(), b'line1\nline2\n') self.assertEqual(stream.read_nowait(), b'') stream.feed_eof() data = self.loop.run_until_complete(stream.read()) self.assertEqual(b'', data) def test_read_nowait_n(self): stream = self._make_one() stream.feed_data(b'line1\nline2\n') self.assertEqual( stream.read_nowait(4), b'line') self.assertEqual( stream.read_nowait(), b'1\nline2\n') self.assertEqual(stream.read_nowait(), b'') stream.feed_eof() data = self.loop.run_until_complete(stream.read()) self.assertEqual(b'', data) def test_read_nowait_exception(self): stream = self._make_one() stream.feed_data(b'line\n') stream.set_exception(ValueError()) self.assertRaises(ValueError, stream.read_nowait) def test_read_nowait_waiter(self): stream = self._make_one() stream.feed_data(b'line\n') stream._waiter = helpers.create_future(self.loop) self.assertRaises(RuntimeError, stream.read_nowait) def test___repr__(self): stream = self._make_one() self.assertEqual("", repr(stream)) def test___repr__nondefault_limit(self): stream = self._make_one(limit=123) self.assertEqual("", repr(stream)) def test___repr__eof(self): stream = self._make_one() stream.feed_eof() self.assertEqual("", repr(stream)) def test___repr__data(self): stream = self._make_one() stream.feed_data(b'data') self.assertEqual("", repr(stream)) def test___repr__exception(self): stream = self._make_one() exc = RuntimeError() stream.set_exception(exc) self.assertEqual("", repr(stream)) def test___repr__waiter(self): stream = self._make_one() stream._waiter = helpers.create_future(self.loop) self.assertRegex( repr(stream), ">") stream._waiter.set_result(None) self.loop.run_until_complete(stream._waiter) stream._waiter = None self.assertEqual("", repr(stream)) def test_unread_empty(self): stream = self._make_one() stream.feed_data(b'line1') stream.feed_eof() stream.unread_data(b'') data = self.loop.run_until_complete(stream.read(5)) self.assertEqual(b'line1', data) self.assertTrue(stream.at_eof()) def test_set_exception_cancels_timeout(self): stream = self._make_one(timeout=1) task = helpers.ensure_future(stream.readany(), loop=self.loop) self.loop.run_until_complete(asyncio.sleep(0, loop=self.loop)) self.assertIsNotNone(stream._canceller) canceller = stream._canceller = mock.Mock() stream.set_exception(ValueError()) self.assertIsNone(stream._canceller) canceller.cancel.assert_called_with() self.assertRaises( ValueError, self.loop.run_until_complete, task) def test_feed_eof_cancels_timeout(self): stream = self._make_one(timeout=1) task = helpers.ensure_future(stream.readany(), loop=self.loop) self.loop.run_until_complete(asyncio.sleep(0, loop=self.loop)) self.assertIsNotNone(stream._canceller) canceller = stream._canceller = mock.Mock() stream.feed_eof() self.assertIsNone(stream._canceller) canceller.cancel.assert_called_with() self.assertEqual(b'', self.loop.run_until_complete(task)) def test_feed_data_cancels_timeout(self): stream = self._make_one(timeout=1) task = helpers.ensure_future(stream.readany(), loop=self.loop) self.loop.run_until_complete(asyncio.sleep(0, loop=self.loop)) self.assertIsNotNone(stream._canceller) canceller = stream._canceller = mock.Mock() stream.feed_data(b'data') self.assertIsNone(stream._canceller) canceller.cancel.assert_called_with() self.assertEqual(b'data', self.loop.run_until_complete(task)) def test_wait_cancels_timeout(self): # Read bytes. stream = self._make_one(timeout=1) task = helpers.ensure_future(stream._wait('test'), loop=self.loop) self.loop.run_until_complete(asyncio.sleep(0, loop=self.loop)) self.assertIsNotNone(stream._canceller) canceller = stream._canceller = mock.Mock() stream._waiter.set_result(None) self.loop.run_until_complete(task) self.assertIsNone(stream._canceller) canceller.cancel.assert_called_with() class TestEmptyStreamReader(unittest.TestCase): def setUp(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(None) def tearDown(self): self.loop.close() def test_empty_stream_reader(self): s = streams.EmptyStreamReader() self.assertIsNone(s.set_exception(ValueError())) self.assertIsNone(s.exception()) self.assertIsNone(s.feed_eof()) self.assertIsNone(s.feed_data(b'data')) self.assertTrue(s.at_eof()) self.assertIsNone( self.loop.run_until_complete(s.wait_eof())) self.assertEqual( self.loop.run_until_complete(s.read()), b'') self.assertEqual( self.loop.run_until_complete(s.readline()), b'') self.assertEqual( self.loop.run_until_complete(s.readany()), b'') self.assertRaises( asyncio.IncompleteReadError, self.loop.run_until_complete, s.readexactly(10)) self.assertEqual(s.read_nowait(), b'') class DataQueueMixin: def test_is_eof(self): self.assertFalse(self.buffer.is_eof()) self.buffer.feed_eof() self.assertTrue(self.buffer.is_eof()) def test_at_eof(self): self.assertFalse(self.buffer.at_eof()) self.buffer.feed_eof() self.assertTrue(self.buffer.at_eof()) self.buffer._buffer.append(object()) self.assertFalse(self.buffer.at_eof()) def test_feed_data(self): item = object() self.buffer.feed_data(item, 1) self.assertEqual([(item, 1)], list(self.buffer._buffer)) def test_feed_eof(self): self.buffer.feed_eof() self.assertTrue(self.buffer._eof) def test_read(self): item = object() read_task = asyncio.Task(self.buffer.read(), loop=self.loop) def cb(): self.buffer.feed_data(item, 1) self.loop.call_soon(cb) data = self.loop.run_until_complete(read_task) self.assertIs(item, data) def test_read_eof(self): read_task = asyncio.Task(self.buffer.read(), loop=self.loop) def cb(): self.buffer.feed_eof() self.loop.call_soon(cb) self.assertRaises( streams.EofStream, self.loop.run_until_complete, read_task) def test_read_cancelled(self): read_task = asyncio.Task(self.buffer.read(), loop=self.loop) test_utils.run_briefly(self.loop) waiter = self.buffer._waiter self.assertIsInstance(waiter, asyncio.Future) read_task.cancel() self.assertRaises( asyncio.CancelledError, self.loop.run_until_complete, read_task) self.assertTrue(waiter.cancelled()) self.assertIsNone(self.buffer._waiter) self.buffer.feed_data(b'test', 4) self.assertIsNone(self.buffer._waiter) def test_read_until_eof(self): item = object() self.buffer.feed_data(item, 1) self.buffer.feed_eof() data = self.loop.run_until_complete(self.buffer.read()) self.assertIs(data, item) self.assertRaises( streams.EofStream, self.loop.run_until_complete, self.buffer.read()) def test_read_exception(self): self.buffer.set_exception(ValueError()) self.assertRaises( ValueError, self.loop.run_until_complete, self.buffer.read()) def test_read_exception_with_data(self): val = object() self.buffer.feed_data(val, 1) self.buffer.set_exception(ValueError()) self.assertIs(val, self.loop.run_until_complete(self.buffer.read())) self.assertRaises( ValueError, self.loop.run_until_complete, self.buffer.read()) def test_read_exception_on_wait(self): read_task = asyncio.Task(self.buffer.read(), loop=self.loop) test_utils.run_briefly(self.loop) self.assertIsInstance(self.buffer._waiter, asyncio.Future) self.buffer.feed_eof() self.buffer.set_exception(ValueError()) self.assertRaises( ValueError, self.loop.run_until_complete, read_task) def test_exception(self): self.assertIsNone(self.buffer.exception()) exc = ValueError() self.buffer.set_exception(exc) self.assertIs(self.buffer.exception(), exc) def test_exception_waiter(self): @asyncio.coroutine def set_err(): self.buffer.set_exception(ValueError()) t1 = asyncio.Task(self.buffer.read(), loop=self.loop) t2 = asyncio.Task(set_err(), loop=self.loop) self.loop.run_until_complete(asyncio.wait([t1, t2], loop=self.loop)) self.assertRaises(ValueError, t1.result) class TestDataQueue(unittest.TestCase, DataQueueMixin): def setUp(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(None) self.buffer = streams.DataQueue(loop=self.loop) def tearDown(self): self.loop.close() class TestChunksQueue(unittest.TestCase, DataQueueMixin): def setUp(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(None) self.buffer = streams.ChunksQueue(loop=self.loop) def tearDown(self): self.loop.close() def test_read_eof(self): read_task = asyncio.Task(self.buffer.read(), loop=self.loop) def cb(): self.buffer.feed_eof() self.loop.call_soon(cb) self.loop.run_until_complete(read_task) self.assertTrue(self.buffer.at_eof()) def test_read_until_eof(self): item = object() self.buffer.feed_data(item, 1) self.buffer.feed_eof() data = self.loop.run_until_complete(self.buffer.read()) self.assertIs(data, item) thing = self.loop.run_until_complete(self.buffer.read()) self.assertEqual(thing, b'') self.assertTrue(self.buffer.at_eof()) def test_readany(self): self.assertIs(self.buffer.read.__func__, self.buffer.readany.__func__) aiohttp-1.2.0/tests/test_stream_writer.py0000664000175000017500000001735713025134363021505 0ustar travistravis00000000000000import socket from unittest import mock import pytest from aiohttp.parsers import CORK, StreamWriter has_ipv6 = socket.has_ipv6 if has_ipv6: # The socket.has_ipv6 flag may be True if Python was built with IPv6 # support, but the target system still may not have it. # So let's ensure that we really have IPv6 support. try: socket.socket(socket.AF_INET6, socket.SOCK_STREAM) except OSError: has_ipv6 = False # nodelay def test_nodelay_default(loop): transport = mock.Mock() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) transport.get_extra_info.return_value = s proto = mock.Mock() reader = mock.Mock() writer = StreamWriter(transport, proto, reader, loop) assert not writer.tcp_nodelay assert not s.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY) def test_set_nodelay_no_change(loop): transport = mock.Mock() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) transport.get_extra_info.return_value = s proto = mock.Mock() reader = mock.Mock() writer = StreamWriter(transport, proto, reader, loop) writer.set_tcp_nodelay(False) assert not writer.tcp_nodelay assert not s.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY) def test_set_nodelay_enable(loop): transport = mock.Mock() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) transport.get_extra_info.return_value = s proto = mock.Mock() reader = mock.Mock() writer = StreamWriter(transport, proto, reader, loop) writer.set_tcp_nodelay(True) assert writer.tcp_nodelay assert s.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY) def test_set_nodelay_enable_and_disable(loop): transport = mock.Mock() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) transport.get_extra_info.return_value = s proto = mock.Mock() reader = mock.Mock() writer = StreamWriter(transport, proto, reader, loop) writer.set_tcp_nodelay(True) writer.set_tcp_nodelay(False) assert not writer.tcp_nodelay assert not s.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY) @pytest.mark.skipif(not has_ipv6, reason="IPv6 is not available") def test_set_nodelay_enable_ipv6(loop): transport = mock.Mock() s = socket.socket(socket.AF_INET6, socket.SOCK_STREAM) transport.get_extra_info.return_value = s proto = mock.Mock() reader = mock.Mock() writer = StreamWriter(transport, proto, reader, loop) writer.set_tcp_nodelay(True) assert writer.tcp_nodelay assert s.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY) @pytest.mark.skipif(not hasattr(socket, 'AF_UNIX'), reason="requires unix sockets") def test_set_nodelay_enable_unix(loop): transport = mock.Mock() s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) transport.get_extra_info.return_value = s proto = mock.Mock() reader = mock.Mock() writer = StreamWriter(transport, proto, reader, loop) writer.set_tcp_nodelay(True) assert writer.tcp_nodelay def test_set_nodelay_enable_no_socket(loop): transport = mock.Mock() transport.get_extra_info.return_value = None proto = mock.Mock() reader = mock.Mock() writer = StreamWriter(transport, proto, reader, loop) writer.set_tcp_nodelay(True) assert writer.tcp_nodelay assert writer._socket is None # cork @pytest.mark.skipif(CORK is None, reason="TCP_CORK or TCP_NOPUSH required") def test_cork_default(loop): transport = mock.Mock() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) transport.get_extra_info.return_value = s proto = mock.Mock() reader = mock.Mock() writer = StreamWriter(transport, proto, reader, loop) assert not writer.tcp_cork assert not s.getsockopt(socket.IPPROTO_TCP, CORK) @pytest.mark.skipif(CORK is None, reason="TCP_CORK or TCP_NOPUSH required") def test_set_cork_no_change(loop): transport = mock.Mock() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) transport.get_extra_info.return_value = s proto = mock.Mock() reader = mock.Mock() writer = StreamWriter(transport, proto, reader, loop) writer.set_tcp_cork(False) assert not writer.tcp_cork assert not s.getsockopt(socket.IPPROTO_TCP, CORK) @pytest.mark.skipif(CORK is None, reason="TCP_CORK or TCP_NOPUSH required") def test_set_cork_enable(loop): transport = mock.Mock() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) transport.get_extra_info.return_value = s proto = mock.Mock() reader = mock.Mock() writer = StreamWriter(transport, proto, reader, loop) writer.set_tcp_cork(True) assert writer.tcp_cork assert s.getsockopt(socket.IPPROTO_TCP, CORK) @pytest.mark.skipif(CORK is None, reason="TCP_CORK or TCP_NOPUSH required") def test_set_cork_enable_and_disable(loop): transport = mock.Mock() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) transport.get_extra_info.return_value = s proto = mock.Mock() reader = mock.Mock() writer = StreamWriter(transport, proto, reader, loop) writer.set_tcp_cork(True) writer.set_tcp_cork(False) assert not writer.tcp_cork assert not s.getsockopt(socket.IPPROTO_TCP, CORK) @pytest.mark.skipif(not has_ipv6, reason="IPv6 is not available") @pytest.mark.skipif(CORK is None, reason="TCP_CORK or TCP_NOPUSH required") def test_set_cork_enable_ipv6(loop): transport = mock.Mock() s = socket.socket(socket.AF_INET6, socket.SOCK_STREAM) transport.get_extra_info.return_value = s proto = mock.Mock() reader = mock.Mock() writer = StreamWriter(transport, proto, reader, loop) writer.set_tcp_cork(True) assert writer.tcp_cork assert s.getsockopt(socket.IPPROTO_TCP, CORK) @pytest.mark.skipif(not hasattr(socket, 'AF_UNIX'), reason="requires unix sockets") @pytest.mark.skipif(CORK is None, reason="TCP_CORK or TCP_NOPUSH required") def test_set_cork_enable_unix(loop): transport = mock.Mock() s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) transport.get_extra_info.return_value = s proto = mock.Mock() reader = mock.Mock() writer = StreamWriter(transport, proto, reader, loop) writer.set_tcp_cork(True) assert writer.tcp_cork @pytest.mark.skipif(CORK is None, reason="TCP_CORK or TCP_NOPUSH required") def test_set_cork_enable_no_socket(loop): transport = mock.Mock() transport.get_extra_info.return_value = None proto = mock.Mock() reader = mock.Mock() writer = StreamWriter(transport, proto, reader, loop) writer.set_tcp_cork(True) assert writer.tcp_cork assert writer._socket is None # cork and nodelay interference @pytest.mark.skipif(CORK is None, reason="TCP_CORK or TCP_NOPUSH required") def test_set_enabling_cork_disables_nodelay(loop): transport = mock.Mock() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) transport.get_extra_info.return_value = s proto = mock.Mock() reader = mock.Mock() writer = StreamWriter(transport, proto, reader, loop) writer.set_tcp_nodelay(True) writer.set_tcp_cork(True) assert not writer.tcp_nodelay assert not s.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY) assert writer.tcp_cork assert s.getsockopt(socket.IPPROTO_TCP, CORK) @pytest.mark.skipif(CORK is None, reason="TCP_CORK or TCP_NOPUSH required") def test_set_enabling_nodelay_disables_cork(loop): transport = mock.Mock() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) transport.get_extra_info.return_value = s proto = mock.Mock() reader = mock.Mock() writer = StreamWriter(transport, proto, reader, loop) writer.set_tcp_cork(True) writer.set_tcp_nodelay(True) assert writer.tcp_nodelay assert s.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY) assert not writer.tcp_cork assert not s.getsockopt(socket.IPPROTO_TCP, CORK) aiohttp-1.2.0/tests/test_test_utils.py0000664000175000017500000002013713025134363021003 0ustar travistravis00000000000000import asyncio from unittest import mock import pytest from multidict import CIMultiDict, CIMultiDictProxy from yarl import URL import aiohttp from aiohttp import web, web_reqrep from aiohttp.test_utils import TestClient as _TestClient from aiohttp.test_utils import TestServer as _TestServer from aiohttp.test_utils import (AioHTTPTestCase, RawTestServer, loop_context, make_mocked_request, setup_test_loop, teardown_test_loop, unittest_run_loop) def _create_example_app(loop): @asyncio.coroutine def hello(request): return web.Response(body=b"Hello, world") @asyncio.coroutine def websocket_handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) msg = yield from ws.receive() if msg.type == aiohttp.WSMsgType.TEXT: if msg.data == 'close': yield from ws.close() else: ws.send_str(msg.data + '/answer') return ws @asyncio.coroutine def cookie_handler(request): resp = web.Response(body=b"Hello, world") resp.set_cookie('cookie', 'val') return resp app = web.Application(loop=loop) app.router.add_route('*', '/', hello) app.router.add_route('*', '/websocket', websocket_handler) app.router.add_route('*', '/cookie', cookie_handler) return app def test_full_server_scenario(): with loop_context() as loop: app = _create_example_app(loop) with _TestClient(app) as client: @asyncio.coroutine def test_get_route(): nonlocal client resp = yield from client.request("GET", "/") assert resp.status == 200 text = yield from resp.text() assert "Hello, world" in text loop.run_until_complete(test_get_route()) def test_server_with_create_test_teardown(): with loop_context() as loop: app = _create_example_app(loop) with _TestClient(app) as client: @asyncio.coroutine def test_get_route(): resp = yield from client.request("GET", "/") assert resp.status == 200 text = yield from resp.text() assert "Hello, world" in text loop.run_until_complete(test_get_route()) def test_test_client_close_is_idempotent(): """ a test client, called multiple times, should not attempt to close the server again. """ loop = setup_test_loop() app = _create_example_app(loop) client = _TestClient(app) loop.run_until_complete(client.close()) loop.run_until_complete(client.close()) teardown_test_loop(loop) class TestAioHTTPTestCase(AioHTTPTestCase): def get_app(self, loop): return _create_example_app(loop) @unittest_run_loop @asyncio.coroutine def test_example_with_loop(self): request = yield from self.client.request("GET", "/") assert request.status == 200 text = yield from request.text() assert "Hello, world" in text def test_example(self): @asyncio.coroutine def test_get_route(): resp = yield from self.client.request("GET", "/") assert resp.status == 200 text = yield from resp.text() assert "Hello, world" in text self.loop.run_until_complete(test_get_route()) # these exist to test the pytest scenario @pytest.yield_fixture def loop(): with loop_context() as loop: yield loop @pytest.fixture def app(loop): return _create_example_app(loop) @pytest.yield_fixture def test_client(loop, app): client = _TestClient(app) loop.run_until_complete(client.start_server()) yield client loop.run_until_complete(client.close()) def test_get_route(loop, test_client): @asyncio.coroutine def test_get_route(): resp = yield from test_client.request("GET", "/") assert resp.status == 200 text = yield from resp.text() assert "Hello, world" in text loop.run_until_complete(test_get_route()) @asyncio.coroutine def test_client_websocket(loop, test_client): resp = yield from test_client.ws_connect("/websocket") resp.send_str("foo") msg = yield from resp.receive() assert msg.type == aiohttp.WSMsgType.TEXT assert "foo" in msg.data resp.send_str("close") msg = yield from resp.receive() assert msg.type == aiohttp.WSMsgType.CLOSE @asyncio.coroutine def test_client_cookie(loop, test_client): assert not test_client.session.cookie_jar yield from test_client.get("/cookie") cookies = list(test_client.session.cookie_jar) assert cookies[0].key == 'cookie' assert cookies[0].value == 'val' @asyncio.coroutine @pytest.mark.parametrize("method", [ "get", "post", "options", "post", "put", "patch", "delete" ]) @asyncio.coroutine def test_test_client_methods(method, loop, test_client): resp = yield from getattr(test_client, method)("/") assert resp.status == 200 text = yield from resp.text() assert "Hello, world" in text @asyncio.coroutine def test_test_client_head(loop, test_client): resp = yield from test_client.head("/") assert resp.status == 200 @pytest.mark.parametrize( "headers", [{'token': 'x'}, CIMultiDict({'token': 'x'}), {}]) def test_make_mocked_request(headers): req = make_mocked_request('GET', '/', headers=headers) assert req.method == "GET" assert req.path == "/" assert isinstance(req, web_reqrep.Request) assert isinstance(req.headers, CIMultiDictProxy) def test_make_mocked_request_sslcontext(): req = make_mocked_request('GET', '/') assert req.transport.get_extra_info('sslcontext') is None def test_make_mocked_request_unknown_extra_info(): req = make_mocked_request('GET', '/') assert req.transport.get_extra_info('unknown_extra_info') is None def test_make_mocked_request_app(): app = mock.Mock() req = make_mocked_request('GET', '/', app=app) assert req.app is app def test_make_mocked_request_content(): payload = mock.Mock() req = make_mocked_request('GET', '/', payload=payload) assert req.content is payload def test_make_mocked_request_transport(): transport = mock.Mock() req = make_mocked_request('GET', '/', transport=transport) assert req.transport is transport def test_test_client_props(loop): app = _create_example_app(loop) client = _TestClient(app, host='localhost') assert client.host == 'localhost' assert client.port is None with client: assert isinstance(client.port, int) assert client.server is not None assert client.port is None def test_test_server_context_manager(loop): app = _create_example_app(loop) with _TestServer(app) as server: @asyncio.coroutine def go(): client = aiohttp.ClientSession(loop=loop) resp = yield from client.head(server.make_url('/')) assert resp.status == 200 resp.close() yield from client.close() loop.run_until_complete(go()) def test_client_scheme_mutually_exclusive_with_server(loop): app = _create_example_app(loop) server = _TestServer(app) with pytest.raises(ValueError): _TestClient(server, scheme='http') def test_client_host_mutually_exclusive_with_server(loop): app = _create_example_app(loop) server = _TestServer(app) with pytest.raises(ValueError): _TestClient(server, host='127.0.0.1') def test_client_unsupported_arg(): with pytest.raises(TypeError): _TestClient('string') def test_server_make_url_yarl_compatibility(loop): app = _create_example_app(loop) with _TestServer(app) as server: make_url = server.make_url assert make_url(URL('/foo')) == make_url('/foo') with pytest.raises(AssertionError): make_url('http://foo.com') with pytest.raises(AssertionError): make_url(URL('http://foo.com')) def test_raw_server_implicit_loop(loop): @asyncio.coroutine def handler(request): pass asyncio.set_event_loop(loop) srv = RawTestServer(handler) assert srv._loop is loop aiohttp-1.2.0/tests/test_flowcontrol_streams.py0000664000175000017500000002300013025134363022702 0ustar travistravis00000000000000import asyncio import unittest from unittest import mock from aiohttp import streams class TestFlowControlStreamReader(unittest.TestCase): def setUp(self): self.stream = mock.Mock(paused=False) self.transp = self.stream.transport self.loop = asyncio.new_event_loop() asyncio.set_event_loop(None) def tearDown(self): self.loop.close() def _make_one(self, *args, **kwargs): return streams.FlowControlStreamReader( self.stream, limit=1, loop=self.loop, *args, **kwargs) def test_read(self): r = self._make_one() r._stream.paused = True r.feed_data(b'da', 2) res = self.loop.run_until_complete(r.read(1)) self.assertEqual(res, b'd') self.assertTrue(self.transp.resume_reading.called) def test_readline(self): r = self._make_one() r._stream.paused = True r.feed_data(b'data\n', 5) res = self.loop.run_until_complete(r.readline()) self.assertEqual(res, b'data\n') self.assertTrue(self.transp.resume_reading.called) def test_readany(self): r = self._make_one() r._stream.paused = True r.feed_data(b'data', 4) res = self.loop.run_until_complete(r.readany()) self.assertEqual(res, b'data') self.assertTrue(self.transp.resume_reading.called) def test_readexactly(self): r = self._make_one() r._stream.paused = True r.feed_data(b'data', 4) res = self.loop.run_until_complete(r.readexactly(3)) self.assertEqual(res, b'dat') self.assertTrue(self.transp.resume_reading.called) def test_feed_data(self): r = self._make_one() r._stream.paused = False r.feed_data(b'datadata', 8) self.assertTrue(self.transp.pause_reading.called) def test_read_nowait(self): r = self._make_one() r._stream.paused = False r.feed_data(b'data1', 5) r.feed_data(b'data2', 5) r.feed_data(b'data3', 5) self.assertTrue(self.stream.paused) res = self.loop.run_until_complete(r.read(5)) self.assertTrue(res == b'data1') # _buffer_size > _buffer_limit self.assertTrue(self.transp.pause_reading.call_count == 1) self.assertTrue(self.transp.resume_reading.call_count == 0) self.assertTrue(self.stream.paused) r._stream.paused = False res = r.read_nowait(5) self.assertTrue(res == b'data2') # _buffer_size > _buffer_limit self.assertTrue(self.transp.pause_reading.call_count == 2) self.assertTrue(self.transp.resume_reading.call_count == 0) self.assertTrue(self.stream.paused) res = r.read_nowait(5) self.assertTrue(res == b'data3') # _buffer_size < _buffer_limit self.assertTrue(self.transp.pause_reading.call_count == 2) self.assertTrue(self.transp.resume_reading.call_count == 1) self.assertTrue(not self.stream.paused) res = r.read_nowait(5) self.assertTrue(res == b'') # _buffer_size < _buffer_limit self.assertTrue(self.transp.pause_reading.call_count == 2) self.assertTrue(self.transp.resume_reading.call_count == 1) self.assertTrue(not self.stream.paused) def test_rudimentary_transport(self): self.transp.resume_reading.side_effect = NotImplementedError() self.transp.pause_reading.side_effect = NotImplementedError() self.stream.paused = True r = self._make_one() self.assertTrue(self.transp.pause_reading.call_count == 0) self.assertTrue(self.transp.resume_reading.call_count == 1) self.assertTrue(self.stream.paused) r.feed_data(b'data', 4) res = self.loop.run_until_complete(r.read(4)) self.assertTrue(self.transp.pause_reading.call_count == 0) self.assertTrue(self.transp.resume_reading.call_count == 2) self.assertTrue(self.stream.paused) self.assertTrue(res == b'data') self.stream.paused = False r.feed_data(b'data', 4) res = self.loop.run_until_complete(r.read(1)) self.assertTrue(self.transp.pause_reading.call_count == 2) self.assertTrue(self.transp.resume_reading.call_count == 2) self.assertTrue(not self.stream.paused) self.assertTrue(res == b'd') class FlowControlMixin: def test_resume_on_init(self): stream = mock.Mock() stream.paused = True streams.FlowControlDataQueue(stream, limit=1, loop=self.loop) self.assertTrue(stream.transport.resume_reading.called) self.assertFalse(stream.paused) def test_no_transport_in_init(self): stream = mock.Mock() stream.paused = True stream.transport = None streams.FlowControlDataQueue(stream, limit=1, loop=self.loop) self.assertTrue(stream.paused) def test_feed_no_waiter(self): out = self._make_one() out.feed_data(object(), 100) self.assertTrue(self.stream.transport.pause_reading.called) def test_feed_no_transport(self): self.stream.transport = None out = self._make_one() self.stream.paused = False out.feed_data(object(), 100) self.assertFalse(self.stream.paused) def test_feed_with_waiter(self): self.stream.paused = False out = self._make_one() read_task = asyncio.Task(out.read(), loop=self.loop) def cb(): out.feed_data(object(), 100) self.loop.call_soon(cb) self.loop.run_until_complete(read_task) self.assertFalse(self.stream.transport.pause_reading.called) self.assertFalse(self.stream.paused) def test_resume_on_read(self): out = self._make_one() out.feed_data(object(), 100) self.assertTrue(self.stream.paused) self.loop.run_until_complete(out.read()) self.assertTrue(self.stream.transport.resume_reading.called) self.assertFalse(self.stream.paused) def test_resume_on_read_no_transport(self): item = object() out = self._make_one() out.feed_data(item, 100) self.assertTrue(self.stream.paused) self.stream.transport = None res = self.loop.run_until_complete(out.read()) self.assertIs(res, item) self.assertTrue(self.stream.paused) def test_no_resume_on_read(self): out = self._make_one() out.feed_data(object(), 100) out.feed_data(object(), 100) out.feed_data(object(), 100) self.assertTrue(self.stream.paused) self.stream.transport.reset_mock() self.loop.run_until_complete(out.read()) self.assertFalse(self.stream.transport.resume_reading.called) self.assertTrue(self.stream.paused) def test_pause_on_read(self): out = self._make_one() out._buffer.append((object(), 100)) out._buffer.append((object(), 100)) out._buffer.append((object(), 100)) out._size = 300 self.stream.paused = False self.loop.run_until_complete(out.read()) self.assertTrue(self.stream.transport.pause_reading.called) self.assertTrue(self.stream.paused) def test_no_pause_on_read(self): item = object() out = self._make_one() out._buffer.append((item, 100)) out._size = 100 self.stream.paused = False res = self.loop.run_until_complete(out.read()) self.assertIs(res, item) self.assertFalse(self.stream.transport.pause_reading.called) self.assertFalse(self.stream.paused) def test_no_pause_on_read_no_transport(self): item = object() out = self._make_one() out._buffer.append((item, 100)) out._buffer.append((object(), 100)) out._buffer.append((object(), 100)) out._size = 300 self.stream.paused = False self.stream.transport = None res = self.loop.run_until_complete(out.read()) self.assertIs(res, item) self.assertFalse(self.stream.paused) class TestFlowControlDataQueue(unittest.TestCase, FlowControlMixin): def setUp(self): self.stream = mock.Mock() self.loop = asyncio.new_event_loop() asyncio.set_event_loop(None) def tearDown(self): self.loop.close() def _make_one(self, *args, **kwargs): return streams.FlowControlDataQueue( self.stream, limit=1, loop=self.loop, *args, **kwargs) class TestFlowControlChunksQueue(unittest.TestCase, FlowControlMixin): def setUp(self): self.stream = mock.Mock() self.loop = asyncio.new_event_loop() asyncio.set_event_loop(None) def tearDown(self): self.loop.close() def _make_one(self, *args, **kwargs): return streams.FlowControlChunksQueue( self.stream, limit=1, loop=self.loop, *args, **kwargs) def test_read_eof(self): out = self._make_one() read_task = asyncio.Task(out.read(), loop=self.loop) def cb(): out.feed_eof() self.loop.call_soon(cb) self.loop.run_until_complete(read_task) self.assertTrue(out.at_eof()) def test_read_until_eof(self): item = object() out = self._make_one() out.feed_data(item, 1) out.feed_eof() data = self.loop.run_until_complete(out.read()) self.assertIs(data, item) thing = self.loop.run_until_complete(out.read()) self.assertEqual(thing, b'') self.assertTrue(out.at_eof()) def test_readany(self): out = self._make_one() self.assertIs(out.read.__func__, out.readany.__func__) aiohttp-1.2.0/tests/data.unknown_mime_type0000664000175000017500000000001513025134363021566 0ustar travistravis00000000000000file content aiohttp-1.2.0/tests/test_errors.py0000664000175000017500000000070613025134363020120 0ustar travistravis00000000000000"""Tests for errors.py""" import aiohttp def test_bad_status_line1(): err = aiohttp.BadStatusLine(b'') assert str(err) == "b''" def test_bad_status_line2(): err = aiohttp.BadStatusLine('Test') assert str(err) == 'Test' def test_fingerprint_mismatch(): err = aiohttp.FingerprintMismatch('exp', 'got', 'host', 8888) expected = '' assert expected == repr(err) aiohttp-1.2.0/tests/test_proxy_functional.py0000664000175000017500000003535713025134363022221 0ustar travistravis00000000000000import asyncio from functools import partial from unittest import mock import pytest from yarl import URL import aiohttp import aiohttp.helpers import aiohttp.web @pytest.fixture def proxy_test_server(raw_test_server, loop, monkeypatch): """Handle all proxy requests and imitate remote server response.""" _patch_ssl_transport(monkeypatch) default_response = dict( status=200, headers=None, body=None) @asyncio.coroutine def proxy_handler(request, proxy_mock): proxy_mock.request = request proxy_mock.requests_list.append(request) response = default_response.copy() if isinstance(proxy_mock.return_value, dict): response.update(proxy_mock.return_value) if request.method == 'CONNECT': response['body'] = None return aiohttp.web.Response(**response) @asyncio.coroutine def proxy_server(): proxy_mock = mock.Mock() proxy_mock.request = None proxy_mock.requests_list = [] handler = partial(proxy_handler, proxy_mock=proxy_mock) server = yield from raw_test_server(handler) proxy_mock.server = server proxy_mock.url = server.make_url('/') return proxy_mock return proxy_server @asyncio.coroutine def _request(method, url, loop=None, **kwargs): with aiohttp.ClientSession(loop=loop) as client: resp = yield from client.request(method, url, **kwargs) yield from resp.release() return resp @pytest.fixture() def get_request(loop): return partial(_request, method='GET', loop=loop) @asyncio.coroutine def test_proxy_http_absolute_path(proxy_test_server, get_request): url = 'http://aiohttp.io/path?query=yes' proxy = yield from proxy_test_server() yield from get_request(url=url, proxy=proxy.url) assert len(proxy.requests_list) == 1 assert proxy.request.method == 'GET' assert proxy.request.host == 'aiohttp.io' assert proxy.request.path_qs == 'http://aiohttp.io/path?query=yes' @asyncio.coroutine def test_proxy_http_raw_path(proxy_test_server, get_request): url = 'http://aiohttp.io:2561/space sheep?q=can:fly' raw_url = 'http://aiohttp.io:2561/space%20sheep?q=can:fly' proxy = yield from proxy_test_server() yield from get_request(url=url, proxy=proxy.url) assert proxy.request.host == 'aiohttp.io:2561' assert proxy.request.path_qs == raw_url @asyncio.coroutine def test_proxy_http_idna_support(proxy_test_server, get_request): url = 'http://éé.com/' raw_url = 'http://xn--9caa.com/' proxy = yield from proxy_test_server() yield from get_request(url=url, proxy=proxy.url) assert proxy.request.host == 'xn--9caa.com' assert proxy.request.path_qs == raw_url @asyncio.coroutine def test_proxy_http_connection_error(get_request): url = 'http://aiohttp.io/path' proxy_url = 'http://localhost:2242/' with pytest.raises(aiohttp.ProxyConnectionError): yield from get_request(url=url, proxy=proxy_url) @asyncio.coroutine def test_proxy_http_bad_response(proxy_test_server, get_request): url = 'http://aiohttp.io/path' proxy = yield from proxy_test_server() proxy.return_value = dict( status=502, headers={'Proxy-Agent': 'TestProxy'}) resp = yield from get_request(url=url, proxy=proxy.url) assert resp.status == 502 assert resp.headers['Proxy-Agent'] == 'TestProxy' @asyncio.coroutine def test_proxy_http_auth(proxy_test_server, get_request): url = 'http://aiohttp.io/path' proxy = yield from proxy_test_server() yield from get_request(url=url, proxy=proxy.url) assert 'Authorization' not in proxy.request.headers assert 'Proxy-Authorization' not in proxy.request.headers auth = aiohttp.helpers.BasicAuth('user', 'pass') yield from get_request(url=url, auth=auth, proxy=proxy.url) assert 'Authorization' in proxy.request.headers assert 'Proxy-Authorization' not in proxy.request.headers yield from get_request(url=url, proxy_auth=auth, proxy=proxy.url) assert 'Authorization' not in proxy.request.headers assert 'Proxy-Authorization' in proxy.request.headers yield from get_request(url=url, auth=auth, proxy_auth=auth, proxy=proxy.url) assert 'Authorization' in proxy.request.headers assert 'Proxy-Authorization' in proxy.request.headers @asyncio.coroutine def test_proxy_http_auth_utf8(proxy_test_server, get_request): url = 'http://aiohttp.io/path' auth = aiohttp.helpers.BasicAuth('юзер', 'пасс', 'utf-8') proxy = yield from proxy_test_server() yield from get_request(url=url, auth=auth, proxy=proxy.url) assert 'Authorization' in proxy.request.headers assert 'Proxy-Authorization' not in proxy.request.headers @asyncio.coroutine def test_proxy_http_auth_from_url(proxy_test_server, get_request): url = 'http://aiohttp.io/path' proxy = yield from proxy_test_server() auth_url = URL(url).with_user('user').with_password('pass') yield from get_request(url=auth_url, proxy=proxy.url) assert 'Authorization' in proxy.request.headers assert 'Proxy-Authorization' not in proxy.request.headers proxy_url = URL(proxy.url).with_user('user').with_password('pass') yield from get_request(url=url, proxy=proxy_url) assert 'Authorization' not in proxy.request.headers assert 'Proxy-Authorization' in proxy.request.headers @asyncio.coroutine def test_proxy_http_acquired_cleanup(proxy_test_server, loop): url = 'http://aiohttp.io/path' key = ('aiohttp.io', 80, False) conn = aiohttp.TCPConnector(loop=loop) sess = aiohttp.ClientSession(connector=conn, loop=loop) proxy = yield from proxy_test_server() assert 0 == len(conn._acquired.keys()) @asyncio.coroutine def request(): resp = yield from sess.get(url, proxy=proxy.url) assert 1 == len(conn._acquired.keys()) assert 1 == len(conn._acquired[key]) yield from resp.release() yield from request() assert 0 == len(conn._acquired[key]) yield from sess.close() @asyncio.coroutine def test_proxy_http_acquired_cleanup_force(proxy_test_server, loop): url = 'http://aiohttp.io/path' key = ('aiohttp.io', 80, False) conn = aiohttp.TCPConnector(force_close=True, loop=loop) sess = aiohttp.ClientSession(connector=conn, loop=loop) proxy = yield from proxy_test_server() assert 0 == len(conn._acquired.keys()) @asyncio.coroutine def request(): resp = yield from sess.get(url, proxy=proxy.url) assert 1 == len(conn._acquired.keys()) assert 1 == len(conn._acquired[key]) yield from resp.release() yield from request() assert 0 == len(conn._acquired[key]) yield from sess.close() @asyncio.coroutine def test_proxy_http_multi_conn_limit(proxy_test_server, loop): url = 'http://aiohttp.io/path' limit, multi_conn_num = 1, 5 conn = aiohttp.TCPConnector(limit=limit, loop=loop) sess = aiohttp.ClientSession(connector=conn, loop=loop) proxy = yield from proxy_test_server() current_pid = None @asyncio.coroutine def request(pid): # process requests only one by one nonlocal current_pid resp = yield from sess.get(url, proxy=proxy.url) current_pid = pid yield from asyncio.sleep(0.2, loop=loop) assert current_pid == pid yield from resp.release() return resp requests = [request(pid) for pid in range(multi_conn_num)] responses = yield from asyncio.gather(*requests, loop=loop) assert len(responses) == multi_conn_num assert set(resp.status for resp in responses) == {200} yield from sess.close() @asyncio.coroutine def test_proxy_https_connect(proxy_test_server, get_request): proxy = yield from proxy_test_server() url = 'https://www.google.com.ua/search?q=aiohttp proxy' yield from get_request(url=url, proxy=proxy.url) connect = proxy.requests_list[0] assert connect.method == 'CONNECT' assert connect.path == 'www.google.com.ua:443' assert connect.host == 'www.google.com.ua' assert proxy.request.host == 'www.google.com.ua' assert proxy.request.path_qs == '/search?q=aiohttp+proxy' @asyncio.coroutine def test_proxy_https_connect_with_port(proxy_test_server, get_request): proxy = yield from proxy_test_server() url = 'https://secure.aiohttp.io:2242/path' yield from get_request(url=url, proxy=proxy.url) connect = proxy.requests_list[0] assert connect.method == 'CONNECT' assert connect.path == 'secure.aiohttp.io:2242' assert connect.host == 'secure.aiohttp.io:2242' assert proxy.request.host == 'secure.aiohttp.io:2242' assert proxy.request.path_qs == '/path' @asyncio.coroutine def test_proxy_https_send_body(proxy_test_server, loop): sess = aiohttp.ClientSession(loop=loop) proxy = yield from proxy_test_server() proxy.return_value = {'status': 200, 'body': b'1'*(2**20)} url = 'https://www.google.com.ua/search?q=aiohttp proxy' resp = yield from sess.get(url, proxy=proxy.url) body = yield from resp.read() yield from resp.release() yield from sess.close() assert body == b'1'*(2**20) @asyncio.coroutine def test_proxy_https_idna_support(proxy_test_server, get_request): url = 'https://éé.com/' proxy = yield from proxy_test_server() yield from get_request(url=url, proxy=proxy.url) connect = proxy.requests_list[0] assert connect.method == 'CONNECT' assert connect.path == 'xn--9caa.com:443' assert connect.host == 'xn--9caa.com' @asyncio.coroutine def test_proxy_https_connection_error(get_request): url = 'https://secure.aiohttp.io/path' proxy_url = 'http://localhost:2242/' with pytest.raises(aiohttp.ProxyConnectionError): yield from get_request(url=url, proxy=proxy_url) @asyncio.coroutine def test_proxy_https_bad_response(proxy_test_server, get_request): url = 'https://secure.aiohttp.io/path' proxy = yield from proxy_test_server() proxy.return_value = dict( status=502, headers={'Proxy-Agent': 'TestProxy'}) with pytest.raises(aiohttp.HttpProxyError): yield from get_request(url=url, proxy=proxy.url) assert len(proxy.requests_list) == 1 assert proxy.request.method == 'CONNECT' assert proxy.request.path == 'secure.aiohttp.io:443' @asyncio.coroutine def test_proxy_https_auth(proxy_test_server, get_request): url = 'https://secure.aiohttp.io/path' auth = aiohttp.helpers.BasicAuth('user', 'pass') proxy = yield from proxy_test_server() yield from get_request(url=url, proxy=proxy.url) connect = proxy.requests_list[0] assert 'Authorization' not in connect.headers assert 'Proxy-Authorization' not in connect.headers assert 'Authorization' not in proxy.request.headers assert 'Proxy-Authorization' not in proxy.request.headers proxy = yield from proxy_test_server() yield from get_request(url=url, auth=auth, proxy=proxy.url) connect = proxy.requests_list[0] assert 'Authorization' not in connect.headers assert 'Proxy-Authorization' not in connect.headers assert 'Authorization' in proxy.request.headers assert 'Proxy-Authorization' not in proxy.request.headers proxy = yield from proxy_test_server() yield from get_request(url=url, proxy_auth=auth, proxy=proxy.url) connect = proxy.requests_list[0] assert 'Authorization' not in connect.headers assert 'Proxy-Authorization' in connect.headers assert 'Authorization' not in proxy.request.headers assert 'Proxy-Authorization' not in proxy.request.headers proxy = yield from proxy_test_server() yield from get_request(url=url, auth=auth, proxy_auth=auth, proxy=proxy.url) connect = proxy.requests_list[0] assert 'Authorization' not in connect.headers assert 'Proxy-Authorization' in connect.headers assert 'Authorization' in proxy.request.headers assert 'Proxy-Authorization' not in proxy.request.headers @asyncio.coroutine def test_proxy_https_acquired_cleanup(proxy_test_server, loop): url = 'https://secure.aiohttp.io/path' key = ('secure.aiohttp.io', 443, True) conn = aiohttp.TCPConnector(loop=loop) sess = aiohttp.ClientSession(connector=conn, loop=loop) proxy = yield from proxy_test_server() assert 0 == len(conn._acquired.keys()) @asyncio.coroutine def request(): resp = yield from sess.get(url, proxy=proxy.url) assert 1 == len(conn._acquired.keys()) assert 1 == len(conn._acquired[key]) yield from resp.release() yield from request() assert 0 == len(conn._acquired[key]) yield from sess.close() @asyncio.coroutine def test_proxy_https_acquired_cleanup_force(proxy_test_server, loop): url = 'https://secure.aiohttp.io/path' key = ('secure.aiohttp.io', 443, True) conn = aiohttp.TCPConnector(force_close=True, loop=loop) sess = aiohttp.ClientSession(connector=conn, loop=loop) proxy = yield from proxy_test_server() assert 0 == len(conn._acquired.keys()) @asyncio.coroutine def request(): resp = yield from sess.get(url, proxy=proxy.url) assert 1 == len(conn._acquired.keys()) assert 1 == len(conn._acquired[key]) yield from resp.release() yield from request() assert 0 == len(conn._acquired[key]) yield from sess.close() @asyncio.coroutine def test_proxy_https_multi_conn_limit(proxy_test_server, loop): url = 'https://secure.aiohttp.io/path' limit, multi_conn_num = 1, 5 conn = aiohttp.TCPConnector(limit=limit, loop=loop) sess = aiohttp.ClientSession(connector=conn, loop=loop) proxy = yield from proxy_test_server() current_pid = None @asyncio.coroutine def request(pid): # process requests only one by one nonlocal current_pid resp = yield from sess.get(url, proxy=proxy.url) current_pid = pid yield from asyncio.sleep(0.2, loop=loop) assert current_pid == pid yield from resp.release() return resp requests = [request(pid) for pid in range(multi_conn_num)] responses = yield from asyncio.gather(*requests, loop=loop) assert len(responses) == multi_conn_num assert set(resp.status for resp in responses) == {200} yield from sess.close() def _patch_ssl_transport(monkeypatch): """Make ssl transport substitution to prevent ssl handshake.""" def _make_ssl_transport_dummy(self, rawsock, protocol, sslcontext, waiter=None, **kwargs): return self._make_socket_transport(rawsock, protocol, waiter, extra=kwargs.get('extra'), server=kwargs.get('server')) monkeypatch.setattr( "asyncio.selector_events.BaseSelectorEventLoop._make_ssl_transport", _make_ssl_transport_dummy) aiohttp-1.2.0/tests/test_helpers.py0000664000175000017500000003156613025134363020256 0ustar travistravis00000000000000import datetime from unittest import mock import pytest from aiohttp import helpers def test_parse_mimetype_1(): assert helpers.parse_mimetype('') == ('', '', '', {}) def test_parse_mimetype_2(): assert helpers.parse_mimetype('*') == ('*', '*', '', {}) def test_parse_mimetype_3(): assert (helpers.parse_mimetype('application/json') == ('application', 'json', '', {})) def test_parse_mimetype_4(): assert ( helpers.parse_mimetype('application/json; charset=utf-8') == ('application', 'json', '', {'charset': 'utf-8'})) def test_parse_mimetype_5(): assert ( helpers.parse_mimetype('''application/json; charset=utf-8;''') == ('application', 'json', '', {'charset': 'utf-8'})) def test_parse_mimetype_6(): assert( helpers.parse_mimetype('ApPlIcAtIoN/JSON;ChaRseT="UTF-8"') == ('application', 'json', '', {'charset': 'UTF-8'})) def test_parse_mimetype_7(): assert ( helpers.parse_mimetype('application/rss+xml') == ('application', 'rss', 'xml', {})) def test_parse_mimetype_8(): assert ( helpers.parse_mimetype('text/plain;base64') == ('text', 'plain', '', {'base64': ''})) def test_basic_auth1(): # missing password here with pytest.raises(ValueError): helpers.BasicAuth(None) def test_basic_auth2(): with pytest.raises(ValueError): helpers.BasicAuth('nkim', None) def test_basic_with_auth_colon_in_login(): with pytest.raises(ValueError): helpers.BasicAuth('nkim:1', 'pwd') def test_basic_auth3(): auth = helpers.BasicAuth('nkim') assert auth.login == 'nkim' assert auth.password == '' def test_basic_auth4(): auth = helpers.BasicAuth('nkim', 'pwd') assert auth.login == 'nkim' assert auth.password == 'pwd' assert auth.encode() == 'Basic bmtpbTpwd2Q=' def test_basic_auth_decode(): auth = helpers.BasicAuth.decode('Basic bmtpbTpwd2Q=') assert auth.login == 'nkim' assert auth.password == 'pwd' def test_basic_auth_invalid(): with pytest.raises(ValueError): helpers.BasicAuth.decode('bmtpbTpwd2Q=') def test_basic_auth_decode_not_basic(): with pytest.raises(ValueError): helpers.BasicAuth.decode('Complex bmtpbTpwd2Q=') def test_basic_auth_decode_bad_base64(): with pytest.raises(ValueError): helpers.BasicAuth.decode('Basic bmtpbTpwd2Q') def test_invalid_formdata_params(): with pytest.raises(TypeError): helpers.FormData('asdasf') def test_invalid_formdata_params2(): with pytest.raises(TypeError): helpers.FormData('as') # 2-char str is not allowed def test_invalid_formdata_content_type(): form = helpers.FormData() invalid_vals = [0, 0.1, {}, [], b'foo'] for invalid_val in invalid_vals: with pytest.raises(TypeError): form.add_field('foo', 'bar', content_type=invalid_val) def test_invalid_formdata_filename(): form = helpers.FormData() invalid_vals = [0, 0.1, {}, [], b'foo'] for invalid_val in invalid_vals: with pytest.raises(TypeError): form.add_field('foo', 'bar', filename=invalid_val) def test_invalid_formdata_content_transfer_encoding(): form = helpers.FormData() invalid_vals = [0, 0.1, {}, [], b'foo'] for invalid_val in invalid_vals: with pytest.raises(TypeError): form.add_field('foo', 'bar', content_transfer_encoding=invalid_val) # ------------- access logger ------------------------- def test_access_logger_format(): log_format = '%T {%{SPAM}e} "%{ETag}o" %X {X} %%P %{FOO_TEST}e %{FOO1}e' mock_logger = mock.Mock() access_logger = helpers.AccessLogger(mock_logger, log_format) expected = '%s {%s} "%s" %%X {X} %%%s %s %s' assert expected == access_logger._log_format def test_access_logger_atoms(mocker): mock_datetime = mocker.patch("aiohttp.helpers.datetime") mock_getpid = mocker.patch("os.getpid") utcnow = datetime.datetime(1843, 1, 1, 0, 0) mock_datetime.datetime.utcnow.return_value = utcnow mock_getpid.return_value = 42 log_format = '%a %t %P %l %u %r %s %b %O %T %Tf %D' mock_logger = mock.Mock() access_logger = helpers.AccessLogger(mock_logger, log_format) message = mock.Mock(headers={}, method="GET", path="/path", version=(1, 1)) environ = {} response = mock.Mock(headers={}, output_length=123, body_length=42, status=200) transport = mock.Mock() transport.get_extra_info.return_value = ("127.0.0.2", 1234) access_logger.log(message, environ, response, transport, 3.1415926) assert not mock_logger.exception.called expected = ('127.0.0.2 [01/Jan/1843:00:00:00 +0000] <42> - - ' 'GET /path HTTP/1.1 200 42 123 3 3.141593 3141593') extra = { 'bytes_sent': 123, 'first_request_line': 'GET /path HTTP/1.1', 'process_id': '<42>', 'remote_address': '127.0.0.2', 'request_time': 3, 'request_time_frac': '3.141593', 'request_time_micro': 3141593, 'response_size': 42, 'response_status': 200 } mock_logger.info.assert_called_with(expected, extra=extra) def test_access_logger_dicts(): log_format = '%{User-Agent}i %{Content-Length}o %{SPAM}e %{None}i' mock_logger = mock.Mock() access_logger = helpers.AccessLogger(mock_logger, log_format) message = mock.Mock(headers={"User-Agent": "Mock/1.0"}, version=(1, 1)) environ = {"SPAM": "EGGS"} response = mock.Mock(headers={"Content-Length": 123}) transport = mock.Mock() transport.get_extra_info.return_value = ("127.0.0.2", 1234) access_logger.log(message, environ, response, transport, 0.0) assert not mock_logger.error.called expected = 'Mock/1.0 123 EGGS -' extra = { 'environ': {'SPAM': 'EGGS'}, 'request_header': {'None': '-'}, 'response_header': {'Content-Length': 123} } mock_logger.info.assert_called_with(expected, extra=extra) def test_access_logger_unix_socket(): log_format = '|%a|' mock_logger = mock.Mock() access_logger = helpers.AccessLogger(mock_logger, log_format) message = mock.Mock(headers={"User-Agent": "Mock/1.0"}, version=(1, 1)) environ = {} response = mock.Mock() transport = mock.Mock() transport.get_extra_info.return_value = "" access_logger.log(message, environ, response, transport, 0.0) assert not mock_logger.error.called expected = '||' mock_logger.info.assert_called_with(expected, extra={'remote_address': ''}) def test_logger_no_message_and_environ(): mock_logger = mock.Mock() mock_transport = mock.Mock() mock_transport.get_extra_info.return_value = ("127.0.0.3", 0) access_logger = helpers.AccessLogger(mock_logger, "%r %{FOOBAR}e %{content-type}i") extra_dict = { 'environ': {'FOOBAR': '-'}, 'first_request_line': '-', 'request_header': {'content-type': '(no headers)'} } access_logger.log(None, None, None, mock_transport, 0.0) mock_logger.info.assert_called_with("- - (no headers)", extra=extra_dict) def test_logger_internal_error(): mock_logger = mock.Mock() mock_transport = mock.Mock() mock_transport.get_extra_info.return_value = ("127.0.0.3", 0) access_logger = helpers.AccessLogger(mock_logger, "%D") access_logger.log(None, None, None, mock_transport, 'invalid') mock_logger.exception.assert_called_with("Error in logging") def test_logger_no_transport(): mock_logger = mock.Mock() access_logger = helpers.AccessLogger(mock_logger, "%a") access_logger.log(None, None, None, None, 0) mock_logger.info.assert_called_with("-", extra={'remote_address': '-'}) class TestReify: def test_reify(self): class A: def __init__(self): self._cache = {} @helpers.reify def prop(self): return 1 a = A() assert 1 == a.prop def test_reify_class(self): class A: def __init__(self): self._cache = {} @helpers.reify def prop(self): """Docstring.""" return 1 assert isinstance(A.prop, helpers.reify) assert 'Docstring.' == A.prop.__doc__ def test_reify_assignment(self): class A: def __init__(self): self._cache = {} @helpers.reify def prop(self): return 1 a = A() with pytest.raises(AttributeError): a.prop = 123 def test_create_future_with_new_loop(): # We should use the new create_future() if it's available. mock_loop = mock.Mock() expected = 'hello' mock_loop.create_future.return_value = expected assert expected == helpers.create_future(mock_loop) def test_create_future_with_old_loop(mocker): MockFuture = mocker.patch('asyncio.Future') # The old loop (without create_future()) should just have a Future object # wrapped around it. mock_loop = mock.Mock() del mock_loop.create_future expected = 'hello' MockFuture.return_value = expected future = helpers.create_future(mock_loop) MockFuture.assert_called_with(loop=mock_loop) assert expected == future # ----------------------------------- is_ip_address() ---------------------- def test_is_ip_address(): assert helpers.is_ip_address("127.0.0.1") assert helpers.is_ip_address("::1") assert helpers.is_ip_address("FE80:0000:0000:0000:0202:B3FF:FE1E:8329") # Hostnames assert not helpers.is_ip_address("localhost") assert not helpers.is_ip_address("www.example.com") # Out of range assert not helpers.is_ip_address("999.999.999.999") # Contain a port assert not helpers.is_ip_address("127.0.0.1:80") assert not helpers.is_ip_address("[2001:db8:0:1]:80") # Too many "::" assert not helpers.is_ip_address("1200::AB00:1234::2552:7777:1313") def test_is_ip_address_bytes(): assert helpers.is_ip_address(b"127.0.0.1") assert helpers.is_ip_address(b"::1") assert helpers.is_ip_address(b"FE80:0000:0000:0000:0202:B3FF:FE1E:8329") # Hostnames assert not helpers.is_ip_address(b"localhost") assert not helpers.is_ip_address(b"www.example.com") # Out of range assert not helpers.is_ip_address(b"999.999.999.999") # Contain a port assert not helpers.is_ip_address(b"127.0.0.1:80") assert not helpers.is_ip_address(b"[2001:db8:0:1]:80") # Too many "::" assert not helpers.is_ip_address(b"1200::AB00:1234::2552:7777:1313") def test_ip_addresses(): ip_addresses = [ '0.0.0.0', '127.0.0.1', '255.255.255.255', '0:0:0:0:0:0:0:0', 'FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF', '00AB:0002:3008:8CFD:00AB:0002:3008:8CFD', '00ab:0002:3008:8cfd:00ab:0002:3008:8cfd', 'AB:02:3008:8CFD:AB:02:3008:8CFD', 'AB:02:3008:8CFD::02:3008:8CFD', '::', '1::1', ] for address in ip_addresses: assert helpers.is_ip_address(address) def test_host_addresses(): hosts = [ 'www.four.part.host' 'www.python.org', 'foo.bar', 'localhost', ] for host in hosts: assert not helpers.is_ip_address(host) def test_is_ip_address_invalid_type(): with pytest.raises(TypeError): helpers.is_ip_address(123) with pytest.raises(TypeError): helpers.is_ip_address(object()) @pytest.fixture def time_service(loop): return helpers.TimeService(loop) class TestTimeService: def test_ctor(self, time_service): assert time_service._cb is not None assert time_service._time is not None assert time_service._strtime is None assert time_service._count == 0 def test_stop(self, time_service): time_service.stop() assert time_service._cb is None assert time_service._loop is None def test_double_stopping(self, time_service): time_service.stop() time_service.stop() assert time_service._cb is None assert time_service._loop is None def test_time(self, time_service): t = time_service._time assert t == time_service.time() def test_strtime(self, time_service): time_service._time = 1477797232 assert time_service.strtime() == 'Sun, 30 Oct 2016 03:13:52 GMT' # second call should use cached value assert time_service.strtime() == 'Sun, 30 Oct 2016 03:13:52 GMT' def test_recalc_time(self, time_service): time_service._time = 123 time_service._strtime = 'asd' time_service._count = 1000000 time_service._on_cb() assert time_service._strtime is None assert time_service._count == 0 assert time_service._time > 1234 class TestFrozenList: def test_eq(self): l = helpers.FrozenList([1]) assert l == [1] def test_le(self): l = helpers.FrozenList([1]) assert l < [2] aiohttp-1.2.0/tests/test_web_server.py0000664000175000017500000000361313025134363020747 0ustar travistravis00000000000000import asyncio from unittest import mock from aiohttp import web @asyncio.coroutine def test_simple_server(raw_test_server, test_client): @asyncio.coroutine def handler(request): return web.Response(text=str(request.rel_url)) server = yield from raw_test_server(handler) client = yield from test_client(server) resp = yield from client.get('/path/to') assert resp.status == 200 txt = yield from resp.text() assert txt == '/path/to' @asyncio.coroutine def test_raw_server_not_http_exception(raw_test_server, test_client): exc = RuntimeError("custom runtime error") @asyncio.coroutine def handler(request): raise exc logger = mock.Mock() server = yield from raw_test_server(handler, logger=logger) client = yield from test_client(server) resp = yield from client.get('/path/to') assert resp.status == 500 txt = yield from resp.text() assert "

500 Internal Server Error

" in txt logger.exception.assert_called_with( "Error handling request", exc_info=exc) @asyncio.coroutine def test_raw_server_not_http_exception_debug(raw_test_server, test_client): exc = RuntimeError("custom runtime error") @asyncio.coroutine def handler(request): raise exc logger = mock.Mock() server = yield from raw_test_server(handler, logger=logger, debug=True) client = yield from test_client(server) resp = yield from client.get('/path/to') assert resp.status == 500 txt = yield from resp.text() assert "

Traceback:

" in txt logger.exception.assert_called_with( "Error handling request", exc_info=exc) def test_create_web_server_with_implicit_loop(loop): asyncio.set_event_loop(loop) @asyncio.coroutine def handler(request): return web.Response() # pragma: no cover srv = web.Server(handler) assert srv._loop is loop aiohttp-1.2.0/tests/test_web_cli.py0000664000175000017500000000717213025134363020214 0ustar travistravis00000000000000import pytest from aiohttp import web def test_entry_func_empty(mocker): error = mocker.patch("aiohttp.web.ArgumentParser.error", side_effect=SystemExit) argv = [""] with pytest.raises(SystemExit): web.main(argv) error.assert_called_with( "'entry-func' not in 'module:function' syntax" ) def test_entry_func_only_module(mocker): argv = ["test"] error = mocker.patch("aiohttp.web.ArgumentParser.error", side_effect=SystemExit) with pytest.raises(SystemExit): web.main(argv) error.assert_called_with( "'entry-func' not in 'module:function' syntax" ) def test_entry_func_only_function(mocker): argv = [":test"] error = mocker.patch("aiohttp.web.ArgumentParser.error", side_effect=SystemExit) with pytest.raises(SystemExit): web.main(argv) error.assert_called_with( "'entry-func' not in 'module:function' syntax" ) def test_entry_func_only_seperator(mocker): argv = [":"] error = mocker.patch("aiohttp.web.ArgumentParser.error", side_effect=SystemExit) with pytest.raises(SystemExit): web.main(argv) error.assert_called_with( "'entry-func' not in 'module:function' syntax" ) def test_entry_func_relative_module(mocker): argv = [".a.b:c"] error = mocker.patch("aiohttp.web.ArgumentParser.error", side_effect=SystemExit) with pytest.raises(SystemExit): web.main(argv) error.assert_called_with("relative module names not supported") def test_entry_func_non_existent_module(mocker): argv = ["alpha.beta:func"] mocker.patch("aiohttp.web.import_module", side_effect=ImportError("Test Error")) error = mocker.patch("aiohttp.web.ArgumentParser.error", side_effect=SystemExit) with pytest.raises(SystemExit): web.main(argv) error.assert_called_with('unable to import alpha.beta: Test Error') def test_entry_func_non_existent_attribute(mocker): argv = ["alpha.beta:func"] import_module = mocker.patch("aiohttp.web.import_module") error = mocker.patch("aiohttp.web.ArgumentParser.error", side_effect=SystemExit) module = import_module("alpha.beta") del module.func with pytest.raises(SystemExit): web.main(argv) error.assert_called_with( "module %r has no attribute %r" % ("alpha.beta", "func") ) def test_entry_func_call(mocker): mocker.patch("aiohttp.web.run_app") import_module = mocker.patch("aiohttp.web.import_module") argv = ("-H testhost -P 6666 --extra-optional-eins alpha.beta:func " "--extra-optional-zwei extra positional args").split() module = import_module("alpha.beta") with pytest.raises(SystemExit): web.main(argv) module.func.assert_called_with( ("--extra-optional-eins --extra-optional-zwei extra positional " "args").split() ) def test_running_application(mocker): run_app = mocker.patch("aiohttp.web.run_app") import_module = mocker.patch("aiohttp.web.import_module") exit = mocker.patch("aiohttp.web.ArgumentParser.exit", side_effect=SystemExit) argv = ("-H testhost -P 6666 --extra-optional-eins alpha.beta:func " "--extra-optional-zwei extra positional args").split() module = import_module("alpha.beta") app = module.func() with pytest.raises(SystemExit): web.main(argv) run_app.assert_called_with(app, host="testhost", port=6666) exit.assert_called_with(message="Stopped\n") aiohttp-1.2.0/tests/test_client_request.py0000664000175000017500000007646113025134363021645 0ustar travistravis00000000000000# coding: utf-8 import asyncio import inspect import io import os.path import urllib.parse import zlib from http.cookies import SimpleCookie from unittest import mock import pytest from multidict import CIMultiDict, CIMultiDictProxy, upstr from yarl import URL import aiohttp from aiohttp import BaseConnector, hdrs, helpers from aiohttp.client_reqrep import ClientRequest, ClientResponse @pytest.yield_fixture def make_request(loop): request = None def maker(method, url, *args, **kwargs): nonlocal request request = ClientRequest(method, URL(url), *args, loop=loop, **kwargs) return request yield maker if request is not None: loop.run_until_complete(request.close()) def test_method1(make_request): req = make_request('get', 'http://python.org/') assert req.method == 'GET' def test_method2(make_request): req = make_request('head', 'http://python.org/') assert req.method == 'HEAD' def test_method3(make_request): req = make_request('HEAD', 'http://python.org/') assert req.method == 'HEAD' def test_version_1_0(make_request): req = make_request('get', 'http://python.org/', version='1.0') assert req.version == (1, 0) def test_version_default(make_request): req = make_request('get', 'http://python.org/') assert req.version == (1, 1) def test_version_err(make_request): with pytest.raises(ValueError): make_request('get', 'http://python.org/', version='1.c') def test_host_port_default_http(make_request): req = make_request('get', 'http://python.org/') assert req.host == 'python.org' assert req.port == 80 assert not req.ssl def test_host_port_default_https(make_request): req = make_request('get', 'https://python.org/') assert req.host == 'python.org' assert req.port == 443 assert req.ssl def test_host_port_nondefault_http(make_request): req = make_request('get', 'http://python.org:960/') assert req.host == 'python.org' assert req.port == 960 assert not req.ssl def test_host_port_nondefault_https(make_request): req = make_request('get', 'https://python.org:960/') assert req.host == 'python.org' assert req.port == 960 assert req.ssl def test_host_port_default_ws(make_request): req = make_request('get', 'ws://python.org/') assert req.host == 'python.org' assert req.port == 80 assert not req.ssl def test_host_port_default_wss(make_request): req = make_request('get', 'wss://python.org/') assert req.host == 'python.org' assert req.port == 443 assert req.ssl def test_host_port_nondefault_ws(make_request): req = make_request('get', 'ws://python.org:960/') assert req.host == 'python.org' assert req.port == 960 assert not req.ssl def test_host_port_nondefault_wss(make_request): req = make_request('get', 'wss://python.org:960/') assert req.host == 'python.org' assert req.port == 960 assert req.ssl def test_host_port_err(make_request): with pytest.raises(ValueError): make_request('get', 'http://python.org:123e/') def test_hostname_err(make_request): with pytest.raises(ValueError): make_request('get', 'http://:8080/') def test_host_header_host_without_port(make_request): req = make_request('get', 'http://python.org/') assert req.headers['HOST'] == 'python.org' def test_host_header_host_with_default_port(make_request): req = make_request('get', 'http://python.org:80/') assert req.headers['HOST'] == 'python.org' def test_host_header_host_with_nondefault_port(make_request): req = make_request('get', 'http://python.org:99/') assert req.headers['HOST'] == 'python.org:99' def test_host_header_host_idna_encode(make_request): req = make_request('get', 'http://xn--9caa.com') assert req.headers['HOST'] == 'xn--9caa.com' def test_host_header_host_unicode(make_request): req = make_request('get', 'http://éé.com') assert req.headers['HOST'] == 'xn--9caa.com' def test_host_header_explicit_host(make_request): req = make_request('get', 'http://python.org/', headers={'host': 'example.com'}) assert req.headers['HOST'] == 'example.com' def test_host_header_explicit_host_with_port(make_request): req = make_request('get', 'http://python.org/', headers={'host': 'example.com:99'}) assert req.headers['HOST'] == 'example.com:99' def test_default_loop(loop): asyncio.set_event_loop(loop) req = ClientRequest('get', URL('http://python.org/')) assert req.loop is loop def test_default_headers_useragent(make_request): req = make_request('get', 'http://python.org/') assert 'SERVER' not in req.headers assert 'USER-AGENT' in req.headers def test_default_headers_useragent_custom(make_request): req = make_request('get', 'http://python.org/', headers={'user-agent': 'my custom agent'}) assert 'USER-Agent' in req.headers assert 'my custom agent' == req.headers['User-Agent'] def test_skip_default_useragent_header(make_request): req = make_request('get', 'http://python.org/', skip_auto_headers=set([upstr('user-agent')])) assert 'User-Agent' not in req.headers def test_headers(make_request): req = make_request('get', 'http://python.org/', headers={'Content-Type': 'text/plain'}) assert 'CONTENT-TYPE' in req.headers assert req.headers['CONTENT-TYPE'] == 'text/plain' assert req.headers['ACCEPT-ENCODING'] == 'gzip, deflate' def test_headers_list(make_request): req = make_request('get', 'http://python.org/', headers=[('Content-Type', 'text/plain')]) assert 'CONTENT-TYPE' in req.headers assert req.headers['CONTENT-TYPE'] == 'text/plain' def test_headers_default(make_request): req = make_request('get', 'http://python.org/', headers={'ACCEPT-ENCODING': 'deflate'}) assert req.headers['ACCEPT-ENCODING'] == 'deflate' def test_invalid_url(make_request): with pytest.raises(ValueError): make_request('get', 'hiwpefhipowhefopw') def test_invalid_idna(make_request): with pytest.raises(ValueError): make_request('get', 'http://\u2061owhefopw.com') def test_no_path(make_request): req = make_request('get', 'http://python.org') assert '/' == req.url.path def test_ipv6_default_http_port(make_request): req = make_request('get', 'http://[2001:db8::1]/') assert req.host == '2001:db8::1' assert req.port == 80 assert not req.ssl def test_ipv6_default_https_port(make_request): req = make_request('get', 'https://[2001:db8::1]/') assert req.host == '2001:db8::1' assert req.port == 443 assert req.ssl def test_ipv6_nondefault_http_port(make_request): req = make_request('get', 'http://[2001:db8::1]:960/') assert req.host == '2001:db8::1' assert req.port == 960 assert not req.ssl def test_ipv6_nondefault_https_port(make_request): req = make_request('get', 'https://[2001:db8::1]:960/') assert req.host == '2001:db8::1' assert req.port == 960 assert req.ssl def test_basic_auth(make_request): req = make_request('get', 'http://python.org', auth=aiohttp.helpers.BasicAuth('nkim', '1234')) assert 'AUTHORIZATION' in req.headers assert 'Basic bmtpbToxMjM0' == req.headers['AUTHORIZATION'] def test_basic_auth_utf8(make_request): req = make_request('get', 'http://python.org', auth=aiohttp.helpers.BasicAuth('nkim', 'секрет', 'utf-8')) assert 'AUTHORIZATION' in req.headers assert 'Basic bmtpbTrRgdC10LrRgNC10YI=' == req.headers['AUTHORIZATION'] def test_basic_auth_tuple_forbidden(make_request): with pytest.raises(TypeError): make_request('get', 'http://python.org', auth=('nkim', '1234')) def test_basic_auth_from_url(make_request): req = make_request('get', 'http://nkim:1234@python.org') assert 'AUTHORIZATION' in req.headers assert 'Basic bmtpbToxMjM0' == req.headers['AUTHORIZATION'] assert 'python.org' == req.host def test_basic_auth_from_url_overriden(make_request): req = make_request('get', 'http://garbage@python.org', auth=aiohttp.BasicAuth('nkim', '1234')) assert 'AUTHORIZATION' in req.headers assert 'Basic bmtpbToxMjM0' == req.headers['AUTHORIZATION'] assert 'python.org' == req.host def test_path_is_not_double_encoded1(make_request): req = make_request('get', "http://0.0.0.0/get/test case") assert req.url.raw_path == "/get/test%20case" def test_path_is_not_double_encoded2(make_request): req = make_request('get', "http://0.0.0.0/get/test%2fcase") assert req.url.raw_path == "/get/test%2Fcase" def test_path_is_not_double_encoded3(make_request): req = make_request('get', "http://0.0.0.0/get/test%20case") assert req.url.raw_path == "/get/test%20case" def test_path_safe_chars_preserved(make_request): req = make_request('get', "http://0.0.0.0/get/:=") assert req.url.path == "/get/:=" def test_params_are_added_before_fragment1(make_request): req = make_request('GET', "http://example.com/path#fragment", params={"a": "b"}) assert str(req.url) == "http://example.com/path?a=b" def test_params_are_added_before_fragment2(make_request): req = make_request('GET', "http://example.com/path?key=value#fragment", params={"a": "b"}) assert str(req.url) == "http://example.com/path?key=value&a=b" def test_path_not_contain_fragment1(make_request): req = make_request('GET', "http://example.com/path#fragment") assert req.url.path == "/path" def test_path_not_contain_fragment2(make_request): req = make_request('GET', "http://example.com/path?key=value#fragment") assert str(req.url) == "http://example.com/path?key=value" def test_cookies(make_request): req = make_request('get', 'http://test.com/path', cookies={'cookie1': 'val1'}) assert 'COOKIE' in req.headers assert 'cookie1=val1' == req.headers['COOKIE'] def test_cookies_merge_with_headers(make_request): req = make_request('get', 'http://test.com/path', headers={'cookie': 'cookie1=val1'}, cookies={'cookie2': 'val2'}) assert 'cookie1=val1; cookie2=val2' == req.headers['COOKIE'] def test_unicode_get1(make_request): req = make_request('get', 'http://python.org', params={'foo': 'f\xf8\xf8'}) assert 'http://python.org/?foo=f%C3%B8%C3%B8' == str(req.url) def test_unicode_get2(make_request): req = make_request('', 'http://python.org', params={'f\xf8\xf8': 'f\xf8\xf8'}) assert 'http://python.org/?f%C3%B8%C3%B8=f%C3%B8%C3%B8' == str(req.url) def test_unicode_get3(make_request): req = make_request('', 'http://python.org', params={'foo': 'foo'}) assert 'http://python.org/?foo=foo' == str(req.url) def test_unicode_get4(make_request): def join(*suffix): return urllib.parse.urljoin('http://python.org/', '/'.join(suffix)) req = make_request('', join('\xf8'), params={'foo': 'foo'}) assert 'http://python.org/%C3%B8?foo=foo' == str(req.url) def test_query_multivalued_param(make_request): for meth in ClientRequest.ALL_METHODS: req = make_request( meth, 'http://python.org', params=(('test', 'foo'), ('test', 'baz'))) assert str(req.url) == 'http://python.org/?test=foo&test=baz' def test_query_str_param(make_request): for meth in ClientRequest.ALL_METHODS: req = make_request(meth, 'http://python.org', params='test=foo') assert str(req.url) == 'http://python.org/?test=foo' def test_query_bytes_param_raises(make_request): for meth in ClientRequest.ALL_METHODS: with pytest.raises(TypeError): make_request(meth, 'http://python.org', params=b'test=foo') def test_query_str_param_is_not_encoded(make_request): for meth in ClientRequest.ALL_METHODS: req = make_request(meth, 'http://python.org', params='test=f+oo') assert str(req.url) == 'http://python.org/?test=f+oo' def test_params_update_path_and_url(make_request): req = make_request('get', 'http://python.org', params=(('test', 'foo'), ('test', 'baz'))) assert str(req.url) == 'http://python.org/?test=foo&test=baz' def test_params_empty_path_and_url(make_request): req_empty = make_request('get', 'http://python.org', params={}) assert str(req_empty.url) == 'http://python.org' req_none = make_request('get', 'http://python.org') assert str(req_none.url) == 'http://python.org' def test_gen_netloc_all(make_request): req = make_request('get', 'https://aiohttp:pwpwpw@' + '12345678901234567890123456789' + '012345678901234567890:8080') assert req.headers['HOST'] == '12345678901234567890123456789' +\ '012345678901234567890:8080' def test_gen_netloc_no_port(make_request): req = make_request('get', 'https://aiohttp:pwpwpw@' + '12345678901234567890123456789' + '012345678901234567890/') assert req.headers['HOST'] == '12345678901234567890123456789' +\ '012345678901234567890' @asyncio.coroutine def test_no_content_length(loop): req = ClientRequest('get', URL('http://python.org'), loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert '0' == req.headers.get('CONTENT-LENGTH') yield from req.close() resp.close() @asyncio.coroutine def test_no_content_length2(loop): req = ClientRequest('head', URL('http://python.org'), loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert '0' == req.headers.get('CONTENT-LENGTH') yield from req.close() resp.close() def test_content_type_auto_header_get(loop): req = ClientRequest('get', URL('http://python.org'), loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert 'CONTENT-TYPE' not in req.headers resp.close() def test_content_type_auto_header_form(loop): req = ClientRequest('post', URL('http://python.org'), data={'hey': 'you'}, loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert 'application/x-www-form-urlencoded' == \ req.headers.get('CONTENT-TYPE') resp.close() def test_content_type_auto_header_bytes(loop): req = ClientRequest('post', URL('http://python.org'), data=b'hey you', loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert 'application/octet-stream' == req.headers.get('CONTENT-TYPE') resp.close() def test_content_type_skip_auto_header_bytes(loop): req = ClientRequest('post', URL('http://python.org'), data=b'hey you', skip_auto_headers={'Content-Type'}, loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert 'CONTENT-TYPE' not in req.headers resp.close() def test_content_type_skip_auto_header_form(loop): req = ClientRequest('post', URL('http://python.org'), data={'hey': 'you'}, loop=loop, skip_auto_headers={'Content-Type'}) resp = req.send(mock.Mock(), mock.Mock()) assert 'CONTENT-TYPE' not in req.headers resp.close() def test_content_type_auto_header_content_length_no_skip(loop): req = ClientRequest('get', URL('http://python.org'), data=io.BytesIO(b'hey'), skip_auto_headers={'Content-Length'}, loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert req.headers.get('CONTENT-LENGTH') == '3' resp.close() @asyncio.coroutine def test_post_data(loop): for meth in ClientRequest.POST_METHODS: req = ClientRequest( meth, URL('http://python.org/'), data={'life': '42'}, loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert '/' == req.url.path assert b'life=42' == req.body assert 'application/x-www-form-urlencoded' ==\ req.headers['CONTENT-TYPE'] yield from req.close() resp.close() @asyncio.coroutine def test_pass_falsy_data(loop): with mock.patch( 'aiohttp.client_reqrep.ClientRequest.update_body_from_data'): req = ClientRequest( 'post', URL('http://python.org/'), data={}, loop=loop) req.update_body_from_data.assert_called_once_with({}, frozenset()) yield from req.close() @asyncio.coroutine def test_pass_falsy_data_file(loop, tmpdir): testfile = tmpdir.join('tmpfile').open('w+b') testfile.write(b'data') testfile.seek(0) skip = frozenset([hdrs.CONTENT_TYPE]) req = ClientRequest( 'post', URL('http://python.org/'), data=testfile, skip_auto_headers=skip, loop=loop) assert req.headers.get('CONTENT-LENGTH', None) is not None yield from req.close() @asyncio.coroutine def test_get_with_data(loop): for meth in ClientRequest.GET_METHODS: req = ClientRequest( meth, URL('http://python.org/'), data={'life': '42'}, loop=loop) assert '/' == req.url.path assert b'life=42' == req.body yield from req.close() @asyncio.coroutine def test_bytes_data(loop): for meth in ClientRequest.POST_METHODS: req = ClientRequest( meth, URL('http://python.org/'), data=b'binary data', loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert '/' == req.url.path assert b'binary data' == req.body assert 'application/octet-stream' == req.headers['CONTENT-TYPE'] yield from req.close() resp.close() @asyncio.coroutine def test_content_encoding(loop): req = ClientRequest('get', URL('http://python.org/'), data='foo', compress='deflate', loop=loop) with mock.patch('aiohttp.client_reqrep.aiohttp') as m_http: resp = req.send(mock.Mock(), mock.Mock()) assert req.headers['TRANSFER-ENCODING'] == 'chunked' assert req.headers['CONTENT-ENCODING'] == 'deflate' m_http.Request.return_value\ .add_compression_filter.assert_called_with('deflate') yield from req.close() resp.close() @asyncio.coroutine def test_content_encoding_dont_set_headers_if_no_body(loop): req = ClientRequest('get', URL('http://python.org/'), compress='deflate', loop=loop) with mock.patch('aiohttp.client_reqrep.aiohttp'): resp = req.send(mock.Mock(), mock.Mock()) assert 'TRANSFER-ENCODING' not in req.headers assert 'CONTENT-ENCODING' not in req.headers yield from req.close() resp.close() @asyncio.coroutine def test_content_encoding_header(loop): req = ClientRequest( 'get', URL('http://python.org/'), data='foo', headers={'Content-Encoding': 'deflate'}, loop=loop) with mock.patch('aiohttp.client_reqrep.aiohttp') as m_http: resp = req.send(mock.Mock(), mock.Mock()) assert req.headers['TRANSFER-ENCODING'] == 'chunked' assert req.headers['CONTENT-ENCODING'] == 'deflate' m_http.Request.return_value\ .add_compression_filter.assert_called_with('deflate') m_http.Request.return_value\ .add_chunking_filter.assert_called_with(8192) yield from req.close() resp.close() @asyncio.coroutine def test_chunked(loop): req = ClientRequest( 'get', URL('http://python.org/'), headers={'TRANSFER-ENCODING': 'gzip'}, loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert 'gzip' == req.headers['TRANSFER-ENCODING'] yield from req.close() resp.close() @asyncio.coroutine def test_chunked2(loop): req = ClientRequest( 'get', URL('http://python.org/'), headers={'Transfer-encoding': 'chunked'}, loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert 'chunked' == req.headers['TRANSFER-ENCODING'] yield from req.close() resp.close() @asyncio.coroutine def test_chunked_explicit(loop): req = ClientRequest( 'get', URL('http://python.org/'), chunked=True, loop=loop) with mock.patch('aiohttp.client_reqrep.aiohttp') as m_http: resp = req.send(mock.Mock(), mock.Mock()) assert 'chunked' == req.headers['TRANSFER-ENCODING'] m_http.Request.return_value\ .add_chunking_filter.assert_called_with(8192) yield from req.close() resp.close() @asyncio.coroutine def test_chunked_explicit_size(loop): req = ClientRequest( 'get', URL('http://python.org/'), chunked=1024, loop=loop) with mock.patch('aiohttp.client_reqrep.aiohttp') as m_http: resp = req.send(mock.Mock(), mock.Mock()) assert 'chunked' == req.headers['TRANSFER-ENCODING'] m_http.Request.return_value\ .add_chunking_filter.assert_called_with(1024) yield from req.close() resp.close() @asyncio.coroutine def test_chunked_length(loop): req = ClientRequest( 'get', URL('http://python.org/'), headers={'CONTENT-LENGTH': '1000'}, chunked=1024, loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert req.headers['TRANSFER-ENCODING'] == 'chunked' assert 'CONTENT-LENGTH' not in req.headers yield from req.close() resp.close() @asyncio.coroutine def test_file_upload_not_chunked(loop): here = os.path.dirname(__file__) fname = os.path.join(here, 'sample.key') with open(fname, 'rb') as f: req = ClientRequest( 'post', URL('http://python.org/'), data=f, loop=loop) assert not req.chunked assert req.headers['CONTENT-LENGTH'] == str(os.path.getsize(fname)) yield from req.close() @asyncio.coroutine def test_precompressed_data_stays_intact(loop): data = zlib.compress(b'foobar') req = ClientRequest( 'post', URL('http://python.org/'), data=data, headers={'CONTENT-ENCODING': 'deflate'}, compress=False, loop=loop) assert not req.compress assert not req.chunked assert req.headers['CONTENT-ENCODING'] == 'deflate' yield from req.close() @asyncio.coroutine def test_file_upload_not_chunked_seek(loop): here = os.path.dirname(__file__) fname = os.path.join(here, 'sample.key') with open(fname, 'rb') as f: f.seek(100) req = ClientRequest( 'post', URL('http://python.org/'), data=f, loop=loop) assert req.headers['CONTENT-LENGTH'] == \ str(os.path.getsize(fname) - 100) yield from req.close() @asyncio.coroutine def test_file_upload_force_chunked(loop): here = os.path.dirname(__file__) fname = os.path.join(here, 'sample.key') with open(fname, 'rb') as f: req = ClientRequest( 'post', URL('http://python.org/'), data=f, chunked=True, loop=loop) assert req.chunked assert 'CONTENT-LENGTH' not in req.headers yield from req.close() def test_expect100(loop): req = ClientRequest('get', URL('http://python.org/'), expect100=True, loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert '100-continue' == req.headers['EXPECT'] assert req._continue is not None req.terminate() resp.close() def test_expect_100_continue_header(loop): req = ClientRequest('get', URL('http://python.org/'), headers={'expect': '100-continue'}, loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert '100-continue' == req.headers['EXPECT'] assert req._continue is not None req.terminate() resp.close() @asyncio.coroutine def test_data_stream(loop): def gen(): yield b'binary data' return b' result' req = ClientRequest( 'POST', URL('http://python.org/'), data=gen(), loop=loop) assert req.chunked assert inspect.isgenerator(req.body) assert req.headers['TRANSFER-ENCODING'] == 'chunked' transport = mock.Mock() resp = req.send(transport, mock.Mock()) assert isinstance(req._writer, asyncio.Future) yield from resp.wait_for_close() assert req._writer is None assert transport.write.mock_calls[-2:] == [ mock.call(b'12\r\nbinary data result\r\n'), mock.call(b'0\r\n\r\n')] yield from req.close() @asyncio.coroutine def test_data_file(loop): req = ClientRequest( 'POST', URL('http://python.org/'), data=io.BufferedReader(io.BytesIO(b'*' * 2)), loop=loop) assert req.chunked assert isinstance(req.body, io.IOBase) assert req.headers['TRANSFER-ENCODING'] == 'chunked' transport = mock.Mock() resp = req.send(transport, mock.Mock()) assert isinstance(req._writer, asyncio.Future) yield from resp.wait_for_close() assert req._writer is None assert transport.write.mock_calls[-2:] == [ mock.call(b'2\r\n' + b'*' * 2 + b'\r\n'), mock.call(b'0\r\n\r\n')] yield from req.close() @asyncio.coroutine def test_data_stream_exc(loop): fut = helpers.create_future(loop) def gen(): yield b'binary data' yield from fut req = ClientRequest( 'POST', URL('http://python.org/'), data=gen(), loop=loop) assert req.chunked assert inspect.isgenerator(req.body) assert req.headers['TRANSFER-ENCODING'] == 'chunked' @asyncio.coroutine def exc(): yield from asyncio.sleep(0.01, loop=loop) fut.set_exception(ValueError) helpers.ensure_future(exc(), loop=loop) protocol = mock.Mock() resp = req.send(mock.Mock(), protocol) connection = mock.Mock() resp._connection = connection yield from req._writer assert connection.close.called assert protocol.set_exception.called yield from req.close() @asyncio.coroutine def test_data_stream_not_bytes(loop): @asyncio.coroutine def gen(): yield object() req = ClientRequest( 'POST', URL('http://python.org/'), data=gen(), loop=loop) protocol = mock.Mock() resp = req.send(mock.Mock(), protocol) yield from req._writer assert protocol.set_exception.called yield from req.close() resp.close() @asyncio.coroutine def test_data_stream_exc_chain(loop): fut = helpers.create_future(loop) def gen(): yield from fut req = ClientRequest('POST', URL('http://python.org/'), data=gen(), loop=loop) inner_exc = ValueError() @asyncio.coroutine def exc(): yield from asyncio.sleep(0.01, loop=loop) fut.set_exception(inner_exc) helpers.ensure_future(exc(), loop=loop) protocol = mock.Mock() resp = req.send(mock.Mock(), protocol) connection = mock.Mock() resp._connection = connection yield from req._writer assert connection.close.called assert protocol.set_exception.called outer_exc = protocol.set_exception.call_args[0][0] assert isinstance(outer_exc, aiohttp.ClientRequestError) assert inner_exc is outer_exc.__context__ assert inner_exc is outer_exc.__cause__ yield from req.close() @asyncio.coroutine def test_data_stream_continue(loop): def gen(): yield b'binary data' return b' result' req = ClientRequest( 'POST', URL('http://python.org/'), data=gen(), expect100=True, loop=loop) assert req.chunked assert inspect.isgenerator(req.body) def coro(): yield from asyncio.sleep(0.0001, loop=loop) req._continue.set_result(1) helpers.ensure_future(coro(), loop=loop) transport = mock.Mock() resp = req.send(transport, mock.Mock()) yield from req._writer assert transport.write.mock_calls[-2:] == [ mock.call(b'12\r\nbinary data result\r\n'), mock.call(b'0\r\n\r\n')] yield from req.close() resp.close() @asyncio.coroutine def test_data_continue(loop): req = ClientRequest( 'POST', URL('http://python.org/'), data=b'data', expect100=True, loop=loop) def coro(): yield from asyncio.sleep(0.0001, loop=loop) req._continue.set_result(1) helpers.ensure_future(coro(), loop=loop) transport = mock.Mock() resp = req.send(transport, mock.Mock()) assert 1 == len(transport.write.mock_calls) yield from req._writer assert transport.write.mock_calls[-1] == mock.call(b'data') yield from req.close() resp.close() @asyncio.coroutine def test_close(loop): @asyncio.coroutine def gen(): yield from asyncio.sleep(0.00001, loop=loop) return b'result' req = ClientRequest( 'POST', URL('http://python.org/'), data=gen(), loop=loop) transport = mock.Mock() resp = req.send(transport, mock.Mock()) yield from req.close() assert transport.write.mock_calls[-2:] == [ mock.call(b'6\r\nresult\r\n'), mock.call(b'0\r\n\r\n')] yield from req.close() resp.close() @asyncio.coroutine def test_custom_response_class(loop): class CustomResponse(ClientResponse): def read(self, decode=False): return 'customized!' req = ClientRequest( 'GET', URL('http://python.org/'), response_class=CustomResponse, loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert 'customized!' == resp.read() yield from req.close() resp.close() @asyncio.coroutine def test_terminate(loop): req = ClientRequest('get', URL('http://python.org'), loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert req._writer is not None writer = req._writer = mock.Mock() req.terminate() assert req._writer is None writer.cancel.assert_called_with() resp.close() def test_terminate_with_closed_loop(loop): req = ClientRequest('get', URL('http://python.org'), loop=loop) resp = req.send(mock.Mock(), mock.Mock()) assert req._writer is not None writer = req._writer = mock.Mock() loop.close() req.terminate() assert req._writer is None assert not writer.cancel.called resp.close() def test_terminate_without_writer(loop): req = ClientRequest('get', URL('http://python.org'), loop=loop) assert req._writer is None req.terminate() assert req._writer is None @asyncio.coroutine def test_custom_req_rep(loop): conn = None class CustomResponse(ClientResponse): @asyncio.coroutine def start(self, connection, read_until_eof=False): nonlocal conn conn = connection self.status = 123 self.reason = 'Test OK' self.headers = CIMultiDictProxy(CIMultiDict()) self.cookies = SimpleCookie() return called = False class CustomRequest(ClientRequest): def send(self, writer, reader): resp = self.response_class(self.method, self.url, writer=self._writer, continue100=self._continue) resp._post_init(self.loop) self.response = resp nonlocal called called = True return resp @asyncio.coroutine def create_connection(req): assert isinstance(req, CustomRequest) return mock.Mock(), mock.Mock() connector = BaseConnector(loop=loop) connector._create_connection = create_connection resp = yield from aiohttp.request( 'get', URL('http://example.com/path/to'), request_class=CustomRequest, response_class=CustomResponse, connector=connector, loop=loop) assert isinstance(resp, CustomResponse) assert called resp.close() conn.close() aiohttp-1.2.0/tests/test_web_request.py0000664000175000017500000002125513025134363021133 0ustar travistravis00000000000000import asyncio from collections import MutableMapping from unittest import mock import pytest from multidict import CIMultiDict, MultiDict from yarl import URL from aiohttp.protocol import HttpVersion from aiohttp.streams import StreamReader from aiohttp.test_utils import make_mocked_request @pytest.fixture def make_request(): return make_mocked_request def test_ctor(make_request): req = make_request('GET', '/path/to?a=1&b=2') assert 'GET' == req.method assert HttpVersion(1, 1) == req.version assert req.host is None assert '/path/to?a=1&b=2' == req.path_qs assert '/path/to' == req.path assert 'a=1&b=2' == req.query_string assert CIMultiDict() == req.headers assert () == req.raw_headers get = req.GET assert MultiDict([('a', '1'), ('b', '2')]) == get # second call should return the same object assert get is req.GET assert req.keep_alive # just make sure that all lines of make_mocked_request covered headers = CIMultiDict(FOO='bar') reader = mock.Mock() writer = mock.Mock() payload = mock.Mock() transport = mock.Mock() app = mock.Mock() req = make_request('GET', '/path/to?a=1&b=2', headers=headers, writer=writer, reader=reader, payload=payload, transport=transport, app=app) assert req.app is app assert req.content is payload assert req.transport is transport assert req._reader is reader assert req._writer is writer assert req.headers == headers assert req.raw_headers == ((b'Foo', b'bar'),) def test_doubleslashes(make_request): # NB: //foo/bar is an absolute URL with foo netloc and /bar path req = make_request('GET', '/bar//foo/') assert '/bar//foo/' == req.path def test_POST(make_request): req = make_request('POST', '/') with pytest.raises(RuntimeError): req.POST marker = object() req._post = marker assert req.POST is marker assert req.POST is marker def test_content_type_not_specified(make_request): req = make_request('Get', '/') assert 'application/octet-stream' == req.content_type def test_content_type_from_spec(make_request): req = make_request('Get', '/', CIMultiDict([('CONTENT-TYPE', 'application/json')])) assert 'application/json' == req.content_type def test_content_type_from_spec_with_charset(make_request): req = make_request( 'Get', '/', CIMultiDict([('CONTENT-TYPE', 'text/html; charset=UTF-8')])) assert 'text/html' == req.content_type assert 'UTF-8' == req.charset def test_calc_content_type_on_getting_charset(make_request): req = make_request( 'Get', '/', CIMultiDict([('CONTENT-TYPE', 'text/html; charset=UTF-8')])) assert 'UTF-8' == req.charset assert 'text/html' == req.content_type def test_urlencoded_querystring(make_request): req = make_request('GET', '/yandsearch?text=%D1%82%D0%B5%D0%BA%D1%81%D1%82') assert {'text': 'текст'} == req.GET def test_non_ascii_path(make_request): req = make_request('GET', '/путь') assert '/путь' == req.path def test_non_ascii_raw_path(make_request): req = make_request('GET', '/путь') assert '/%D0%BF%D1%83%D1%82%D1%8C' == req.raw_path def test_content_length(make_request): req = make_request('Get', '/', CIMultiDict([('CONTENT-LENGTH', '123')])) assert 123 == req.content_length def test_non_keepalive_on_http10(make_request): req = make_request('GET', '/', version=HttpVersion(1, 0)) assert not req.keep_alive def test_non_keepalive_on_closing(make_request): req = make_request('GET', '/', closing=True) assert not req.keep_alive @asyncio.coroutine def test_call_POST_on_GET_request(make_request): req = make_request('GET', '/') ret = yield from req.post() assert CIMultiDict() == ret @asyncio.coroutine def test_call_POST_on_weird_content_type(make_request): req = make_request( 'POST', '/', headers=CIMultiDict({'CONTENT-TYPE': 'something/weird'})) ret = yield from req.post() assert CIMultiDict() == ret @asyncio.coroutine def test_call_POST_twice(make_request): req = make_request('GET', '/') ret1 = yield from req.post() ret2 = yield from req.post() assert ret1 is ret2 def test_no_request_cookies(make_request): req = make_request('GET', '/') assert req.cookies == {} cookies = req.cookies assert cookies is req.cookies def test_request_cookie(make_request): headers = CIMultiDict(COOKIE='cookie1=value1; cookie2=value2') req = make_request('GET', '/', headers=headers) assert req.cookies == {'cookie1': 'value1', 'cookie2': 'value2'} def test_request_cookie__set_item(make_request): headers = CIMultiDict(COOKIE='name=value') req = make_request('GET', '/', headers=headers) assert req.cookies == {'name': 'value'} with pytest.raises(TypeError): req.cookies['my'] = 'value' def test_match_info(make_request): req = make_request('GET', '/') assert req._match_info is req.match_info def test_request_is_mutable_mapping(make_request): req = make_request('GET', '/') assert isinstance(req, MutableMapping) req['key'] = 'value' assert 'value' == req['key'] def test_request_delitem(make_request): req = make_request('GET', '/') req['key'] = 'value' assert 'value' == req['key'] del req['key'] assert 'key' not in req def test_request_len(make_request): req = make_request('GET', '/') assert len(req) == 0 req['key'] = 'value' assert len(req) == 1 def test_request_iter(make_request): req = make_request('GET', '/') req['key'] = 'value' req['key2'] = 'value2' assert set(req) == {'key', 'key2'} def test___repr__(make_request): req = make_request('GET', '/path/to') assert "" == repr(req) def test___repr___non_ascii_path(make_request): req = make_request('GET', '/path/\U0001f415\U0001f308') assert "" == repr(req) def test_http_scheme(make_request): req = make_request('GET', '/') assert "http" == req.scheme def test_https_scheme_by_ssl_transport(make_request): req = make_request('GET', '/', sslcontext=True) assert "https" == req.scheme def test_https_scheme_by_secure_proxy_ssl_header(make_request): req = make_request('GET', '/', secure_proxy_ssl_header=('X-HEADER', '1'), headers=CIMultiDict({'X-HEADER': '1'})) assert "https" == req.scheme def test_https_scheme_by_secure_proxy_ssl_header_false_test(make_request): req = make_request('GET', '/', secure_proxy_ssl_header=('X-HEADER', '1'), headers=CIMultiDict({'X-HEADER': '0'})) assert "http" == req.scheme def test_raw_headers(make_request): req = make_request('GET', '/', headers=CIMultiDict({'X-HEADER': 'aaa'})) assert req.raw_headers == ((b'X-Header', b'aaa'),) def test_rel_url(make_request): req = make_request('GET', '/path') assert URL('/path') == req.rel_url def test_url_url(make_request): req = make_request('GET', '/path', headers={'HOST': 'example.com'}) assert URL('http://example.com/path') == req.url def test_clone(): req = make_mocked_request('GET', '/path') req2 = req.clone() assert req2.method == 'GET' assert req2.rel_url == URL('/path') def test_clone_method(): req = make_mocked_request('GET', '/path') req2 = req.clone(method='POST') assert req2.method == 'POST' assert req2.rel_url == URL('/path') def test_clone_rel_url(): req = make_mocked_request('GET', '/path') req2 = req.clone(rel_url=URL('/path2')) assert req2.rel_url == URL('/path2') def test_clone_rel_url_str(): req = make_mocked_request('GET', '/path') req2 = req.clone(rel_url='/path2') assert req2.rel_url == URL('/path2') def test_clone_headers(): req = make_mocked_request('GET', '/path', headers={'A': 'B'}) req2 = req.clone(headers=CIMultiDict({'B': 'C'})) assert req2.headers == CIMultiDict({'B': 'C'}) assert req2.raw_headers == ((b'B', b'C'),) def test_clone_headers_dict(): req = make_mocked_request('GET', '/path', headers={'A': 'B'}) req2 = req.clone(headers={'B': 'C'}) assert req2.headers == CIMultiDict({'B': 'C'}) assert req2.raw_headers == ((b'B', b'C'),) @asyncio.coroutine def test_cannot_clone_after_read(loop): payload = StreamReader(loop=loop) payload.feed_data(b'data') payload.feed_eof() req = make_mocked_request('GET', '/path', payload=payload) yield from req.read() with pytest.raises(RuntimeError): req.clone() aiohttp-1.2.0/tests/software_development_in_picture.jpg0000664000175000017500000021744613025134363024365 0ustar travistravis00000000000000+ExifII*(2  i" CanonCanon PowerShot A710 IS2008:09:25 09:16:45 V^0220fz    |L 0100  2008:06:25 18:51:552008:06:25 18:51:55  .4<"DU   &04E"F # '(  \@t 9D@ts @IMG:PowerShot AS JPEGFirmware Vsion 1.00[YQ>"KlO^YO^ /0//(,Yl[Pi  pk` )))))))))***1 Uʰp x ( C      C  x" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?tBS EY6v:2)K?6)çj!]f-<дȤ#Y1Z2uZA?*ֲb@B~\Wmj[HAW|5e&'H4Ojn&T 0O>,;g>ҮvJ 3'ԛ[@LVcEKkhK4%:}JpvoEaK[cN[IX>nOle@2y#tz(>7r}3ӛ#kˉeRp7Hzxt[N}3ֽ/ږדkdb%hSzExf;9/`tS}+ +S>p6:5vZHX l=l5iLbqשVK ]oU74J=uwr6=Ҿh {Wn_~j iE@' U9>n= 9gT-bLˉs `A2ΐ4U>fTV94AנR 잵Csb-DI\/_/ I]6>z3L"`fOƣػMմIKl@z% H'q_)ay$w }<Xt}OI$NĒNͰc)'qc C $Sмvd7jY`715fG[XZY/ $g3#qNk9&ei)8CB4ȭEEx3G#!W^=U%]@I{x5KF<(TD?|uƒyLo!eb<n>X2)TӦsy${_隹o2@HZ)-Z_*$6Q2'Kw`#(hx2gVj*>ֹ5 0pThǘ%pTƍ-pۡkGB1 ixYUOVasԒ>Z9[G]f״i(R&32ʁ9ozƿJIqn.7,O(3Ӿ3<(‡}!nFvo[WP6N`o.2{@B?f5;ԎkR[Y?wn uXԏ@գk؂VFhn R% aU{*|ke6Q 'pwpׇCW͊ qp%!#Or4ч0F9'*3a]_sW($sse{eYѱ xB{t棴%_&9?g >!i"#S.pMv-NI~ ][-wC$-as k |BQO %zyH3O355OXT㑈FyA+l<|洳"55PFsEd'`Gi2y \vlylO`lA%̹aK:Ϣ)s8ߩmw٣G~KPe]sž'7mݴo3 )Md 73_7:N\0#ߊw7kώj}+}{3鶤61<:5<<V)Q~ikҮkm*>pxki (Ow?5X p 봗'%8*W %|ik{i5Z/_ZMKNj nGoJ[Hp#V=Wivڎfdb Edp?|KxC\fyg:M݌+)F mEQ[hٳc``iCd./N-wǡ&i51Ls%X҄ҒێG~Vp,=3G;]Mb|1s]qŠ,4XtKx#dmʭ,[ Ցy89~g|.JȾ}:!Ocyg=:E__oeGnN9/ؑOuz]JH0Mx3,~(Q*#f ¢qkG \ISVOz6ءVl`߼0("`O{BtC2%<3Gj64YD?gszZ5k>DoyFU;ź8k"XxOBHu8 3_9QǞI&z8&쭧ύ|iKM5l<=GR Hpyxk.tzfF;yܿFjhp4giRDǧ /=+υoSeeT@pHڤ GoՌFw>= Rj3[&FA[K;uu3a\mm,<.x[LУ_ ?cp8X|;cfUJ<<^"J~>hKHmyyu EO b^+uZB9YmdgİeܜNOξi2xZ - HԲ ?/s_Q~V~ѵã nỆ)QwHҢu8s"=קZi1۬[A,oh0.:OqNp*3O1{E~;?}?*I]^lhTؿ,2+? 46^;OMO浭WOԮ;Gi[!d q C793ÿ4ăR㽲 I4ڹχ,hn/r GEP~^֯,GbG;NPh"׮13H:ɑNzj56ka17-zW}5MX+Y_? 䟧J^eu{R Y#j6]oy6Kbp9<87?]`4mE*1峃޹yn#[}!~~ASnjkr«N8?NUSՄ,.eK$+1bP=g(FdgȮŽp [3VյՔ1 T۔i#9csW2 y43%R]KmJ^/|i䏛>,i yeaY-bA8+&ЙdIUfԊ_x,X4̨x\z+b+j^5y=`ѥ ͦ_>^bcPFiq57`3?:+|mƣe-Ryt/[Xbۊ^F6-VruM K3ӧj6tdr T!GGj,-cݭm!FqEߞ1}>hfX+Fg7x.Hw#*H#>1 ׈^4,|gp8#$zry:C  !"$"$C" N !1AQa"q2#BRbr$3CS4s%Dc&5Td+!1AQ"aq2B#3Rb ?/J(4@U  0MHSZqKPq@Q@!N))4BqN)P!@SQ5 A(<hОTƀ@"(*Y 4f4N(3D T TJf6hȡ-CPM494R4SfFP h -, hP OL)4Ƒ=iS*5FjEju(@84`QPELE bqBM&4Dfh&6iP *T4٦4$Mj>hjbq@ U74K4M&48(@THFP=*j,W1>uUiq c}R. @yѨ%X)5ƐP ӊ*Q9zjNhЃ Q4$PN)(",P 4DS6cG%@@&jC@iMY*TJK4fhsJ*cMY6iC@4n PsJT)lƦ"C$%M>ޕ.)3F"1B |Px]ME#IbXTşDүFJ~mj=Ц{=y5j^k7?n '|L=>-c#r7#F>>CRK:68Gfb۷}C>j;S[jk6AJih͞k>_MhY\cЀqҴSnh=ձL?e(Cvk:{`O?:Y(Ԣᵋi/itx襖Ji425{3Sht6:J5(Im-n}r5)4K4,x"lԽM P1怊i 4J€F(lӚրv3NjTDRR4A*hD5Y;CVpGj)`<|h?Nj<.%(@U0W~=YTEGx<{C[hc4[th5  ؗh5 [2Her9V#yW&h@ T)#:jwV/We'?g5[` "k 7domUH/y skgsLk-EXO(Cڃjw>y3^C]ne#-Fi[]jdπ̞x_nh:o_>;61،#,WyU}]pvo\u0wW<>Xrw n֏eZͰlǏ+c8@$W>OCn.XV,s^ٽ1`wGe#>lml3%ݶ.*;RMlw 7'*+#pQ |>OUSSRzʍrQY^ 1G]Շ*kν[{(t>kU(GkyP{AO52IGƴ"yV'ݱ]ݑ _i3B\bsxW ƅ|o;vi t]Oִe:#[Z挼,-5y0MAcr]٫>˨*F^9/yJh&S"j) yVMOJ>)P XjZbij sMSRMVjsOMBLZ |PD ˜:DҠz3*Tu$SY._X8 6DA)yF+~$4{FfuIQM|=Eҵ˻^ʲIL2]&ڬ[<1\Snvuݳ?\7ּ_d5m^OKYAwq$x:+;uY!:Ich=bh5=4s)@5_7ְVԦdZ018_nioٯeܬYKlxx3kڽΧu,]NMFJNVe<#VY/&wG>֪FR|!MYV$/?α9RVͽM$"Pp°¶q(I@c=T-ca#R^C>+M-5;WK88^3ЕGRLN㗕_TȒaOR-'E^We>m7>Csu$G&妺%N={GVK?tӬ=+/^R +ubl G+{Sj10{d#?jMup>cfhYMiw.Kx[&$Wf$KmE/c -ǏײS9Attӆ=I籷0nR.Sw k\vN,069m4 yϝtqvKr1pOQx:q Ρɂ5# ocl\u]ǩ DFCǕ8L,R* T(4ƈГ4FƁHhBh6(#DQ7$zRWe/gYB >j,fK&BSN=i8@rٗ`5Z]Gl;gHb|IL^ڟ>ڛ/M,2)"<⾠lii]}طrGQ9ˣ<[u.Y\_FѺ,l뵝J+u DIgkb^ @u;M7O/#,*($cJc.5<Foq۵j}RΨy5ʑ*$G_4ln,s['I+д™[D8 a;DX`A ?!|Ei44{hL.㟉Asu\XK2B0isJQ٭tm5/Ϟʱ'=m=O<|V frjMo%pX}'UFg(W}o:Cu!Lc${ƭ&|jRr`rV׀=bwӬߏݍԊӻ=j H=7~cZzhV41L9j׵2-qe\מ̶֪@4KPdI,AO³~"*,;.{*mAav_V>y-+}yCӠEԛUT̿hƥE-qR~t8 K#;HX!Lc9t5qpSNXwAYZZt m}shy+ {L|wxžΣoMu+vЉ8]:kN@UOgu}w0ѴDxEZm+fKdG>Ѯ#b?QU5g#v#ojͱlTS_i?*2{FU59e'4]\ޱ?ϟivʩ.*m/>*iuɖDpHZyF'.0Ok2+? t;#VYxp9…lM/%ɽlw\K!_6 \<^{Yg|Or}(,\Mg+_~NmKHj*ָۚh L~<`@99}qVHgb?9<5`}S]e4zvs#`VE,ӊ!@`i@i:W~Vv:YW`}9Q^+Ŀk^kB>cAF!>F%h]3koK]gO즇|fUeS/SU& 1ēzsVn.bPۋ@iM7jC1@ƽ BmaE{3ޘ;Jcā?JtI-qk]N8b',xכ,!R[!Hlȡx@Eug[}RM'|h^8>{5M-᏷#6]O$ڝͲ8eP? N,-{yt U1vz=Ngs:dͣj(n~xq9z:sZ.V<|\Ƨ}?Y7=[q[?e" &uǸtGm 2]WK5mkvQοlNH[T< ]}>KNjj-6$l=]]b(U Jy5l`;*7CaZ\kp4(6w;{}rRH;ܽOҪ ,4IJ ۟VjF;^8;>!z=k&d[msɿ(A*[T; W$!gW~Xִ;a=<3'֫ieqk$7.GQEF> ;ϞVvn|U=ә[ֈYc֝vqo[:gǚ)< =ZS/Q⤵u39gh皸nnОfs>}O¤ 5z~ Fݜʖ Y$[Z-!c(U;ueo(;=ֶY$P0ۧ?dIc|ti4R6%]^Ps0TOC%m$P` or(gœ ´Y/dS޺Q+%`8LҴr+eƒǝz"qze#̼).a`H9hxYg8dR哷8oh}h@}7慮lՁMӛJSIabܻ@F?(Yuom_<5L>ýfsW $g8; JIOO(Yι*όcZ=% 6SΜi9aX5ckmpq D;)rmÛW>G$N D NZWU?*;ZOhlIC{V`W5H~TO/ռ? SH^&<}(>͏'j:%έ+^TH`W~>ufj=ౖ+{KiąB6$r<<+a3Hb4>mCZ20ӁD (Xb#4F 8zB`)D)6Z.)R "*=)U) =BY(),M6h|iz)fTR(>ͻG7ڕރʺ'$kmgԻrYM4jW}ы>GzʱfΗoxY%el>uP#s82l~=OZJ-Ȓv7R I攗f u1*N)(AG]>+wsgdunr|S u|mQ >K 82yd''erG/9̇ܽs;[iրMw)s|q^jᮀDz9fVi""Y3迅O&FrjZc XO"Qx5vR[^K:[Gu:Eh~F>xp=v Ux4&{2Eb仆MBR[ql,T<:x[#e.Y 6UH99p*ZKgLKF{3j[,`;Ul[{)#HCۜ>=Y/iVG4O5̑<6Nd[iN=\{> p<@wANķR-oMk`5b}A: pŤ<QBm U֦Aj[[rqjy B̦R]dLJ`,s|%oEZ)=VA+-&P@ٟ55{ UD=)Qy=Fh2#mj[#2+0x'S r$?JV ۇέ,aDbE9j0'ҮE FmKΨD铇ꁸ1?>ol{2]FOǻ[ےHU`Ю^dӠ`sՉѺ!&l&x"qNM6i@554 juQ- H ӓLh4=*sJJJ4 ҨABM6h),OCif:q҃4\oIf;3u>pm?&8[7VVrLwcx͝5CNdxAVc$KQrۻk]󭕃\gCKL:ً|_f+`Υ,o5W!Oκ7}gt6[a"=]Xy;govɑVa #mMG{ivKn%7ݢe^C<{^|8N5KH(y tTBq^YK=u fWWA$@z }?Q%4 #LxϥqY_J{s0{椿%[g P`u=B䏼 s ¼lmo(yX'Mի:]S^ ]1<;ch/O3I{vPSJ5}^0bUOgpORǦC '|TK)`٤ilAD4Vߨ=G *n{ӬݮycQ, l5kٓKIi1被T[u(tDPF:ƉOƆMcP]B\翟*?ZNcpZ\2^ T:6Hfr0۹?=nᤓT%=SX矝hMqgmIm`>^> 뺊J}:]zV,=cn${zIHF }4M77S e}ڍ\HZ[A:E/ty.  5˛Kt#v;ahG-qmiqޝJ[7r!BX~g㼛w2nbٻmZ{ֺΘgPkw:+R#1{g)-K1. fouT^cbr8*Da-®z.0>7SlW\+tK*(42^ty>1UHSb'H;W#đTȚLl `֦alN~Xmϥ4edxҫ a/十b1U濸9նԖFv{ FlC|8P!bq1(4BųvIB睬PQG4˨\tT/Bw(ckCGRVF˨ڗ }>bk8XO ]!a1_r}eqSa%a9wj\`rA8Z]ܚB4 (Z,@8SP(M=* "SziZbh"9ԩ)M*if-j< Y$,fh@K&ZY4CT)_~qecgA82n%/6 :ƤKF )^ -'LԮ-./`Nݤ\CXPrf}i}մH}Rq 8%^K:̐ǴvAe]?yҦ^f*9la4Gl~S"7$n+Ο} EiCsqd{Qai. ÐBQd4{3ҫ-֭qL0,Z lڭ_Hȗk:*7Zbҭ䝲`2||j[nͽYnQu~UHZMVǹ>톭.`ӣ'wqO lVs,Iu)Hh2B/<: ihܺ] !,k06,Gʯ~@iK}y&|X~-hѶ g,}y5AuVd#ao0g; ҥjcN *LԩaR峞U>8՝NOF2*M_Q&=&Ni}zv]qM[q_}UYԤH幟`zOQHyHpIɎ2UGǯZͤXDѤDDn>}AC^ڂ Nj,45%YQ1p+wU$FO{J?E=xӥrױ .2rrKq׎+-p `G<\@#R=P¸&RGo;89G҈ۦ#K|fPB{PSp(9hI?SղZ t¨˭5"})A{Bk 2ꑁ8:.7ex S^CTS=r F4f":41DBͦ7 d FW1#φr8 R}bU(TN@5nl-wV2o'>ycDžU}Y[0jJhEzYT N9FhEJMc|J`/5t.hNtȫ󨞀 T$Ҡ2ZiB0JY84@it聠N(3OYGivcl2sH5'cmΛ^6; p-:5h }_fٯa8ߖ9tԎhj} c EŽȈ#,'}9y_4i~1~ y Dž}+QgG:52dǂ}q5gmJsČf!UݛQ 7wLz9Q.Uke# }9#=ib2Iy18 [*]v7L0##}渝Sh^[ibxmQz$J?ߞMfCw_MixA<|[Ѭ,IB2͏ք[}ypÄ<gemZKg0/ϩVE$Eϲ }qr5iF`?Z=;J&t9 xv*VJv]>[RA;}D֚{/xߎ[/a( -~HvqYd*gm3Ϋ{FKʢ:ঝ ܺ Bx3_ͅ_Ԛn銿zbdVxaBǿ)m6^6֖` zqS0wCgI5ǘ'5>,R5cEfv s|:b.#T6i,}lrq:w2(6|:AV3B|ɮ#XXmJr ]2Z1Ņbqu5e!UK򫎲=p}YQ|ہLe@3]L@ RҰfRæ@5$m!;]n@?J8vF0Q$Tg ɧC* ㏟n 9m^(>"{,.* aEk27mWĮkR1j[ܫ] x}*a '>|Q-%BSbTp=OV\~ǗZ JGz5U )Qp6=5W TgPiĞ=ef|%1`߇?;E/%Tv!9ǁs_*{Ybc%9ӿ azŊ?2_UG904j3] SLiqNǥNj>h4T<(Qv^("e5"Q-,4RSb*rNiP4@ >}h@CZY54@I)QgO$>j0$H $Ciׁ} oB2?#R^_Ino}y-=+'qLMZBe8 W֡~m`O!ߓ {m;HYdY'=9S׏"b4*y5bKg{dM0}X~^kcqm5 ,i>j{6d ?\V]4>q6?}caiux|[zֵ$pz{؏Pݠ2agD4{TNSiƹ'':\m2R? ' W>҂ Htf-scV]/^CN='SU EE>ӳzҖ=63y+{״a}p+&X`.zŠ7Ċ("Y 2x0>#Mڟ^5٦YK4c[ٌz³{xuGu6$(K<} rchs%^e5у-R|I~lhk)l~FH*LÓ}p,ԖM. H .`]ol"կc[mqYvq8>ҹ,$NFNo <:ltc%#~9D,]ob@ǚ-&Q&jzp$sǦ X7WͰϟ:0%9 X@o`{?ؽghaKvώ0W u}$22 w<{bl;Aԅɽ1^U]>^2KR')8(iqN1LbjE&r:Єy qOtI7A*<5 ~(lfJ@ZJu*sAw42LυBu.l@M j@}iQsN .|Q@iADB1/> av?ZLל(d0O?ϜmbY;,4qXqvJ{/zu`cW}i=5@^V0O:)l{; OJiìKxB #\m#Ҿ縍?y_6縷]Ǔ\i<-G@h˟yhtk!^M$fY y/S_?0kmJ\{ sY"VUf]*IimE(KtFwv`>*};Gaoij Qrܫ9Y㲍m|RE%6^O5Woa|$K=~ہ5<ʔڜ -6Km|E 1nep3c0bCa`(}u{"vZnǞb$s|*$Gr~.ed}䞴MtU=Qc}^4NC Es3@98=ɒ@-ǠZ3VGS+o 2^CųQmis$;-g!Yj789م-mcW>|Z2{SZ3K=$GQW%Ik ]_;rv]:6ovF=~5]f.uRM.J)g>g9I; '<҉~Xߴ.j{8],zZ9ٮQM5-)bmsg5Y]g?.%\2> QB&OǨ۫E9P9 s!MϳӨ⧊M5S !GҥOn͞FSM,Űf>Zd&mU[NG|D-G6uu9/'!@<ӟWfm#kQ#7_ [&$U39nsx)ʁWFf`B|-Gփn9؁7S{Wa~MVfY[O&"*w c?^' n=fP~`שW2VS@V~OtQf0xK4Bh) Pl愚lP>Q/Z:@}iQNM 4,94%f BNJ!)UZUAZCj74`HjE}z&5ܸX#y|^5DOPqo8~XF8#È*m_}m qhvI^]d<ZB25 4nft*ݟf?Ԝ4}/scF[qt;O񵽧?TQ~8u; =1qu\AN4m&Eƣ;R}~ڏimP1#GbHOp[HۏcS3"O)cJ[n6XEWv/^O:]ok6$t^FOW& =\6譢0Φ56OKx`|s׏OvͬowaEkm4;ZH$Fd yٸ4+#K24hѣ6FN)f ~h:Ɨd#Jf :W}XQ}iIwFv^y;2j}ċ)Ǔy͙ueDQy8KX2 vw5 ot-m]x!Hyzy#[5d-.[d`y+ե=9Lג>5m5-6.`8rjiIcղ4€Tׂ}Xj-R 1wp7c~sZPyV(أBLą?:6y])e&<0FPߝ[:^hBJF]Fw u[Y#B-;Fv8]#@@Ғ@TRn1+AfR/m(}Rǟ 5'V"dv<2_]V:l$Rp1#J[OFj?9JOw5 $1q€s6  XUW?EothD%g i]GEϖ%'`SccW wd:"㨗< d㾜g2~y_#JGn;yXwl*sO ) ;`rF2)U?e[ƺ$R\Rƥxcz/TѤ&J\8 5a%D ٧P(GzK5)n$n*=%@PLO4٠ 4ŨIcГJ9ϠH|Ҫp!FP }I4@ `prhG M Pin/1o ރuGa&isQKw4)>[=K[&e@|}κMFq@ ~q^+NQ3^|8u_[ w ry#&}잧}]wxlH<(nҧOXn(i3 H;=༺h,y;p9-*dZѸ== Dr x^VMh>a>k:I5v۝j]]ٽ 'hf &|3:tv9Hn5VG[ka`vU^ip5)o'-Ut-)kݬeK3&vV hu;e>s⶯N=vL{m. (ɉ}Ʊ]lkURO}_Z="mR~BA/<84,x * s[c^kWCuvPm?JVb:Z}wRf#HHIǘ'*%SɇLz*v(:9) %QI'Y=zuY#,pp'9fgEڌƀ=Oưu>Zq+K&yϥT? 7ޕ(u>hv- Bz,B XynGҞI vϯҥ{*E[Y),BVPTc,sǼO)kwc 6f+IG qZi HlrZMѦ{+.5NHWy#9'К3 m ,n 7Q%,Q4 d4@`4 6iU4s dPf>lM;Tain=h Q X4sT8S=Ǎ.3EfSրl. e1m{8Y"no>5'd{']yB-^yakm>m@ʨM:=C#G ̥Zq=ޥ۹'b@AF.je`3SWI?bh_FmQĢ3<'^u>[=-; ϸbf#.NN V-8b0>O֣_K].HJRA~ƢÓjufy'0rI j1l =m(Vki}c&Y9sI'CQOoкh;%`ۦ]VekD_GqE_I)bu=[ Q $cː>m-2۸$b BO`M.MQZa& ϟ5V35>$ ʤ J1Y*}8/JT䟁%Cз qp *xͱ;;>q­YAEt<PTi&ċQ} 9 qV/Tڳ!8=L&ʍs|\x~vЗ֬IBlܺ)!w 6<,͚J /#{ip0/"PzȫӸ`zeN͏Yj#:BhUC AiCGBh0SN΀|6pvzד}[?h饊EX2 apa-% e#vFA'-핕%zd^^<'kOi&m,L8DA}1V,J,X[ݨxďeeCdϞ[Yzmv\ެrL2eJX̒7Nߋ_hiNⴷEo74ɥ牤J֞g9v6р5vPUf8@|r=i:FKݫg#>>%DXmyӥ)1";\* r<wEk] c D 2\H_?*pZ?d\LPTFm.qpHOƫ#1>r$ XBjO{%25P$?*Z#ȬǸk=]Wv}Мww-Hd4{oN+gv(vw%CLbm1:x3=QR/Js8ic5S,q@8Ԩ3@\У"1PA@ԤfnhE L@AҕX(3J9$O Q\Q&,9OG*hxSwGʜFHTYcKn|* *犕UbrE T -Q0:Qh p'eqiww[e$,O\~u<*ם/wk,qjOj=EGOatr]{QWgP0:Y}vmØA)>?*߱ U/v5Nq<2Ĉ^3fQol4֒um%G:Lx_-w_z*E>ƢoXl`M1}EWRuw; R Q:ӽսQ*/+*פH4>vFWg4Лo .Hr>뻷`e ,k+I#[Go:浃 A.xUQg%^H>ኢ"?oG3VMRY5ɛ,ZmFhzM6pDQǩk[vgWԴ &?3EEsE#OBߵmXu qdM4t3L{Z| ~G>b4Viviڭ-l-1gE?/ҹ;x5vCH Mdu&Bq[ }o$zU|*m}kR nSGU1 6w6%1(sz߲֒]?GK^{y=ψVoi[Aq"@>ffX_m}VDmYofէU'`l.GM:3nݣխ!]K{f+qzlUhxd Z<z{+O> Zt9@^+;#@a⾅4l]6y!]NiH޼ay<`S_8<ܱ`'f4?lB ,-(UOHMYхP+謱f)( 1H-JiT0qD5?fⅥU{>tNςր) {6܎XNjBe@sԅsHQ-=*,"yQxGjX Ԯ4ZN k&.R;X<?:ֶV=Ӯn9Wƴz٥i*=ݱ9(|֤61wqEy*a[iZ乖W[fnvo\VBүzu)9! ϪH ~[{;v WĽVj[GKʹvxD=*[9X;9O.Ah`so"F}nBYn.c5mOF3b9mErkjhMSab{Ǒɭ^C@_jW ;q&ONX/\hKkZ2VurբCY[*LitݿZ.Pa#_e@W sژnQ@fdz'bۉ=[|J|W6V[$P0V j7oKNy hՋNjL^JlҴ$J 8*O²wq.mAoFtnZrT:coQյS*[v]߭;@,Iϣes,j:}ʆI}`qχCZ]C`.3w_cw[ّ! ɐNY-l}c XF ;E9N]{kfێCa8Eh-VKg?C^8с WQ (瞕fV=ymw9n8Կ}dQ!U:>Tcɣ$ iB3V 2B/? >lQ&ܻFh@;1M7&U={0l[_l6_$?Jx_RaZ#,g˞l[鶑elL`c j|r:1 і,~̓yỿh;K{C.- /ͬ->tBN9 D0;0kKsBi }#o]q g9Ƅa?!]Ndu P }ƢF< @+~h ;#Hu&j%fcsV|'i.@GN ,,k&$V^|j%2HfQP-S3Jg ?JlNQTLB7[??xO2Wx?#hc6qΣ)c-cЅ # ^:J>;"{)AZݥ _zi"g2KG<W:ˮ!6͜:1ooը/,r3&UP<8uٰڬw ]=.u `,h_q|Mvlw'by[md)ҭI ;{ۯ֯ SYד4\s%;ݔ>w.62~&+tHҭ1@RW=g>\2{}o9lP=:*i}cOqu> }kZ@ ۳{/QRKh7­E>+{O.а}"˹ק~om~BҍjvwX~kkF{8V8yZl_^*voMp`T*zGg;CIK/!ڧ6 NX"*{0i;Ϲ1$RG-P\IW >kn.+Nҡ_rS"@8#\hY٫BR(;c,ª%{7`JiE^Ϭ\wofJ=S]\j:㕎$zsך_R!Rx71+#@Ǵ:r<=+k-$E@}g #ZiѼmʪJNyclmaT#*$(8tY$y'oBGq.YQ9^ha*e1l$sǥ]흝:il@{7ǂ=+";( JSuz$}Pj)3yՅKªsQcSE,7BM$wt JsBUGAq7=tDH@ⴿ? 7X.OPr1Q9"aAc*x\ԲE6e'ԃ Jl?#8HqTPE! =94kō\8 l64D*F=')¹9-@*cS# BLrVB riRqUp%+2jս'b!eUT3p6R! *XfCg1_Cv\ QREkk2Uĉߕʋ$PG$yp gD*1@DBye ?zsTJ~(*|N>jntH%ρngbPoaG%gw^1X5#C*KdFOx{G#_ވ ?ƿpghVƟE;@$ޫATo*JJŦWEvCmV%-"}DaLJWG>߶v;xzpeٽpʴni|ȒM%~eK4/C v'8j]NNuk߱r0+>[Rel<#a\$ `8kCV-0#bpiX٤F"v$ i!;@e+oQ/cu9ǟʪֈ͍_}JV+2]ZFӴ|p6)nw1u^j1y~kl>2cq+w[I>ѸǴLtC|1{u{K[eYCUU11n"2#S ʨ<rz{WR# K{B+A{W,^.IȇjMo.sSV#`(-֊LܮPqVEA@3(-?dzD yQs1+T  ڦ3zf u{Dťqy2((# .gFTS*J[CXyFhZy+KJv3 [? B9'B/%̤d+U dGc)뚫 P:vh oK-=0stvDzs\;0/S$f+Wh_b&T2Hv=g.~^əZUfiaNq=<*њ^Ov!UP*=5'ݢ'{؊؎齒F=˨9Rz+ VFJX;*uܶSh ԲJ>NgA08f*p| 3fX‹hcq)'? S9^?1@0AR*B7x[XPyRoM*ˆjDҍ5dɬI0N), ՈsքK*HQm1֤^ 0\ x5.sTjx2'2EГrb[ c_}GPfmClj2UQ?_V`s_.v3nT$$-\W,3xl=){[g!z>fҞ-L|c_?:sGlPCʰ8d>j| x`nt31] ~^\ebwJz*"U#ξ/[};sVkM?7bZ~Tvo_ϲj=.]h~Y2p8C:s*ޢ잫OZԴ&7 @ G'ZܲQ8΍ڍCH+IZY]*I~:knc4'_t+dVx1dŋ=E9.}y;`2SJ3ٻs,6}Q7z_Ee u :{NIoEC`?Zl>`I%)p]*#׵m;I*[Okt^v/@A ̇+#Ll*Kb BĦr2qf;qca}=մ-MwUR}'sCֵx!'u80ک.k&XnJ^lq0dtT1idHz~Uv62 K#Zdڽ gX ˳Eb `$t(M S!N92HϡoSZİL,IbbXXGKl>MWAlqZY.K&s^;Z<[n{NqWv欭 ͔j?9IpKɋ6LsVDYQ=Ҩ䀕8N%:@&n{ SqlNPXc@"W;V 0rx'~Єc>ME Zԣ228 {e |6F~xŢXռ'_ "tT;[HXC36JnLy[vy\YTTm'Q!Q3m16_4^Gl!68ևfQT]AݜW7׋l7O$lU\~:uŇDJ%ޣ$N@ s땯{r;s91׉~b]f*<aFjh FmZWP6 >UeXtUIH?o-B@"rPN3ho>^ -u}¤ECy LMPNDr[=1p)wϏJA $y0Fj ixFz T pX}TAj`޴0\ K>Sgh 45=^{}HTJj :d^Idkg*Q(w^AEF  c**@1 0q,@hTh ޴Tɦ\N) !TtQ_,}#j_nw> _KZvoSݎWϹ d/:V<@+F>#E4M 񬑺daAl}۫ۤݗ^7K&䁟>#^5nXV,m^ St#w"K`JおGPm1jK'(؎iKMcix\f9lǾ }2[iomVלiޥ=<]w{?*3b^b`i>sy JGoGUui}}bIWiɭ[.kri:&6wHޣ~=ٮ[ڮyvu{[L;Wvݚ{J헦fEc:滺8u?Mޮ}`9͹]"^^w\P0J ԎeU=zچCfy{4@ڂ(BGj+;z xӴ>̎,j1jo &xQs kol:?J`){"+Eo쑜\gFڋy[i.́!mlrM:Lq@:Ufj,ws=r e"6'p_G=wsMt=;S-h1 L;wfpp^z[<{Va}xb Tdf'ׁQw67UɭxER{#8x2Ӄ?gG4>@TG2=*P_[HGW㓺C/lR@伪<:dr/cpHfl})ivTz(=l="'9A#R*cϗ!,QNݜV gO#b#4k kh\vRl|dgAY2>Be]}BI; yAQ;XR2E{i4Wz~w=ZGx#^N-a<&[]i-o}^Kq'#yMwWD1֘TPl1Dh)@*7 ]xu}_-υPҷMfچ4H$@cҮ=e4 (\)̑^d۞ϣ-EP&#ν'1bh7 }PNOj ZFA@KP8PƟ*;=jz[ύZsjF]67\qא~0=ϲ/6e1F=}?5ʝ@ K|5?m?=4F`@Wq/n-w8Qr{>ٸg_mg%O^\IF;7x?fR]_F1hʐapIW:u}5ԡS.Ѩ5̜׵D/ 1N@9nUlm-?ffҾl۸>%/mm{-03? AH;bGq2h=kk~ܶmԎUi1U{Vf?Wsvn_uPT\HYq!opSڋ[mm" qVbJdi_pؓ1Z_gU1gjWLrkǣ9vUv i&i@Xb$zU}gV%;s1-9  >UkEku &\{6:9D[{b95,TFCFj}k#Z`+Y@_Bd-\˹ Eelexֱqvvq~`3(\Zqj:rC+Oi"w$)\udT/bx>9F>8%Gsw{Ŕ9r/=avHsUyh_犝5M\{ōcM#/z !]nL8YH7S&jNJ "uK!>UTC_&uj =LnQr5NYoC4y{Z0;e;Eeޘ. y\p7J{hs_is%6c#Π0%Ʊwǟ,b0:ѳ'>\իn[pK`a gБ+'+hŞaAorL qoUQ쮣a Tᓃ/lj<|_+"jШ$s0+-Beqrbf|!LU @NyZppRAQfnahRI NW:Mh{_dPDB  7u9W,.P̏f 9g[^E M%#x#q\|Ϸtd:d=pm;r2qSOv֪ʪb'▋N-&|i^yqKBɧ>4]!&3?j;~=cjo}(ɟ<6l 7Bq ^i~f cR0@#7\ҪnwH#4[A< ݘ=Ƽ };i3gz׳mQg7gvZ;I60s\;7Դ|}}|trFsaxυf[[W`Ha/4nEm=մPD;zN3OkKFhuv*vPÁ^;4J̑)M̘t51ʩ$WZ9o H=嚏 $qJ{Xed'QJ%\$H'ҡKy.I6k,<3N1Sē-6:qMQ5ZLc^R3iHϵc²;ۼ@(ݯ \<5bGGes .tGʎ:t.F#M;`9@!F+񭤖Rr{&WtcPYdG2C,rn0~4ً1#dCB\YT>ƅYwuzV6I@PWb}ThNa4jMi}Q^CΩDV[1t:Ʀ}*DȄ YV2kkC(r6G*a0ir6.cφ3[ug-cAr`/w=yRv)@ [9d*[O2ٸ u3Ұ y6m?>pb[e)VIz2uǢvcIIk-SwX8s#U{;)ukspuV> W dp 9֢f`KduE?[oMkheFT{G=|+Lue[>{drdDc*H%I'kg^9ּZkMM"E wdg'xcֽAoH{M% jM.]Bv e5].3$h>F^[\G<<ʹU4]]jW vҰu#ʌqfF?ڊ*U;aَs@9C)W}hDQּvhDE|qî /hJ@#\$ҢKWҐ*+L;px=*hzc۽Wʼ}w\@u/.(8=9J.Рe _ 22?lbNL{ٵ{=jG1_}:a1ggFmj$oƱ@^U.Lk_>'^;ovɮbOԭBOܼjIǟnh#O_723^\.\s!#?:7d--,@3a$=r+!w5+7h,2~U܏^W*=zcVZ"ıDqj6Uzdu2ȷs=}Lml(=V>d蛾.ɅΫy-S03Y$Oyrڥm#u݉3 VgEagjAe<ꊈG!m3nu"VH,qGhh.[X?qV!֞2_^p.~#΋Q+9>.ʿNMF$MGvUFΑ+^F rUy~5bJlmY#s/Y+{y Ě֝ἑۊѧO;)V+Qs 7+4fj?A0P  zX, 28M~9>8">iEdod&r(c@8aDfib8R>w)J|JEXV}GxV7bahv'kq.#ךgt161 s!:lQm=rq.Ibi}.1%rDITP3 `HxSoxI 8߶H @A1vD38@g xYn&`!WqQC,zT:jS6⨬<@?Z0/1I8]ҪT7HP'NxX6Yy* sy6n@'9Ҹd@$Ϻq8௕hlcfhlH ۪76h]MrR^Pcg֌]Or =j]/RC4g|.Zɐ"-m7ʤ/VUmZ+9?X?Zt3&T"mݎ].{d|+}:ǨH32Br~uܬH#pp|+ǕpR[NgpBJ!+#ϻ[vڝ֝~⎣qOoVvsL缔qgԵEI-4E -&iFk@>m4{7j'4Ew_Vm'?ZCzL ?*g4I|kV>ϣ_SNG?թƒ 29 [)/LHʎd: `Q쀛@υKeb,s@d趻7w')a6eT[:ߕUmBHmqVBbwM,?ZN"BeS)f?3]6#* 鞔/#21hciǥک]ߝI Z+Dq3vfOJg&5Q5QpZR:e8XX7Wݴk1BiƢevwqM<-)W)Է sAw~̋q7>z9.iӮ$ʣkÚcz8My=hKB V1cͶyumXAbXzr,&* 1mlX=UIEk*B1U=z ?WJ -Ġlb4P<~u!$B% ʪ g}vIdohSLIܠ]Rq.>Z35ϐcߓ399Q襱mfYOR3@6tCݤ*~u'usdj?@(13ўLmU@|HQ1VFd|tL[#*(s>@2 X8w sHɕ# ѵc0lTݒbU?<|*MP-Qq¶dmHh?@ݴl'5+ms~#03 =_"*F=:">\)2E_Ez@@ox f 6iKiݨ^?JKȆ:cxb멄[lB Y p2# :&y[6x.dۃxqS]Rmkqֱ,nfL-^576O@I ָE}5ӮEYX:f'/nI[Hg^{hc*@DU>oC%ӻϲ韍zJ4p+9Y58/{]jW:S7*:+m'x[Î*+Gs"ʱ0c6gYjԯ{đv隐Fneֹ\C\Ĥn8V[iw*ؙtpHa {'u?έ2;^5 ݟ!>U#$W  uQ޸\dwU 0Zh-x`:G0#TuI W:ӊ`^+X/]}>D;N3Vn..!H]B E O/H}~u)^׃Sb`V\ҷtgIEoW\D||ɓzF\ f{*V0], Аz5pr  __5m gSNޤ/#<:V>f؞ΒZ)y-6sU;'A0#P'ֲdVۛPt`ܟPvY{+EC\i;EYD@ԙB1>jtVX/d qY:1q!I$/qs8#ʲųͥ1C[I)8tA:MG*! ^whs,v67nzW/s'~eTjcG\[h/vU4K! F#ኳ7NOJ?K|d[uTZ>ZluِI6;{`=3Ng!|h5M:v"Ɂ8>G>uAq&.gGgv;nbymvNhc%Ӵ3t1 ^}:UXc60T8#(w72@RѠ5}5[ADP8#?q,o<kK˙%tdS"H@=zW7en"=܀3]1ɉ#<*wwpK*k*9T,ʼnR .4N];7 ,zٛkG }b(!&m#x6ÏRE2bc|f!0o@^2Š SmBۜ[8.Jƾ{xn\$ [pwaB9>}Vyr0xg=|OrnfLҰ3@9SK ;ZضX.#Ҭ;q &)# ;HҖHs#:[2w` ϭmG"Ȯ' @[(H *hʸV\fK" ã1΋L 9ʫc-e`O\vo&E_-ojGm2yZT|ˆO95wQoA~uU&IDzx~SI6ǯJȬb5'P,x-!ڴ  D_j`mಯNO4i,hֵv[MfRŀ]X†@pOMA)NAU*l  I9YTm"M 4lxsEy/UFp!H>MN4Z\,ϖMp1ob(Pɰ$<Fy35&v'G,\lWF<nc3$#ݻ\ϝOcvΒ$sQK>@ p8N} 5 2įD _,!Z}7vpH0/!f1R՘ 9s.Dt+?K##׃9f]~ l(d WE:9ɦ/}5`NsNjԣVFm-; U)#=*|_.ѓXE_x 楏GMj@HkD8׊Q$ 8ggũo,4H-%!.[qU^l rGgPKcݞ:+ aJ@;'*ƤኧQӓPG|)y*y=?:rNv a#i В[T\,1Xs߻>ʝǎ5ܦ0+r{l{7SNV,?y~ҕ*8cp±eP@|x}Fr$LǦNޜuVxޓ%j` SLJg}V29rN^9C>T*;m0,sq^$i*1y)KH1|#<'Ucq"gwI70g䓖mՏL#(d W q\g #D98a #An%z \g7"JM3w 1vgֺG3tVoR2v!ˌu\KȠNXx{hK8@1ǟ?*Y퐩ܘg ]GezFW2:xZPqG O-4¥H#$χCuY$pCy^|ĩ8fvgDO9$mZ $^GO<Z3wm59[XX0:ٻ{"2E"Y a"K>?icWqTLn\!*bG G$9Ҋi-`@Ǻ0V.Tf@{!^}qz?xXԮ8mSZ@QU6֜yU^qѭxF*[ dyf>~Bāc|+?/)7"dn&R4r9?)H rASJRUFW񪧪/"ICB;yzխ]YIa#梈 .#V9eh *P6AQWƯ4{70O88D6oP#F;A&UWC[Ǧ7/`$x~p:zuǟJ Br|/RZM7.1uv{t^|vv'9 m'*qRwlFO uFzuyfV;J7բw}w68RqUk"l+k?Q@] |ތ(+Nx&x(\q򗴎B2v r|z-nI0,fOce/mѸ)C <|xzUtuNÑǭrK4,\gحd鎢(Y*%8^ֱZX" =T( {"pJ*=N*F6Mh9tYOv@\*˜?֪Dž$d#PJs+rG^Ef^WG[HnX#VV^ &N N=zֱ u+#ɰ1| &NWy?:\& :ziP,ýL8B2xʒ<5ddVE 3`KO6ݹpеG/vox'JetfcnS>[n6I!OfC_hf)*Sd#*P2Ƅ aqVb{&iTy91Ax' GnL2<xsVmdw`)9ˏJl=iJXrXLOO |x+ NU.Z32β oEH8Tnɰ0a1~tq]#P /R<1DD'/⍱ aUR&)8=1S1) ۆʫ(m'jŵh9o FUʦy}{d0'Z7JY]>Ҳ{2,krAU5*CU(eqP{n&g.:($IhY pFO6ic$jx5F2n\/cvh/fDnIᘯt"vT< }7\2G8}HOVr2Ie2.vrX/ :dpK>>nUmU^V @I8_* XUH'@54Hc ρA̼CtHGbvᙑF96J9?Ҁ:!|1@3.fdnݸUq/+&|VZ;[UsvKI sh{f%3SBdUA2ƒuڡR7P ,bw`GEgS|V4Ѭ+e)⥽%xpQO{cx+'?+vZP^íN)O_J%-تQvV}6[fNƴvF@U9jαʲt5,sΒɆ~UoVfX8/D%FDI6+G=OƳfomꥴ;!NO\?#ף~m3aqQV]WTwWđXXT i$J,VKyд&B̤DVfU^8~$c# &D #d㏆jzc$ jك y?t-H۸+e*ڃr$/ )ww;\g*yKYFf1.B"sӅZTuobO>93x}>P8 #ʪIc]1C/~ji+T>uURt=܌9 }}RCY m G\/I01'aj, m{9PndnA8?>] Ha*Cnd^\ s55(xG:JI=]NW ^6'~cg-N ,^O )U#@G'#zUE^d+aLLj>>84ZsЅS8g?:ԂUYi\&3RI;vM@o# :9qxkPj /sztyt-TtF8*Vo0{5QH$nQs+$Zט,HGeP:X/e!x񫶲biS#G^#8'2{4`xpS,p]3U{fOLdθ0BV58Mo*.K8|+ԬĴ7dmK ҦG9FsU}򓼌{R$ٻ"# ti1IeBG_Cʚwv~O0 aOe⧻8T4qHL{*ިHG|S8^}hy,n j+v*}r=9Gߵ<1_]ޚ짢Ӿgfȡ۽ 8#qZr*X|:GήiLg2+5R6N 1ta\gGU'Hhؘi-m0r]َ"g*aTx(љCM.dNẩToY{N ~H%)?֡\;FA9zu 3o*S"*Zw[&qݏwX2B8< [t$,dPW>#U;F;IVK[SΪp(f̹ b0}dv~%֣lLA90?t,&HQT98XQ3;U''M\3 c9n EVocKqI!2nW53Ԏw*HP2~g5|aC`Vx1e'o G:WMjXLHQznc^YfqjNU¾-V#G8=z1cT6yKJOh3H]|Ȣ{mDV d | ca$qo)#Ջ4KeӦ0q1xGwc'?JnH~bVdABt? i\,Qa"!y8>M-}E Xg+Jڠ\I6Wid >U]7vimq9%WΌG>9>wmnPPHQS\[VΟG=\yH̷h(1|fm,^F>@WF 1 9*&iǀIR 9+ke[Ts!i;^H>#š;،_aE@rΗ,}J>-VuEdl{Cp~b-fZ=.UT>#h)-#nq5i!`D=9} Mr\]Ho;z\Ѧb\[ H y۟ݻ["iÐq:cx-ض@'^3Sy8"8g?*sm!\˼dAe[KqVePi;? 5<^#A$v+mm{b)'>5I$v'eU ?<6o q;HAǐ}MHvʌmJ ƈc+ SnVL`;/"-L3s|>ЭϺ  *Oi֍ko}βF3ԃﮋ=&:ľ=N*gw#W\ƪ6q Ղ86U2Hْ5Vrru _h'ʧ0<[wuQzIp?;`I#o+lh+nꊄJU=MeW=܈p>=|JL̊ n݋m%G :V7l5veH9 xR,iG*$|` xF'ҧr]܄^#ϚYmDIfO_βCYk$f *9̃YRN{S^b.G FVԎe}!ϧ)Z#fw,2$(\4d#ysϿimV`s• `zhv$d{4sU'>84M+݌fkMwf;@aER20 <έYɾظq{Vo,Ŷ&"E8:KK.qԖ[Z#.N&'<`;q$M37@ı=?kS #DpOC4Jn.](b@o"X0`ǻOΩ3Gs,J7_dOheeR=y d]Ba:Φק:v)HpA1[b쵼Aʅ xV>j7c0Vd+W3#0mc\Zܤn0x=pA$|E^DG R*mH+《)jr=X*ekIo4aV#9}2kgM3[f؟Io~5r{ɣ)pU]o4HόS#^ iظ=qq,v+ݪ 콜vg#+!#8#劽c$ǼOwbm]f,Y3[q2Ii,xe pp?}IsfO$2~FqvZb58.Se}AT <{Lǜfѝ3֎q,R%ȊAϮ)Z4FR$%A % ÃfԨ7,n&YYl6?Qhx3LƧ(UI-$^#m/A;I pۤ]˅\$c9Qh^BFV.xa?5=`K"@UB9q~"=hS܎h>Y.m!{^xIKE$r?J4A ĔGCuw4!SGy$cF)j{{+B= z+'ImYK$L|#\2NOw20²NJ.B4eIJE=0vQJ8HnANHϧ_=$k^픕A WeBU##'E:FF$Љp@#j*IYh\mmFXG*sm ĨV1~|֞oAvb[@q,l3H01ϟ&$ʩt^9$Fn#U& I|&Kʥ}R|QvWXF=qo*V㑟N>*}B_j"{3FH0&2FiRqHr2Q 9Xx^:gƃ^Ĥ$*1km$ʉV@o{Vϸ`]}r?0~US]XftgfjF2T`xt[Z!']1Cc$ZxV@B\`e$ŤsvNn쥶1%:{VΧaS*.;a =|1ұXX<꥕8qk3)-wb=1(UKK -u@8UhK*$r #qV" 8^^t'%oj2bX;WZzu7Q\ći018O1v"{Sn}r9mR &&M2X{k9fe'm2{D`=Ml먱,HaXqJIky<>֯閶$ȁ$^MZɭ#ݶOL*m?OHxmqf?kDAB #}J=wlϸPt#G&':[eY S(}1FłUP77MЀ9~WՌdgB|VKlcE'=C y3+ {)  AH$gY$Cqs2Frʵye\ك' ưua\Č܀KnD W~.KDyP47R`yx!\-jvpeVC#;pzzXjK(+y$ /&$ βI m$)#ɭ q,)nm譜Ms./tE#B9#=OjKsӓFyN7Q<]hG1@9B$mc șyV[#zQgяzW)6ӤO@O@|V48Ody`ꗻ-#*O#_즨erH<`G#]`٬M9+STp%H$Pf yQsH  H5 ĝRlnΜ8l KggXQUBq3˲T;3"VB$HI)%c[ޑKqMfH-o\O?,bEys.?"ou[؞I7.q=)7*FyY\0v`p<@7!eR<BRN c 2G9>~5d-wr* 63ƌr2|~9ވbffy f ='?QWS}w"C<OAn Z.T$ q?[~Je]$rrp8hXnbH㞸韁Q\)vI ڒ2 {ԖE}q=N}ՖY#`[ tvc=3OU%4*9i䍃mǙ5;**Gm"jo"8`|1I&BI\{ c[h9,qQ\O_$B9y1S8I\cTa H$ ]E c\B5ۍvTyg)8gIw"]Fxj!GFbVX*D~2F{JS p`d3ҚM;ѻng?!YTj:w>VVn eg>*uHѲ'>Ute{%GEOO ~U,{dd=߱pOƤt60w{v dGƬFDA'|pqoOG.̲꫻j:БpdbJF9momBh\rYUf篙AqtUL 0kA}R霶8sKiIq,J<>U5H$y+;~E$<0'# 2ϵ# |+p#ߴ$gS9K8)꘎aݫs9xO Xǃ\ĝ,L)2S[†$JnUV'ql٠8"ȨtjSq- ~"ǧͩYۘn@E<qI.-&q28 Q1̽ ~NkXlJgeo@68YӴIn4!-Ӡ!Dq2}ٮ9argN ̂> Ҷ4AϺ:(VRKc‚ +1`~-}_ppʴ/[kX{$s<{ǾNU>w8%q'υe%VsQ#f"BfG_Cc  ڎ,q֘,2qF1\UњS paqr $`qѐr[=<)]#˪;i9X.n=*|Xr<0\K!U4׾)(3s1w%{z5,+s8bc?x@6VNdao3Ǻ]ۏx:c5P]%@ct[unF\1ѹfUZ+,0r1 ^~)v:w*\|S nЏ/uX>hz#}lF~tHy a|]8R"he\\(L8i2 I8B r>tKOl3}GڣKEB$둹׌M=hGBV%ĎW`6#=: 7xRvWPBWFk8"4jN!+cpU svā秠d^'D3N|=9!8Ei0ϓJ͹{~> {p`- IiH/~LD#jSXHų6P_ñ'A'Ĝy}6Hǩ-Cb "p6 uE$ڕH3a¹-V]E#p W[]h608 SyfYj#-:[ j/4*VuVUbĜ[>͛HoA$W͞؅;8?)Ow3珡m=Zwi,sVBmoFtB qoLE&sv-\iS֠ә"3WnC/uuh06a{d6KZ$aVU~zGNԫdF:\Γ-1݌Z"l:^+[]9γ,mbyUg%&esnZhYrXc<U'1BUcGXZFW s9PcvO=3Kmߕohw<<ֹ]j!yb!F3ypE\5 Iψ6QjYFGih$Yc oΕx8@V -&ܖRjRHnbrw ഏ%L0NѨ*d:]^݆R9,rwd$+cdz7wiؖR '9J)fd C ť"I&BK;V2,'tiOaf/u̻bR 4qsI㻁v{Cg (K}JSx "'-jGgN-p2X^"c]gVKf y0  *H OOqc/,+ 6"e[3Gp3W>VY6~e>G ҽ] ÷=8iR@SU l>H#ś[ܝy…:AW`V]$b velsaiohttp-1.2.0/tests/test_parser_buffer.py0000664000175000017500000001121313025134363021424 0ustar travistravis00000000000000from unittest import mock import pytest from aiohttp import errors, parsers @pytest.fixture def stream(): return mock.Mock() @pytest.fixture def buf(): return parsers.ParserBuffer() def test_feed_data(buf): buf.feed_data(b'') assert len(buf) == 0 buf.feed_data(b'data') assert len(buf) == 4 assert bytes(buf), b'data' def test_feed_data_after_exception(buf): buf.feed_data(b'data') exc = ValueError() buf.set_exception(exc) buf.feed_data(b'more') assert len(buf) == 4 assert bytes(buf) == b'data' def test_read_exc(buf): p = buf.read(3) next(p) p.send(b'1') exc = ValueError() buf.set_exception(exc) assert buf.exception() is exc with pytest.raises(ValueError): p.send(b'1') def test_read_exc_multiple(buf): p = buf.read(3) next(p) p.send(b'1') exc = ValueError() buf.set_exception(exc) assert buf.exception() is exc p = buf.read(3) with pytest.raises(ValueError): next(p) def test_read(buf): p = buf.read(3) next(p) p.send(b'1') try: p.send(b'234') except StopIteration as exc: res = exc.value assert res == b'123' assert b'4' == bytes(buf) def test_readsome(buf): p = buf.readsome(3) next(p) try: p.send(b'1') except StopIteration as exc: res = exc.value assert res == b'1' p = buf.readsome(2) next(p) try: p.send(b'234') except StopIteration as exc: res = exc.value assert res == b'23' assert b'4' == bytes(buf) def test_readsome_exc(buf): buf.set_exception(ValueError()) p = buf.readsome(3) with pytest.raises(ValueError): next(p) def test_wait(buf): p = buf.wait(3) next(p) p.send(b'1') try: p.send(b'234') except StopIteration as exc: res = exc.value assert res == b'123' assert b'1234' == bytes(buf) def test_wait_exc(buf): buf.set_exception(ValueError()) p = buf.wait(3) with pytest.raises(ValueError): next(p) def test_skip(buf): p = buf.skip(3) next(p) p.send(b'1') try: p.send(b'234') except StopIteration as exc: res = exc.value assert res is None assert b'4' == bytes(buf) def test_skip_exc(buf): buf.set_exception(ValueError()) p = buf.skip(3) with pytest.raises(ValueError): next(p) def test_readuntil_limit(buf): p = buf.readuntil(b'\n', 4) next(p) p.send(b'1') p.send(b'234') with pytest.raises(errors.LineLimitExceededParserError): p.send(b'5') def test_readuntil_limit2(buf): p = buf.readuntil(b'\n', 4) next(p) with pytest.raises(errors.LineLimitExceededParserError): p.send(b'12345\n6') def test_readuntil_limit3(buf): p = buf.readuntil(b'\n', 4) next(p) with pytest.raises(errors.LineLimitExceededParserError): p.send(b'12345\n6') def test_readuntil(buf): p = buf.readuntil(b'\n', 4) next(p) p.send(b'123') try: p.send(b'\n456') except StopIteration as exc: res = exc.value assert res == b'123\n' assert b'456' == bytes(buf) def test_readuntil_exc(buf): buf.set_exception(ValueError()) p = buf.readuntil(b'\n', 4) with pytest.raises(ValueError): next(p) def test_waituntil_limit(buf): p = buf.waituntil(b'\n', 4) next(p) p.send(b'1') p.send(b'234') with pytest.raises(errors.LineLimitExceededParserError): p.send(b'5') def test_waituntil_limit2(buf): p = buf.waituntil(b'\n', 4) next(p) with pytest.raises(errors.LineLimitExceededParserError): p.send(b'12345\n6') def test_waituntil_limit3(buf): p = buf.waituntil(b'\n', 4) next(p) with pytest.raises(errors.LineLimitExceededParserError): p.send(b'12345\n6') def test_waituntil(buf): p = buf.waituntil(b'\n', 4) next(p) p.send(b'123') try: p.send(b'\n456') except StopIteration as exc: res = exc.value assert res == b'123\n' assert b'123\n456' == bytes(buf) def test_waituntil_exc(buf): buf.set_exception(ValueError()) p = buf.waituntil(b'\n', 4) with pytest.raises(ValueError): next(p) def test_skipuntil(buf): p = buf.skipuntil(b'\n') next(p) p.send(b'123') try: p.send(b'\n456\n') except StopIteration: pass assert b'456\n' == bytes(buf) p = buf.skipuntil(b'\n') try: next(p) except StopIteration: pass assert b'' == bytes(buf) def test_skipuntil_exc(buf): buf.set_exception(ValueError()) p = buf.skipuntil(b'\n') with pytest.raises(ValueError): next(p) aiohttp-1.2.0/tests/test_client_ws.py0000664000175000017500000004103213025134363020570 0ustar travistravis00000000000000import asyncio import base64 import hashlib import os from unittest import mock import pytest import aiohttp from aiohttp import ClientWebSocketResponse, errors, hdrs, helpers from aiohttp._ws_impl import WS_KEY @pytest.fixture def key_data(): return os.urandom(16) @pytest.fixture def key(key_data): return base64.b64encode(key_data) @pytest.fixture def ws_key(key): return base64.b64encode(hashlib.sha1(key + WS_KEY).digest()).decode() @asyncio.coroutine def test_ws_connect(ws_key, loop, key_data): resp = mock.Mock() resp.status = 101 resp.headers = { hdrs.UPGRADE: hdrs.WEBSOCKET, hdrs.CONNECTION: hdrs.UPGRADE, hdrs.SEC_WEBSOCKET_ACCEPT: ws_key, hdrs.SEC_WEBSOCKET_PROTOCOL: 'chat' } with mock.patch('aiohttp.client.os') as m_os: with mock.patch('aiohttp.client.ClientSession.get') as m_req: m_os.urandom.return_value = key_data m_req.return_value = helpers.create_future(loop) m_req.return_value.set_result(resp) res = yield from aiohttp.ws_connect( 'http://test.org', protocols=('t1', 't2', 'chat'), loop=loop) assert isinstance(res, ClientWebSocketResponse) assert res.protocol == 'chat' assert hdrs.ORIGIN not in m_req.call_args[1]["headers"] @asyncio.coroutine def test_ws_connect_with_origin(key_data, loop): resp = mock.Mock() resp.status = 403 with mock.patch('aiohttp.client.os') as m_os: with mock.patch('aiohttp.client.ClientSession.get') as m_req: m_os.urandom.return_value = key_data m_req.return_value = helpers.create_future(loop) m_req.return_value.set_result(resp) origin = 'https://example.org/page.html' with pytest.raises(errors.WSServerHandshakeError): yield from aiohttp.ws_connect('http://test.org', loop=loop, origin=origin) assert hdrs.ORIGIN in m_req.call_args[1]["headers"] assert m_req.call_args[1]["headers"][hdrs.ORIGIN] == origin @asyncio.coroutine def test_ws_connect_custom_response(loop, ws_key, key_data): class CustomResponse(ClientWebSocketResponse): def read(self, decode=False): return 'customized!' resp = mock.Mock() resp.status = 101 resp.headers = { hdrs.UPGRADE: hdrs.WEBSOCKET, hdrs.CONNECTION: hdrs.UPGRADE, hdrs.SEC_WEBSOCKET_ACCEPT: ws_key, } with mock.patch('aiohttp.client.os') as m_os: with mock.patch('aiohttp.client.ClientSession.get') as m_req: m_os.urandom.return_value = key_data m_req.return_value = helpers.create_future(loop) m_req.return_value.set_result(resp) res = yield from aiohttp.ws_connect( 'http://test.org', ws_response_class=CustomResponse, loop=loop) assert res.read() == 'customized!' @asyncio.coroutine def test_ws_connect_global_loop(loop, ws_key, key_data): asyncio.set_event_loop(loop) resp = mock.Mock() resp.status = 101 resp.headers = { hdrs.UPGRADE: hdrs.WEBSOCKET, hdrs.CONNECTION: hdrs.UPGRADE, hdrs.SEC_WEBSOCKET_ACCEPT: ws_key } with mock.patch('aiohttp.client.os') as m_os: with mock.patch('aiohttp.client.ClientSession.get') as m_req: m_os.urandom.return_value = key_data m_req.return_value = helpers.create_future(loop) m_req.return_value.set_result(resp) resp = yield from aiohttp.ws_connect('http://test.org') assert resp._loop is loop asyncio.set_event_loop(None) @asyncio.coroutine def test_ws_connect_err_status(loop, ws_key, key_data): resp = mock.Mock() resp.status = 500 resp.headers = { hdrs.UPGRADE: hdrs.WEBSOCKET, hdrs.CONNECTION: hdrs.UPGRADE, hdrs.SEC_WEBSOCKET_ACCEPT: ws_key } with mock.patch('aiohttp.client.os') as m_os: with mock.patch('aiohttp.client.ClientSession.get') as m_req: m_os.urandom.return_value = key_data m_req.return_value = helpers.create_future(loop) m_req.return_value.set_result(resp) with pytest.raises(errors.WSServerHandshakeError) as ctx: yield from aiohttp.ws_connect('http://test.org', protocols=('t1', 't2', 'chat'), loop=loop) assert ctx.value.message == 'Invalid response status' @asyncio.coroutine def test_ws_connect_err_upgrade(loop, ws_key, key_data): resp = mock.Mock() resp.status = 101 resp.headers = { hdrs.UPGRADE: 'test', hdrs.CONNECTION: hdrs.UPGRADE, hdrs.SEC_WEBSOCKET_ACCEPT: ws_key } with mock.patch('aiohttp.client.os') as m_os: with mock.patch('aiohttp.client.ClientSession.get') as m_req: m_os.urandom.return_value = key_data m_req.return_value = helpers.create_future(loop) m_req.return_value.set_result(resp) with pytest.raises(errors.WSServerHandshakeError) as ctx: yield from aiohttp.ws_connect('http://test.org', protocols=('t1', 't2', 'chat'), loop=loop) assert ctx.value.message == 'Invalid upgrade header' @asyncio.coroutine def test_ws_connect_err_conn(loop, ws_key, key_data): resp = mock.Mock() resp.status = 101 resp.headers = { hdrs.UPGRADE: hdrs.WEBSOCKET, hdrs.CONNECTION: 'close', hdrs.SEC_WEBSOCKET_ACCEPT: ws_key } with mock.patch('aiohttp.client.os') as m_os: with mock.patch('aiohttp.client.ClientSession.get') as m_req: m_os.urandom.return_value = key_data m_req.return_value = helpers.create_future(loop) m_req.return_value.set_result(resp) with pytest.raises(errors.WSServerHandshakeError) as ctx: yield from aiohttp.ws_connect('http://test.org', protocols=('t1', 't2', 'chat'), loop=loop) assert ctx.value.message == 'Invalid connection header' @asyncio.coroutine def test_ws_connect_err_challenge(loop, ws_key, key_data): resp = mock.Mock() resp.status = 101 resp.headers = { hdrs.UPGRADE: hdrs.WEBSOCKET, hdrs.CONNECTION: hdrs.UPGRADE, hdrs.SEC_WEBSOCKET_ACCEPT: 'asdfasdfasdfasdfasdfasdf' } with mock.patch('aiohttp.client.os') as m_os: with mock.patch('aiohttp.client.ClientSession.get') as m_req: m_os.urandom.return_value = key_data m_req.return_value = helpers.create_future(loop) m_req.return_value.set_result(resp) with pytest.raises(errors.WSServerHandshakeError) as ctx: yield from aiohttp.ws_connect('http://test.org', protocols=('t1', 't2', 'chat'), loop=loop) assert ctx.value.message == 'Invalid challenge response' @asyncio.coroutine def test_close(loop, ws_key, key_data): resp = mock.Mock() resp.status = 101 resp.headers = { hdrs.UPGRADE: hdrs.WEBSOCKET, hdrs.CONNECTION: hdrs.UPGRADE, hdrs.SEC_WEBSOCKET_ACCEPT: ws_key, } with mock.patch('aiohttp.client.WebSocketWriter') as WebSocketWriter: with mock.patch('aiohttp.client.os') as m_os: with mock.patch('aiohttp.client.ClientSession.get') as m_req: m_os.urandom.return_value = key_data m_req.return_value = helpers.create_future(loop) m_req.return_value.set_result(resp) writer = WebSocketWriter.return_value = mock.Mock() reader = mock.Mock() resp.connection.reader.set_parser.return_value = reader resp = yield from aiohttp.ws_connect('http://test.org', loop=loop) assert not resp.closed msg = aiohttp.WSMessage(aiohttp.MsgType.CLOSE, b'', b'') reader.read.return_value = helpers.create_future(loop) reader.read.return_value.set_result(msg) res = yield from resp.close() writer.close.assert_called_with(1000, b'') assert resp.closed assert res assert resp.exception() is None # idempotent res = yield from resp.close() assert not res assert writer.close.call_count == 1 @asyncio.coroutine def test_close_exc(loop, ws_key, key_data): resp = mock.Mock() resp.status = 101 resp.headers = { hdrs.UPGRADE: hdrs.WEBSOCKET, hdrs.CONNECTION: hdrs.UPGRADE, hdrs.SEC_WEBSOCKET_ACCEPT: ws_key, } with mock.patch('aiohttp.client.WebSocketWriter') as WebSocketWriter: with mock.patch('aiohttp.client.os') as m_os: with mock.patch('aiohttp.client.ClientSession.get') as m_req: m_os.urandom.return_value = key_data m_req.return_value = helpers.create_future(loop) m_req.return_value.set_result(resp) WebSocketWriter.return_value = mock.Mock() reader = mock.Mock() resp.connection.reader.set_parser.return_value = reader resp = yield from aiohttp.ws_connect('http://test.org', loop=loop) assert not resp.closed exc = ValueError() reader.read.return_value = helpers.create_future(loop) reader.read.return_value.set_exception(exc) yield from resp.close() assert resp.closed assert resp.exception() is exc @asyncio.coroutine def test_close_exc2(loop, ws_key, key_data): resp = mock.Mock() resp.status = 101 resp.headers = { hdrs.UPGRADE: hdrs.WEBSOCKET, hdrs.CONNECTION: hdrs.UPGRADE, hdrs.SEC_WEBSOCKET_ACCEPT: ws_key, } with mock.patch('aiohttp.client.WebSocketWriter') as WebSocketWriter: with mock.patch('aiohttp.client.os') as m_os: with mock.patch('aiohttp.client.ClientSession.get') as m_req: m_os.urandom.return_value = key_data m_req.return_value = helpers.create_future(loop) m_req.return_value.set_result(resp) writer = WebSocketWriter.return_value = mock.Mock() resp.connection.reader.set_parser.return_value = mock.Mock() resp = yield from aiohttp.ws_connect('http://test.org', loop=loop) assert not resp.closed exc = ValueError() writer.close.side_effect = exc yield from resp.close() assert resp.closed assert resp.exception() is exc resp._closed = False writer.close.side_effect = asyncio.CancelledError() with pytest.raises(asyncio.CancelledError): yield from resp.close() @asyncio.coroutine def test_send_data_after_close(ws_key, key_data, loop): resp = mock.Mock() resp.status = 101 resp.headers = { hdrs.UPGRADE: hdrs.WEBSOCKET, hdrs.CONNECTION: hdrs.UPGRADE, hdrs.SEC_WEBSOCKET_ACCEPT: ws_key, } with mock.patch('aiohttp.client.WebSocketWriter') as WebSocketWriter: with mock.patch('aiohttp.client.os') as m_os: with mock.patch('aiohttp.client.ClientSession.get') as m_req: m_os.urandom.return_value = key_data m_req.return_value = helpers.create_future(loop) m_req.return_value.set_result(resp) WebSocketWriter.return_value = mock.Mock() resp = yield from aiohttp.ws_connect('http://test.org', loop=loop) resp._closed = True pytest.raises(RuntimeError, resp.ping) pytest.raises(RuntimeError, resp.pong) pytest.raises(RuntimeError, resp.send_str, 's') pytest.raises(RuntimeError, resp.send_bytes, b'b') pytest.raises(RuntimeError, resp.send_json, {}) @asyncio.coroutine def test_send_data_type_errors(ws_key, key_data, loop): resp = mock.Mock() resp.status = 101 resp.headers = { hdrs.UPGRADE: hdrs.WEBSOCKET, hdrs.CONNECTION: hdrs.UPGRADE, hdrs.SEC_WEBSOCKET_ACCEPT: ws_key, } with mock.patch('aiohttp.client.WebSocketWriter') as WebSocketWriter: with mock.patch('aiohttp.client.os') as m_os: with mock.patch('aiohttp.client.ClientSession.get') as m_req: m_os.urandom.return_value = key_data m_req.return_value = helpers.create_future(loop) m_req.return_value.set_result(resp) WebSocketWriter.return_value = mock.Mock() resp = yield from aiohttp.ws_connect('http://test.org', loop=loop) pytest.raises(TypeError, resp.send_str, b's') pytest.raises(TypeError, resp.send_bytes, 'b') pytest.raises(TypeError, resp.send_json, set()) @asyncio.coroutine def test_reader_read_exception(ws_key, key_data, loop): hresp = mock.Mock() hresp.status = 101 hresp.headers = { hdrs.UPGRADE: hdrs.WEBSOCKET, hdrs.CONNECTION: hdrs.UPGRADE, hdrs.SEC_WEBSOCKET_ACCEPT: ws_key, } with mock.patch('aiohttp.client.WebSocketWriter') as WebSocketWriter: with mock.patch('aiohttp.client.os') as m_os: with mock.patch('aiohttp.client.ClientSession.get') as m_req: m_os.urandom.return_value = key_data m_req.return_value = helpers.create_future(loop) m_req.return_value.set_result(hresp) WebSocketWriter.return_value = mock.Mock() reader = mock.Mock() hresp.connection.reader.set_parser.return_value = reader resp = yield from aiohttp.ws_connect('http://test.org', loop=loop) exc = ValueError() reader.read.return_value = helpers.create_future(loop) reader.read.return_value.set_exception(exc) msg = yield from resp.receive() assert msg.type == aiohttp.MsgType.ERROR assert msg.type is msg.tp assert resp.exception() is exc @asyncio.coroutine def test_receive_runtime_err(loop): resp = ClientWebSocketResponse( mock.Mock(), mock.Mock(), mock.Mock(), mock.Mock(), 10.0, True, True, loop) resp._waiting = True with pytest.raises(RuntimeError): yield from resp.receive() @asyncio.coroutine def test_ws_connect_close_resp_on_err(loop, ws_key, key_data): resp = mock.Mock() resp.status = 500 resp.headers = { hdrs.UPGRADE: hdrs.WEBSOCKET, hdrs.CONNECTION: hdrs.UPGRADE, hdrs.SEC_WEBSOCKET_ACCEPT: ws_key } with mock.patch('aiohttp.client.os') as m_os: with mock.patch('aiohttp.client.ClientSession.get') as m_req: m_os.urandom.return_value = key_data m_req.return_value = helpers.create_future(loop) m_req.return_value.set_result(resp) with pytest.raises(errors.WSServerHandshakeError): yield from aiohttp.ws_connect('http://test.org', protocols=('t1', 't2', 'chat'), loop=loop) resp.close.assert_called_with() @asyncio.coroutine def test_ws_connect_non_overlapped_protocols(ws_key, loop, key_data): resp = mock.Mock() resp.status = 101 resp.headers = { hdrs.UPGRADE: hdrs.WEBSOCKET, hdrs.CONNECTION: hdrs.UPGRADE, hdrs.SEC_WEBSOCKET_ACCEPT: ws_key, hdrs.SEC_WEBSOCKET_PROTOCOL: 'other,another' } with mock.patch('aiohttp.client.os') as m_os: with mock.patch('aiohttp.client.ClientSession.get') as m_req: m_os.urandom.return_value = key_data m_req.return_value = helpers.create_future(loop) m_req.return_value.set_result(resp) res = yield from aiohttp.ws_connect( 'http://test.org', protocols=('t1', 't2', 'chat'), loop=loop) assert res.protocol is None aiohttp-1.2.0/tests/hello.txt.gz0000664000175000017500000000005413025134363017452 0ustar travistravis000000000000001%Uhello.txtHWH())6aiohttp-1.2.0/tests/test_web_urldispatcher.py0000664000175000017500000002100313025134363022303 0ustar travistravis00000000000000import asyncio import functools import os import shutil import tempfile from unittest import mock from unittest.mock import MagicMock import pytest from aiohttp import abc, web from aiohttp.web_urldispatcher import SystemRoute @pytest.fixture(scope='function') def tmp_dir_path(request): """ Give a path for a temporary directory The directory is destroyed at the end of the test. """ # Temporary directory. tmp_dir = tempfile.mkdtemp() def teardown(): # Delete the whole directory: shutil.rmtree(tmp_dir) request.addfinalizer(teardown) return tmp_dir @pytest.mark.parametrize("show_index,status,data", [(False, 403, None), (True, 200, b'\n\nIndex of /\n' b'\n\n

Index of /

\n\n\n')]) @asyncio.coroutine def test_access_root_of_static_handler(tmp_dir_path, loop, test_client, show_index, status, data): """ Tests the operation of static file server. Try to access the root of static file server, and make sure that correct HTTP statuses are returned depending if we directory index should be shown or not. """ # Put a file inside tmp_dir_path: my_file_path = os.path.join(tmp_dir_path, 'my_file') with open(my_file_path, 'w') as fw: fw.write('hello') my_dir_path = os.path.join(tmp_dir_path, 'my_dir') os.mkdir(my_dir_path) my_file_path = os.path.join(my_dir_path, 'my_file_in_dir') with open(my_file_path, 'w') as fw: fw.write('world') app = web.Application(loop=loop) # Register global static route: app.router.add_static('/', tmp_dir_path, show_index=show_index) client = yield from test_client(app) # Request the root of the static directory. r = yield from client.get('/') assert r.status == status if data: assert r.headers['Content-Type'] == "text/html; charset=utf-8" read_ = (yield from r.read()) assert read_ == data yield from r.release() @pytest.mark.parametrize('data', ['hello world']) @asyncio.coroutine def test_follow_symlink(tmp_dir_path, loop, test_client, data): """ Tests the access to a symlink, in static folder """ my_dir_path = os.path.join(tmp_dir_path, 'my_dir') os.mkdir(my_dir_path) my_file_path = os.path.join(my_dir_path, 'my_file_in_dir') with open(my_file_path, 'w') as fw: fw.write(data) my_symlink_path = os.path.join(tmp_dir_path, 'my_symlink') os.symlink(my_dir_path, my_symlink_path) app = web.Application(loop=loop) # Register global static route: app.router.add_static('/', tmp_dir_path, follow_symlinks=True) client = yield from test_client(app) # Request the root of the static directory. r = yield from client.get('/my_symlink/my_file_in_dir') assert r.status == 200 assert (yield from r.text()) == data yield from r.release() @pytest.mark.parametrize('dir_name,filename,data', [ ('', 'test file.txt', 'test text'), ('test dir name', 'test dir file .txt', 'test text file folder') ]) @asyncio.coroutine def test_access_to_the_file_with_spaces(tmp_dir_path, loop, test_client, dir_name, filename, data): """ Checks operation of static files with spaces """ my_dir_path = os.path.join(tmp_dir_path, dir_name) if dir_name: os.mkdir(my_dir_path) my_file_path = os.path.join(my_dir_path, filename) with open(my_file_path, 'w') as fw: fw.write(data) app = web.Application(loop=loop) url = os.path.join('/', dir_name, filename) app.router.add_static('/', tmp_dir_path) client = yield from test_client(app) r = yield from client.get(url) assert r.status == 200 assert (yield from r.text()) == data yield from r.release() @asyncio.coroutine def test_access_non_existing_resource(tmp_dir_path, loop, test_client): """ Tests accessing non-existing resource Try to access a non-exiting resource and make sure that 404 HTTP status returned. """ app = web.Application(loop=loop) # Register global static route: app.router.add_static('/', tmp_dir_path, show_index=True) client = yield from test_client(app) # Request the root of the static directory. r = yield from client.get('/non_existing_resource') assert r.status == 404 yield from r.release() @asyncio.coroutine def test_unauthorized_folder_access(tmp_dir_path, loop, test_client): """ Tests the unauthorized access to a folder of static file server. Try to list a folder content of static file server when server does not have permissions to do so for the folder. """ my_dir_path = os.path.join(tmp_dir_path, 'my_dir') os.mkdir(my_dir_path) app = web.Application(loop=loop) with mock.patch('pathlib.Path.__new__') as path_constructor: path = MagicMock() path.joinpath.return_value = path path.resolve.return_value = path path.iterdir.return_value.__iter__.side_effect = PermissionError() path_constructor.return_value = path # Register global static route: app.router.add_static('/', tmp_dir_path, show_index=True) client = yield from test_client(app) # Request the root of the static directory. r = yield from client.get('/my_dir') assert r.status == 403 yield from r.release() @asyncio.coroutine def test_access_symlink_loop(tmp_dir_path, loop, test_client): """ Tests the access to a looped symlink, which could not be resolved. """ my_dir_path = os.path.join(tmp_dir_path, 'my_symlink') os.symlink(my_dir_path, my_dir_path) app = web.Application(loop=loop) # Register global static route: app.router.add_static('/', tmp_dir_path, show_index=True) client = yield from test_client(app) # Request the root of the static directory. r = yield from client.get('/my_symlink') assert r.status == 404 yield from r.release() @asyncio.coroutine def test_access_special_resource(tmp_dir_path, loop, test_client): """ Tests the access to a resource that is neither a file nor a directory. Checks that if a special resource is accessed (f.e. named pipe or UNIX domain socket) then 404 HTTP status returned. """ app = web.Application(loop=loop) with mock.patch('pathlib.Path.__new__') as path_constructor: special = MagicMock() special.is_dir.return_value = False special.is_file.return_value = False path = MagicMock() path.joinpath.side_effect = lambda p: (special if p == 'special' else path) path.resolve.return_value = path special.resolve.return_value = special path_constructor.return_value = path # Register global static route: app.router.add_static('/', tmp_dir_path, show_index=True) client = yield from test_client(app) # Request the root of the static directory. r = yield from client.get('/special') assert r.status == 404 yield from r.release() @asyncio.coroutine def test_partialy_applied_handler(loop, test_client): app = web.Application(loop=loop) @asyncio.coroutine def handler(data, request): return web.Response(body=data) app.router.add_route('GET', '/', functools.partial(handler, b'hello')) client = yield from test_client(app) r = yield from client.get('/') data = (yield from r.read()) assert data == b'hello' yield from r.release() def test_system_route(): route = SystemRoute(web.HTTPCreated(reason='test')) with pytest.raises(RuntimeError): route.url() with pytest.raises(RuntimeError): route.url_for() assert route.name is None assert route.resource is None assert "" == repr(route) assert 201 == route.status assert 'test' == route.reason @asyncio.coroutine def test_412_is_returned(loop, test_client): class MyRouter(abc.AbstractRouter): @asyncio.coroutine def resolve(self, request): raise web.HTTPPreconditionFailed() app = web.Application(router=MyRouter(), loop=loop) client = yield from test_client(app) resp = yield from client.get('/') assert resp.status == 412 aiohttp-1.2.0/tests/test_web_websocket_functional.py0000664000175000017500000003504413025134363023654 0ustar travistravis00000000000000"""HTTP websocket server functional tests""" import asyncio import pytest import aiohttp from aiohttp import helpers, web from aiohttp._ws_impl import WSMsgType @asyncio.coroutine def test_websocket_json(loop, test_client): @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) msg = yield from ws.receive() msg_json = msg.json() answer = msg_json['test'] ws.send_str(answer) yield from ws.close() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/') expected_value = 'value' payload = '{"test": "%s"}' % expected_value ws.send_str(payload) resp = yield from ws.receive() assert resp.data == expected_value @asyncio.coroutine def test_websocket_json_invalid_message(loop, test_client): @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) try: yield from ws.receive_json() except ValueError: ws.send_str('ValueError was raised') else: raise Exception('No Exception') finally: yield from ws.close() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/') payload = 'NOT A VALID JSON STRING' ws.send_str(payload) data = yield from ws.receive_str() assert 'ValueError was raised' in data @asyncio.coroutine def test_websocket_send_json(loop, test_client): @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) data = yield from ws.receive_json() ws.send_json(data) yield from ws.close() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/') expected_value = 'value' ws.send_json({'test': expected_value}) data = yield from ws.receive_json() assert data['test'] == expected_value @asyncio.coroutine def test_websocket_receive_json(loop, test_client): @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) data = yield from ws.receive_json() answer = data['test'] ws.send_str(answer) yield from ws.close() return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/') expected_value = 'value' payload = '{"test": "%s"}' % expected_value ws.send_str(payload) resp = yield from ws.receive() assert resp.data == expected_value @asyncio.coroutine def test_send_recv_text(loop, test_client): closed = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) msg = yield from ws.receive_str() ws.send_str(msg+'/answer') yield from ws.close() closed.set_result(1) return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/') ws.send_str('ask') msg = yield from ws.receive() assert msg.type == aiohttp.WSMsgType.TEXT assert 'ask/answer' == msg.data msg = yield from ws.receive() assert msg.type == aiohttp.WSMsgType.CLOSE assert msg.data == 1000 assert msg.extra == '' assert ws.closed assert ws.close_code == 1000 yield from closed @asyncio.coroutine def test_send_recv_bytes(loop, test_client): closed = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) msg = yield from ws.receive_bytes() ws.send_bytes(msg+b'/answer') yield from ws.close() closed.set_result(1) return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/') ws.send_bytes(b'ask') msg = yield from ws.receive() assert msg.type == aiohttp.WSMsgType.BINARY assert b'ask/answer' == msg.data msg = yield from ws.receive() assert msg.type == aiohttp.WSMsgType.CLOSE assert msg.data == 1000 assert msg.extra == '' assert ws.closed assert ws.close_code == 1000 yield from closed @asyncio.coroutine def test_send_recv_json(loop, test_client): closed = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) data = yield from ws.receive_json() ws.send_json({'response': data['request']}) yield from ws.close() closed.set_result(1) return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/') ws.send_str('{"request": "test"}') msg = yield from ws.receive() data = msg.json() assert msg.type == aiohttp.WSMsgType.TEXT assert data['response'] == 'test' msg = yield from ws.receive() assert msg.type == aiohttp.WSMsgType.CLOSE assert msg.data == 1000 assert msg.extra == '' yield from ws.close() yield from closed @asyncio.coroutine def test_close_timeout(loop, test_client): aborted = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse(timeout=0.1) yield from ws.prepare(request) assert 'request' == (yield from ws.receive_str()) ws.send_str('reply') begin = ws._loop.time() assert (yield from ws.close()) elapsed = ws._loop.time() - begin assert elapsed < 0.201, \ 'close() should have returned before ' \ 'at most 2x timeout.' assert ws.close_code == 1006 assert isinstance(ws.exception(), asyncio.TimeoutError) aborted.set_result(1) return ws app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/') ws.send_str('request') assert 'reply' == (yield from ws.receive_str()) # The server closes here. Then the client sends bogus messages with an # internval shorter than server-side close timeout, to make the server # hanging indefinitely. yield from asyncio.sleep(0.08, loop=loop) msg = yield from ws._reader.read() assert msg.type == WSMsgType.CLOSE ws.send_str('hang') yield from asyncio.sleep(0.08, loop=loop) ws.send_str('hang') yield from asyncio.sleep(0.08, loop=loop) ws.send_str('hang') yield from asyncio.sleep(0.08, loop=loop) ws.send_str('hang') yield from asyncio.sleep(0.08, loop=loop) assert (yield from aborted) yield from ws.close() @asyncio.coroutine def test_auto_pong_with_closing_by_peer(loop, test_client): closed = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) yield from ws.receive() msg = yield from ws.receive() assert msg.type == WSMsgType.CLOSE assert msg.data == 1000 assert msg.extra == 'exit message' closed.set_result(None) return ws app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/', autoclose=False, autoping=False) ws.ping() ws.send_str('ask') msg = yield from ws.receive() assert msg.type == WSMsgType.PONG yield from ws.close(code=1000, message='exit message') yield from closed @asyncio.coroutine def test_ping(loop, test_client): closed = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) ws.ping('data') yield from ws.receive() closed.set_result(None) return ws app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/', autoping=False) msg = yield from ws.receive() assert msg.type == WSMsgType.PING assert msg.data == b'data' ws.pong() yield from ws.close() yield from closed @asyncio.coroutine def test_client_ping(loop, test_client): closed = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) yield from ws.receive() closed.set_result(None) return ws app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/', autoping=False) ws.ping('data') msg = yield from ws.receive() assert msg.type == WSMsgType.PONG assert msg.data == b'data' ws.pong() yield from ws.close() @asyncio.coroutine def test_pong(loop, test_client): closed = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse(autoping=False) yield from ws.prepare(request) msg = yield from ws.receive() assert msg.type == WSMsgType.PING ws.pong('data') msg = yield from ws.receive() assert msg.type == WSMsgType.CLOSE assert msg.data == 1000 assert msg.extra == 'exit message' closed.set_result(None) return ws app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/', autoping=False) ws.ping('data') msg = yield from ws.receive() assert msg.type == WSMsgType.PONG assert msg.data == b'data' yield from ws.close(code=1000, message='exit message') yield from closed @asyncio.coroutine def test_change_status(loop, test_client): closed = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() ws.set_status(200) assert 200 == ws.status yield from ws.prepare(request) assert 101 == ws.status yield from ws.close() closed.set_result(None) return ws app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/', autoping=False) yield from ws.close() yield from closed yield from ws.close() @asyncio.coroutine def test_handle_protocol(loop, test_client): closed = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse(protocols=('foo', 'bar')) yield from ws.prepare(request) yield from ws.close() assert 'bar' == ws.protocol closed.set_result(None) return ws app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/', protocols=('eggs', 'bar')) yield from ws.close() yield from closed @asyncio.coroutine def test_server_close_handshake(loop, test_client): closed = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse(protocols=('foo', 'bar')) yield from ws.prepare(request) yield from ws.close() closed.set_result(None) return ws app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/', autoclose=False, protocols=('eggs', 'bar')) msg = yield from ws.receive() assert msg.type == WSMsgType.CLOSE yield from ws.close() yield from closed @asyncio.coroutine def test_client_close_handshake(loop, test_client): closed = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse( autoclose=False, protocols=('foo', 'bar')) yield from ws.prepare(request) msg = yield from ws.receive() assert msg.type == WSMsgType.CLOSE assert not ws.closed yield from ws.close() assert ws.closed assert ws.close_code == 1007 msg = yield from ws.receive() assert msg.type == WSMsgType.CLOSED closed.set_result(None) return ws app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/', autoclose=False, protocols=('eggs', 'bar')) yield from ws.close(code=1007) msg = yield from ws.receive() assert msg.type == WSMsgType.CLOSED yield from closed @asyncio.coroutine def test_server_close_handshake_server_eats_client_messages(loop, test_client): closed = helpers.create_future(loop) @asyncio.coroutine def handler(request): ws = web.WebSocketResponse(protocols=('foo', 'bar')) yield from ws.prepare(request) yield from ws.close() closed.set_result(None) return ws app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/', autoclose=False, autoping=False, protocols=('eggs', 'bar')) msg = yield from ws.receive() assert msg.type == WSMsgType.CLOSE ws.send_str('text') ws.send_bytes(b'bytes') ws.ping() yield from ws.close() yield from closed @asyncio.coroutine def test_receive_msg(loop, test_client): @asyncio.coroutine def handler(request): ws = web.WebSocketResponse() yield from ws.prepare(request) with pytest.warns(DeprecationWarning): msg = yield from ws.receive_msg() assert msg.data == b'data' yield from ws.close() return ws app = web.Application(loop=loop) app.router.add_get('/', handler) client = yield from test_client(app) ws = yield from client.ws_connect('/') ws.send_bytes(b'data') yield from ws.close() aiohttp-1.2.0/tests/test_worker.py0000664000175000017500000003034213025134363020114 0ustar travistravis00000000000000"""Tests for aiohttp/worker.py""" import asyncio import pathlib import socket import ssl from unittest import mock import pytest from aiohttp import helpers from aiohttp.test_utils import make_mocked_coro base_worker = pytest.importorskip('aiohttp.worker') try: import uvloop except ImportError: uvloop = None WRONG_LOG_FORMAT = '%a "%{Referrer}i" %(h)s %(l)s %s' ACCEPTABLE_LOG_FORMAT = '%a "%{Referrer}i" %s' class BaseTestWorker: def __init__(self): self.servers = {} self.exit_code = 0 self.cfg = mock.Mock() self.cfg.graceful_timeout = 100 class AsyncioWorker(BaseTestWorker, base_worker.GunicornWebWorker): pass PARAMS = [AsyncioWorker] if uvloop is not None: class UvloopWorker(BaseTestWorker, base_worker.GunicornUVLoopWebWorker): pass PARAMS.append(UvloopWorker) @pytest.fixture(params=PARAMS) def worker(request): ret = request.param() ret.notify = mock.Mock() return ret def test_init_process(worker): with mock.patch('aiohttp.worker.asyncio') as m_asyncio: try: worker.init_process() except TypeError: pass assert m_asyncio.get_event_loop.return_value.close.called assert m_asyncio.new_event_loop.called assert m_asyncio.set_event_loop.called def test_run(worker, loop): worker.wsgi = mock.Mock() worker.loop = loop worker._run = mock.Mock( wraps=asyncio.coroutine(lambda: None)) worker.wsgi.startup = make_mocked_coro(None) with pytest.raises(SystemExit): worker.run() assert worker._run.called worker.wsgi.startup.assert_called_once_with() assert loop.is_closed() def test_run_wsgi(worker, loop): worker.wsgi = lambda env, start_resp: start_resp() worker.loop = loop worker._run = mock.Mock( wraps=asyncio.coroutine(lambda: None)) with pytest.raises(SystemExit): worker.run() assert worker._run.called assert loop.is_closed() def test_handle_quit(worker): with mock.patch('aiohttp.worker.ensure_future') as m_ensure_future: worker.loop = mock.Mock() worker.handle_quit(object(), object()) assert not worker.alive assert worker.exit_code == 0 assert m_ensure_future.called worker.loop.call_later.asset_called_with( 0.1, worker._notify_waiter_done) def test_handle_abort(worker): with mock.patch('aiohttp.worker.sys') as m_sys: worker.handle_abort(object(), object()) assert not worker.alive assert worker.exit_code == 1 m_sys.exit.assert_called_with(1) def test__wait_next_notify(worker): worker.loop = mock.Mock() worker._notify_waiter_done = mock.Mock() fut = worker._wait_next_notify() assert worker._notify_waiter == fut worker.loop.call_later.assert_called_with(1.0, worker._notify_waiter_done) def test__notify_waiter_done(worker): worker._notify_waiter = None worker._notify_waiter_done() assert worker._notify_waiter is None waiter = worker._notify_waiter = mock.Mock() worker._notify_waiter.done.return_value = False worker._notify_waiter_done() assert worker._notify_waiter is None waiter.set_result.assert_called_with(True) def test_init_signals(worker): worker.loop = mock.Mock() worker.init_signals() assert worker.loop.add_signal_handler.called def test_make_handler(worker, mocker): worker.wsgi = mock.Mock() worker.loop = mock.Mock() worker.log = mock.Mock() worker.cfg = mock.Mock() worker.cfg.access_log_format = ACCEPTABLE_LOG_FORMAT mocker.spy(worker, '_get_valid_log_format') f = worker.make_handler(worker.wsgi) assert f is worker.wsgi.make_handler.return_value assert worker._get_valid_log_format.called def test_make_handler_wsgi(worker, mocker): worker.wsgi = lambda env, start_resp: start_resp() worker.loop = mock.Mock() worker.log = mock.Mock() worker.cfg = mock.Mock() worker.cfg.access_log_format = ACCEPTABLE_LOG_FORMAT mocker.spy(worker, '_get_valid_log_format') f = worker.make_handler(worker.wsgi) assert isinstance(f, base_worker.WSGIServer) assert isinstance(f(), base_worker.WSGIServerHttpProtocol) assert worker._get_valid_log_format.called @pytest.mark.parametrize('source,result', [ (ACCEPTABLE_LOG_FORMAT, ACCEPTABLE_LOG_FORMAT), (AsyncioWorker.DEFAULT_GUNICORN_LOG_FORMAT, AsyncioWorker.DEFAULT_AIOHTTP_LOG_FORMAT), ]) def test__get_valid_log_format_ok(worker, source, result): assert result == worker._get_valid_log_format(source) def test__get_valid_log_format_exc(worker): with pytest.raises(ValueError) as exc: worker._get_valid_log_format(WRONG_LOG_FORMAT) assert '%(name)s' in str(exc) @asyncio.coroutine def test__run_ok(worker, loop): worker.ppid = 1 worker.alive = True worker.servers = {} sock = mock.Mock() sock.cfg_addr = ('localhost', 8080) worker.sockets = [sock] worker.wsgi = mock.Mock() worker.close = make_mocked_coro(None) worker.log = mock.Mock() worker.loop = loop loop.create_server = make_mocked_coro(sock) worker.wsgi.make_handler.return_value.requests_count = 1 worker.cfg.max_requests = 100 worker.cfg.is_ssl = True worker.cfg.access_log_format = ACCEPTABLE_LOG_FORMAT ssl_context = mock.Mock() with mock.patch('ssl.SSLContext', return_value=ssl_context): with mock.patch('aiohttp.worker.asyncio') as m_asyncio: m_asyncio.sleep = mock.Mock( wraps=asyncio.coroutine(lambda *a, **kw: None)) yield from worker._run() worker.notify.assert_called_with() worker.log.info.assert_called_with("Parent changed, shutting down: %s", worker) args, kwargs = loop.create_server.call_args assert 'ssl' in kwargs ctx = kwargs['ssl'] assert ctx is ssl_context @pytest.mark.skipif(not hasattr(socket, 'AF_UNIX'), reason="UNIX sockets are not supported") @asyncio.coroutine def test__run_ok_unix_socket(worker, loop): worker.ppid = 1 worker.alive = True worker.servers = {} sock = mock.Mock() sock.cfg_addr = ('/path/to') sock.family = socket.AF_UNIX worker.sockets = [sock] worker.wsgi = mock.Mock() worker.close = make_mocked_coro(None) worker.log = mock.Mock() worker.loop = loop loop.create_unix_server = make_mocked_coro(sock) worker.wsgi.make_handler.return_value.requests_count = 1 worker.cfg.max_requests = 100 worker.cfg.is_ssl = True worker.cfg.access_log_format = ACCEPTABLE_LOG_FORMAT ssl_context = mock.Mock() with mock.patch('ssl.SSLContext', return_value=ssl_context): with mock.patch('aiohttp.worker.asyncio') as m_asyncio: m_asyncio.sleep = mock.Mock( wraps=asyncio.coroutine(lambda *a, **kw: None)) yield from worker._run() worker.notify.assert_called_with() worker.log.info.assert_called_with("Parent changed, shutting down: %s", worker) args, kwargs = loop.create_unix_server.call_args assert 'ssl' in kwargs ctx = kwargs['ssl'] assert ctx is ssl_context @asyncio.coroutine def test__run_exc(worker, loop): with mock.patch('aiohttp.worker.os') as m_os: m_os.getpid.return_value = 1 m_os.getppid.return_value = 1 handler = mock.Mock() handler.requests_count = 0 worker.servers = {mock.Mock(): handler} worker._wait_next_notify = mock.Mock() worker.ppid = 1 worker.alive = True worker.sockets = [] worker.log = mock.Mock() worker.loop = loop worker.cfg.is_ssl = False worker.cfg.max_redirects = 0 worker.cfg.max_requests = 100 with mock.patch('aiohttp.worker.asyncio.sleep') as m_sleep: slp = helpers.create_future(loop) slp.set_exception(KeyboardInterrupt) m_sleep.return_value = slp worker.close = make_mocked_coro(None) yield from worker._run() assert worker._wait_next_notify.called worker.close.assert_called_with() @asyncio.coroutine def test_close(worker, loop): srv = mock.Mock() srv.wait_closed = make_mocked_coro(None) handler = mock.Mock() worker.servers = {srv: handler} worker.log = mock.Mock() worker.loop = loop app = worker.wsgi = mock.Mock() app.cleanup = make_mocked_coro(None) handler.connections = [object()] handler.shutdown.return_value = helpers.create_future(loop) handler.shutdown.return_value.set_result(1) app.shutdown.return_value = helpers.create_future(loop) app.shutdown.return_value.set_result(None) yield from worker.close() app.shutdown.assert_called_with() app.cleanup.assert_called_with() handler.shutdown.assert_called_with(timeout=95.0) srv.close.assert_called_with() assert worker.servers is None yield from worker.close() @asyncio.coroutine def test_close_wsgi(worker, loop): srv = mock.Mock() srv.wait_closed = make_mocked_coro(None) handler = mock.Mock() worker.servers = {srv: handler} worker.log = mock.Mock() worker.loop = loop worker.wsgi = lambda env, start_resp: start_resp() handler.connections = [object()] handler.shutdown.return_value = helpers.create_future(loop) handler.shutdown.return_value.set_result(1) yield from worker.close() handler.shutdown.assert_called_with(timeout=95.0) srv.close.assert_called_with() assert worker.servers is None yield from worker.close() @asyncio.coroutine def test__run_ok_no_max_requests(worker, loop): worker.ppid = 1 worker.alive = True worker.servers = {} sock = mock.Mock() sock.cfg_addr = ('localhost', 8080) worker.sockets = [sock] worker.wsgi = mock.Mock() worker.close = make_mocked_coro(None) worker.log = mock.Mock() worker.loop = loop loop.create_server = make_mocked_coro(sock) worker.wsgi.make_handler.return_value.requests_count = 1 worker.cfg.access_log_format = ACCEPTABLE_LOG_FORMAT worker.cfg.max_requests = 0 worker.cfg.is_ssl = True ssl_context = mock.Mock() with mock.patch('ssl.SSLContext', return_value=ssl_context): with mock.patch('aiohttp.worker.asyncio') as m_asyncio: m_asyncio.sleep = mock.Mock( wraps=asyncio.coroutine(lambda *a, **kw: None)) yield from worker._run() worker.notify.assert_called_with() worker.log.info.assert_called_with("Parent changed, shutting down: %s", worker) args, kwargs = loop.create_server.call_args assert 'ssl' in kwargs ctx = kwargs['ssl'] assert ctx is ssl_context @asyncio.coroutine def test__run_ok_max_requests_exceeded(worker, loop): worker.ppid = 1 worker.alive = True worker.servers = {} sock = mock.Mock() sock.cfg_addr = ('localhost', 8080) worker.sockets = [sock] worker.wsgi = mock.Mock() worker.close = make_mocked_coro(None) worker.log = mock.Mock() worker.loop = loop loop.create_server = make_mocked_coro(sock) worker.wsgi.make_handler.return_value.requests_count = 15 worker.cfg.access_log_format = ACCEPTABLE_LOG_FORMAT worker.cfg.max_requests = 10 worker.cfg.is_ssl = True ssl_context = mock.Mock() with mock.patch('ssl.SSLContext', return_value=ssl_context): with mock.patch('aiohttp.worker.asyncio') as m_asyncio: m_asyncio.sleep = mock.Mock( wraps=asyncio.coroutine(lambda *a, **kw: None)) yield from worker._run() worker.notify.assert_called_with() worker.log.info.assert_called_with("Max requests, shutting down: %s", worker) args, kwargs = loop.create_server.call_args assert 'ssl' in kwargs ctx = kwargs['ssl'] assert ctx is ssl_context def test__create_ssl_context_without_certs_and_ciphers(worker): here = pathlib.Path(__file__).parent worker.cfg.ssl_version = ssl.PROTOCOL_SSLv23 worker.cfg.cert_reqs = ssl.CERT_OPTIONAL worker.cfg.certfile = str(here / 'sample.crt') worker.cfg.keyfile = str(here / 'sample.key') worker.cfg.ca_certs = None worker.cfg.ciphers = None crt = worker._create_ssl_context(worker.cfg) assert isinstance(crt, ssl.SSLContext) aiohttp-1.2.0/tests/test_cookiejar.py0000664000175000017500000004607013025134363020556 0ustar travistravis00000000000000import asyncio import datetime import os import tempfile import unittest from http.cookies import SimpleCookie from unittest import mock import pytest from yarl import URL from aiohttp import CookieJar @pytest.fixture def cookies_to_send(): return SimpleCookie( "shared-cookie=first; " "domain-cookie=second; Domain=example.com; " "subdomain1-cookie=third; Domain=test1.example.com; " "subdomain2-cookie=fourth; Domain=test2.example.com; " "dotted-domain-cookie=fifth; Domain=.example.com; " "different-domain-cookie=sixth; Domain=different.org; " "secure-cookie=seventh; Domain=secure.com; Secure; " "no-path-cookie=eighth; Domain=pathtest.com; " "path1-cookie=nineth; Domain=pathtest.com; Path=/; " "path2-cookie=tenth; Domain=pathtest.com; Path=/one; " "path3-cookie=eleventh; Domain=pathtest.com; Path=/one/two; " "path4-cookie=twelfth; Domain=pathtest.com; Path=/one/two/; " "expires-cookie=thirteenth; Domain=expirestest.com; Path=/;" " Expires=Tue, 1 Jan 1980 12:00:00 GMT; " "max-age-cookie=fourteenth; Domain=maxagetest.com; Path=/;" " Max-Age=60; " "invalid-max-age-cookie=fifteenth; Domain=invalid-values.com; " " Max-Age=string; " "invalid-expires-cookie=sixteenth; Domain=invalid-values.com; " " Expires=string;" ) @pytest.fixture def cookies_to_receive(): return SimpleCookie( "unconstrained-cookie=first; Path=/; " "domain-cookie=second; Domain=example.com; Path=/; " "subdomain1-cookie=third; Domain=test1.example.com; Path=/; " "subdomain2-cookie=fourth; Domain=test2.example.com; Path=/; " "dotted-domain-cookie=fifth; Domain=.example.com; Path=/; " "different-domain-cookie=sixth; Domain=different.org; Path=/; " "no-path-cookie=seventh; Domain=pathtest.com; " "path-cookie=eighth; Domain=pathtest.com; Path=/somepath; " "wrong-path-cookie=nineth; Domain=pathtest.com; Path=somepath;" ) def test_date_parsing(): parse_func = CookieJar._parse_date utc = datetime.timezone.utc assert parse_func("") is None # 70 -> 1970 assert parse_func("Tue, 1 Jan 70 00:00:00 GMT") == \ datetime.datetime(1970, 1, 1, tzinfo=utc) # 10 -> 2010 assert parse_func("Tue, 1 Jan 10 00:00:00 GMT") == \ datetime.datetime(2010, 1, 1, tzinfo=utc) # No day of week string assert parse_func("1 Jan 1970 00:00:00 GMT") == \ datetime.datetime(1970, 1, 1, tzinfo=utc) # No timezone string assert parse_func("Tue, 1 Jan 1970 00:00:00") == \ datetime.datetime(1970, 1, 1, tzinfo=utc) # No year assert parse_func("Tue, 1 Jan 00:00:00 GMT") is None # No month assert parse_func("Tue, 1 1970 00:00:00 GMT") is None # No day of month assert parse_func("Tue, Jan 1970 00:00:00 GMT") is None # No time assert parse_func("Tue, 1 Jan 1970 GMT") is None # Invalid day of month assert parse_func("Tue, 0 Jan 1970 00:00:00 GMT") is None # Invalid year assert parse_func("Tue, 1 Jan 1500 00:00:00 GMT") is None # Invalid time assert parse_func("Tue, 1 Jan 1970 77:88:99 GMT") is None def test_domain_matching(): test_func = CookieJar._is_domain_match assert test_func("test.com", "test.com") assert test_func("test.com", "sub.test.com") assert not test_func("test.com", "") assert not test_func("test.com", "test.org") assert not test_func("diff-test.com", "test.com") assert not test_func("test.com", "diff-test.com") assert not test_func("test.com", "127.0.0.1") def test_path_matching(): test_func = CookieJar._is_path_match assert test_func("/", "") assert test_func("", "/") assert test_func("/file", "") assert test_func("/folder/file", "") assert test_func("/", "/") assert test_func("/file", "/") assert test_func("/file", "/file") assert test_func("/folder/", "/folder/") assert test_func("/folder/", "/") assert test_func("/folder/file", "/") assert not test_func("/", "/file") assert not test_func("/", "/folder/") assert not test_func("/file", "/folder/file") assert not test_func("/folder/", "/folder/file") assert not test_func("/different-file", "/file") assert not test_func("/different-folder/", "/folder/") def test_constructor(loop, cookies_to_send, cookies_to_receive): jar = CookieJar(loop=loop) jar.update_cookies(cookies_to_send) jar_cookies = SimpleCookie() for cookie in jar: dict.__setitem__(jar_cookies, cookie.key, cookie) expected_cookies = cookies_to_send assert jar_cookies == expected_cookies assert jar._loop is loop def test_save_load(loop, cookies_to_send, cookies_to_receive): file_path = tempfile.mkdtemp() + '/aiohttp.test.cookie' # export cookie jar jar_save = CookieJar(loop=loop) jar_save.update_cookies(cookies_to_receive) jar_save.save(file_path=file_path) jar_load = CookieJar(loop=loop) jar_load.load(file_path=file_path) jar_test = SimpleCookie() for cookie in jar_load: jar_test[cookie.key] = cookie os.unlink(file_path) assert jar_test == cookies_to_receive def test_update_cookie_with_unicode_domain(loop): cookies = ( "idna-domain-first=first; Domain=xn--9caa.com; Path=/;", "idna-domain-second=second; Domain=xn--9caa.com; Path=/;", ) jar = CookieJar(loop=loop) jar.update_cookies(SimpleCookie(cookies[0]), URL("http://éé.com/")) jar.update_cookies(SimpleCookie(cookies[1]), URL("http://xn--9caa.com/")) jar_test = SimpleCookie() for cookie in jar: jar_test[cookie.key] = cookie assert jar_test == SimpleCookie(" ".join(cookies)) def test_filter_cookie_with_unicode_domain(loop): jar = CookieJar(loop=loop) jar.update_cookies(SimpleCookie( "idna-domain-first=first; Domain=xn--9caa.com; Path=/; " )) assert len(jar.filter_cookies(URL("http://éé.com"))) == 1 assert len(jar.filter_cookies(URL("http://xn--9caa.com"))) == 1 def test_ctor_ith_default_loop(loop): asyncio.set_event_loop(loop) jar = CookieJar() assert jar._loop is loop def test_domain_filter_ip_cookie_send(loop): jar = CookieJar(loop=loop) cookies = SimpleCookie( "shared-cookie=first; " "domain-cookie=second; Domain=example.com; " "subdomain1-cookie=third; Domain=test1.example.com; " "subdomain2-cookie=fourth; Domain=test2.example.com; " "dotted-domain-cookie=fifth; Domain=.example.com; " "different-domain-cookie=sixth; Domain=different.org; " "secure-cookie=seventh; Domain=secure.com; Secure; " "no-path-cookie=eighth; Domain=pathtest.com; " "path1-cookie=nineth; Domain=pathtest.com; Path=/; " "path2-cookie=tenth; Domain=pathtest.com; Path=/one; " "path3-cookie=eleventh; Domain=pathtest.com; Path=/one/two; " "path4-cookie=twelfth; Domain=pathtest.com; Path=/one/two/; " "expires-cookie=thirteenth; Domain=expirestest.com; Path=/;" " Expires=Tue, 1 Jan 1980 12:00:00 GMT; " "max-age-cookie=fourteenth; Domain=maxagetest.com; Path=/;" " Max-Age=60; " "invalid-max-age-cookie=fifteenth; Domain=invalid-values.com; " " Max-Age=string; " "invalid-expires-cookie=sixteenth; Domain=invalid-values.com; " " Expires=string;" ) jar.update_cookies(cookies) cookies_sent = jar.filter_cookies(URL("http://1.2.3.4/")).output( header='Cookie:') assert cookies_sent == 'Cookie: shared-cookie=first' def test_domain_filter_ip_cookie_receive(loop, cookies_to_receive): jar = CookieJar(loop=loop) jar.update_cookies(cookies_to_receive, URL("http://1.2.3.4/")) assert len(jar) == 0 def test_preserving_ip_domain_cookies(loop): jar = CookieJar(loop=loop, unsafe=True) jar.update_cookies(SimpleCookie( "shared-cookie=first; " "ip-cookie=second; Domain=127.0.0.1;" )) cookies_sent = jar.filter_cookies(URL("http://127.0.0.1/")).output( header='Cookie:') assert cookies_sent == ('Cookie: ip-cookie=second\r\n' 'Cookie: shared-cookie=first') def test_preserving_quoted_cookies(loop): jar = CookieJar(loop=loop, unsafe=True) jar.update_cookies(SimpleCookie( "ip-cookie=\"second\"; Domain=127.0.0.1;" )) cookies_sent = jar.filter_cookies(URL("http://127.0.0.1/")).output( header='Cookie:') assert cookies_sent == 'Cookie: ip-cookie=\"second\"' def test_ignore_domain_ending_with_dot(loop): jar = CookieJar(loop=loop, unsafe=True) jar.update_cookies(SimpleCookie("cookie=val; Domain=example.com.;"), URL("http://www.example.com")) cookies_sent = jar.filter_cookies(URL("http://www.example.com/")) assert cookies_sent.output(header='Cookie:') == "Cookie: cookie=val" cookies_sent = jar.filter_cookies(URL("http://example.com/")) assert cookies_sent.output(header='Cookie:') == "" class TestCookieJarBase(unittest.TestCase): def setUp(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(None) # N.B. those need to be overridden in child test cases self.jar = CookieJar(loop=self.loop) def tearDown(self): self.loop.close() def request_reply_with_same_url(self, url): self.jar.update_cookies(self.cookies_to_send) cookies_sent = self.jar.filter_cookies(URL(url)) self.jar.clear() self.jar.update_cookies(self.cookies_to_receive, URL(url)) cookies_received = SimpleCookie() for cookie in self.jar: dict.__setitem__(cookies_received, cookie.key, cookie) self.jar.clear() return cookies_sent, cookies_received class TestCookieJarSafe(TestCookieJarBase): def setUp(self): super().setUp() self.cookies_to_send = SimpleCookie( "shared-cookie=first; " "domain-cookie=second; Domain=example.com; " "subdomain1-cookie=third; Domain=test1.example.com; " "subdomain2-cookie=fourth; Domain=test2.example.com; " "dotted-domain-cookie=fifth; Domain=.example.com; " "different-domain-cookie=sixth; Domain=different.org; " "secure-cookie=seventh; Domain=secure.com; Secure; " "no-path-cookie=eighth; Domain=pathtest.com; " "path1-cookie=nineth; Domain=pathtest.com; Path=/; " "path2-cookie=tenth; Domain=pathtest.com; Path=/one; " "path3-cookie=eleventh; Domain=pathtest.com; Path=/one/two; " "path4-cookie=twelfth; Domain=pathtest.com; Path=/one/two/; " "expires-cookie=thirteenth; Domain=expirestest.com; Path=/;" " Expires=Tue, 1 Jan 1980 12:00:00 GMT; " "max-age-cookie=fourteenth; Domain=maxagetest.com; Path=/;" " Max-Age=60; " "invalid-max-age-cookie=fifteenth; Domain=invalid-values.com; " " Max-Age=string; " "invalid-expires-cookie=sixteenth; Domain=invalid-values.com; " " Expires=string;" ) self.cookies_to_receive = SimpleCookie( "unconstrained-cookie=first; Path=/; " "domain-cookie=second; Domain=example.com; Path=/; " "subdomain1-cookie=third; Domain=test1.example.com; Path=/; " "subdomain2-cookie=fourth; Domain=test2.example.com; Path=/; " "dotted-domain-cookie=fifth; Domain=.example.com; Path=/; " "different-domain-cookie=sixth; Domain=different.org; Path=/; " "no-path-cookie=seventh; Domain=pathtest.com; " "path-cookie=eighth; Domain=pathtest.com; Path=/somepath; " "wrong-path-cookie=nineth; Domain=pathtest.com; Path=somepath;" ) self.jar = CookieJar(loop=self.loop) def timed_request(self, url, update_time, send_time): with mock.patch.object(self.loop, 'time', return_value=update_time): self.jar.update_cookies(self.cookies_to_send) with mock.patch.object(self.loop, 'time', return_value=send_time): cookies_sent = self.jar.filter_cookies(URL(url)) self.jar.clear() return cookies_sent def test_domain_filter_same_host(self): cookies_sent, cookies_received = ( self.request_reply_with_same_url("http://example.com/")) self.assertEqual(set(cookies_sent.keys()), { "shared-cookie", "domain-cookie", "dotted-domain-cookie" }) self.assertEqual(set(cookies_received.keys()), { "unconstrained-cookie", "domain-cookie", "dotted-domain-cookie" }) def test_domain_filter_same_host_and_subdomain(self): cookies_sent, cookies_received = ( self.request_reply_with_same_url("http://test1.example.com/")) self.assertEqual(set(cookies_sent.keys()), { "shared-cookie", "domain-cookie", "subdomain1-cookie", "dotted-domain-cookie" }) self.assertEqual(set(cookies_received.keys()), { "unconstrained-cookie", "domain-cookie", "subdomain1-cookie", "dotted-domain-cookie" }) def test_domain_filter_same_host_diff_subdomain(self): cookies_sent, cookies_received = ( self.request_reply_with_same_url("http://different.example.com/")) self.assertEqual(set(cookies_sent.keys()), { "shared-cookie", "domain-cookie", "dotted-domain-cookie" }) self.assertEqual(set(cookies_received.keys()), { "unconstrained-cookie", "domain-cookie", "dotted-domain-cookie" }) def test_domain_filter_diff_host(self): cookies_sent, cookies_received = ( self.request_reply_with_same_url("http://different.org/")) self.assertEqual(set(cookies_sent.keys()), { "shared-cookie", "different-domain-cookie" }) self.assertEqual(set(cookies_received.keys()), { "unconstrained-cookie", "different-domain-cookie" }) def test_domain_filter_host_only(self): self.jar.update_cookies(self.cookies_to_receive, URL("http://example.com/")) cookies_sent = self.jar.filter_cookies(URL("http://example.com/")) self.assertIn("unconstrained-cookie", set(cookies_sent.keys())) cookies_sent = self.jar.filter_cookies(URL("http://different.org/")) self.assertNotIn("unconstrained-cookie", set(cookies_sent.keys())) def test_secure_filter(self): cookies_sent, _ = ( self.request_reply_with_same_url("http://secure.com/")) self.assertEqual(set(cookies_sent.keys()), { "shared-cookie" }) cookies_sent, _ = ( self.request_reply_with_same_url("https://secure.com/")) self.assertEqual(set(cookies_sent.keys()), { "shared-cookie", "secure-cookie" }) def test_path_filter_root(self): cookies_sent, _ = ( self.request_reply_with_same_url("http://pathtest.com/")) self.assertEqual(set(cookies_sent.keys()), { "shared-cookie", "no-path-cookie", "path1-cookie" }) def test_path_filter_folder(self): cookies_sent, _ = ( self.request_reply_with_same_url("http://pathtest.com/one/")) self.assertEqual(set(cookies_sent.keys()), { "shared-cookie", "no-path-cookie", "path1-cookie", "path2-cookie" }) def test_path_filter_file(self): cookies_sent, _ = self.request_reply_with_same_url( "http://pathtest.com/one/two") self.assertEqual(set(cookies_sent.keys()), { "shared-cookie", "no-path-cookie", "path1-cookie", "path2-cookie", "path3-cookie" }) def test_path_filter_subfolder(self): cookies_sent, _ = self.request_reply_with_same_url( "http://pathtest.com/one/two/") self.assertEqual(set(cookies_sent.keys()), { "shared-cookie", "no-path-cookie", "path1-cookie", "path2-cookie", "path3-cookie", "path4-cookie" }) def test_path_filter_subsubfolder(self): cookies_sent, _ = self.request_reply_with_same_url( "http://pathtest.com/one/two/three/") self.assertEqual(set(cookies_sent.keys()), { "shared-cookie", "no-path-cookie", "path1-cookie", "path2-cookie", "path3-cookie", "path4-cookie" }) def test_path_filter_different_folder(self): cookies_sent, _ = ( self.request_reply_with_same_url("http://pathtest.com/hundred/")) self.assertEqual(set(cookies_sent.keys()), { "shared-cookie", "no-path-cookie", "path1-cookie" }) def test_path_value(self): _, cookies_received = ( self.request_reply_with_same_url("http://pathtest.com/")) self.assertEqual(set(cookies_received.keys()), { "unconstrained-cookie", "no-path-cookie", "path-cookie", "wrong-path-cookie" }) self.assertEqual(cookies_received["no-path-cookie"]["path"], "/") self.assertEqual(cookies_received["path-cookie"]["path"], "/somepath") self.assertEqual(cookies_received["wrong-path-cookie"]["path"], "/") def test_expires(self): ts_before = datetime.datetime( 1975, 1, 1, tzinfo=datetime.timezone.utc).timestamp() ts_after = datetime.datetime( 2115, 1, 1, tzinfo=datetime.timezone.utc).timestamp() cookies_sent = self.timed_request( "http://expirestest.com/", ts_before, ts_before) self.assertEqual(set(cookies_sent.keys()), { "shared-cookie", "expires-cookie" }) cookies_sent = self.timed_request( "http://expirestest.com/", ts_before, ts_after) self.assertEqual(set(cookies_sent.keys()), { "shared-cookie" }) def test_max_age(self): cookies_sent = self.timed_request( "http://maxagetest.com/", 1000, 1000) self.assertEqual(set(cookies_sent.keys()), { "shared-cookie", "max-age-cookie" }) cookies_sent = self.timed_request( "http://maxagetest.com/", 1000, 2000) self.assertEqual(set(cookies_sent.keys()), { "shared-cookie" }) def test_invalid_values(self): cookies_sent, cookies_received = ( self.request_reply_with_same_url("http://invalid-values.com/")) self.assertEqual(set(cookies_sent.keys()), { "shared-cookie", "invalid-max-age-cookie", "invalid-expires-cookie" }) cookie = cookies_sent["invalid-max-age-cookie"] self.assertEqual(cookie["max-age"], "") cookie = cookies_sent["invalid-expires-cookie"] self.assertEqual(cookie["expires"], "") aiohttp-1.2.0/tests/test_client_functional_oldstyle.py0000664000175000017500000007023613025134363024230 0ustar travistravis00000000000000"""HTTP client functional tests.""" import asyncio import binascii import cgi import contextlib import email.parser import gc import http.cookies import http.server import io import json import logging import os import os.path import re import ssl import sys import threading import traceback import unittest import urllib.parse from unittest import mock from multidict import MultiDict import aiohttp from aiohttp import client, helpers, server, test_utils from aiohttp.multipart import MultipartWriter from aiohttp.test_utils import run_briefly, unused_port @contextlib.contextmanager def run_server(loop, *, listen_addr=('127.0.0.1', 0), use_ssl=False, router=None): properties = {} transports = [] class HttpRequestHandler: def __init__(self, addr): host, port = addr self.host = host self.port = port self.address = addr self._url = '{}://{}:{}'.format( 'https' if use_ssl else 'http', host, port) def __getitem__(self, key): return properties[key] def __setitem__(self, key, value): properties[key] = value def url(self, *suffix): return urllib.parse.urljoin( self._url, '/'.join(str(s) for s in suffix)) class TestHttpServer(server.ServerHttpProtocol): def connection_made(self, transport): transports.append(transport) super().connection_made(transport) def handle_request(self, message, payload): if properties.get('close', False): return for hdr, val in message.headers.items(): if (hdr.upper() == 'EXPECT') and (val == '100-continue'): self.transport.write(b'HTTP/1.0 100 Continue\r\n\r\n') break body = yield from payload.read() rob = router( self, properties, self.transport, message, body) rob.dispatch() if use_ssl: here = os.path.join(os.path.dirname(__file__), '..', 'tests') keyfile = os.path.join(here, 'sample.key') certfile = os.path.join(here, 'sample.crt') sslcontext = ssl.SSLContext(ssl.PROTOCOL_SSLv23) sslcontext.load_cert_chain(certfile, keyfile) else: sslcontext = None def run(loop, fut): thread_loop = asyncio.new_event_loop() asyncio.set_event_loop(thread_loop) host, port = listen_addr server_coroutine = thread_loop.create_server( lambda: TestHttpServer(keep_alive=0.5), host, port, ssl=sslcontext) server = thread_loop.run_until_complete(server_coroutine) waiter = helpers.create_future(thread_loop) loop.call_soon_threadsafe( fut.set_result, (thread_loop, waiter, server.sockets[0].getsockname())) try: thread_loop.run_until_complete(waiter) finally: # call pending connection_made if present run_briefly(thread_loop) # close opened transports for tr in transports: tr.close() run_briefly(thread_loop) # call close callbacks server.close() thread_loop.stop() thread_loop.close() gc.collect() fut = helpers.create_future(loop) server_thread = threading.Thread(target=run, args=(loop, fut)) server_thread.start() thread_loop, waiter, addr = loop.run_until_complete(fut) try: yield HttpRequestHandler(addr) finally: thread_loop.call_soon_threadsafe(waiter.set_result, None) server_thread.join() class Router: _response_version = "1.1" _responses = http.server.BaseHTTPRequestHandler.responses def __init__(self, srv, props, transport, message, payload): # headers self._headers = http.client.HTTPMessage() for hdr, val in message.headers.items(): self._headers.add_header(hdr, val) self._srv = srv self._props = props self._transport = transport self._method = message.method self._uri = message.path self._version = message.version self._compression = message.compression self._body = payload url = urllib.parse.urlsplit(self._uri) self._path = url.path self._query = url.query @staticmethod def define(rmatch): def wrapper(fn): f_locals = sys._getframe(1).f_locals mapping = f_locals.setdefault('_mapping', []) mapping.append((re.compile(rmatch), fn.__name__)) return fn return wrapper def dispatch(self): # pragma: no cover for route, fn in self._mapping: match = route.match(self._path) if match is not None: try: return getattr(self, fn)(match) except Exception: out = io.StringIO() traceback.print_exc(file=out) self._response(500, out.getvalue()) return return self._response(self._start_response(404)) def _start_response(self, code): return aiohttp.Response(self._srv.writer, code) def _response(self, response, body=None, headers=None, chunked=False, write_body=None): r_headers = {} for key, val in self._headers.items(): key = '-'.join(p.capitalize() for p in key.split('-')) r_headers[key] = val encoding = self._headers.get('content-encoding', '').lower() if 'gzip' in encoding: # pragma: no cover cmod = 'gzip' elif 'deflate' in encoding: cmod = 'deflate' else: cmod = '' resp = { 'method': self._method, 'version': '%s.%s' % self._version, 'path': self._uri, 'headers': r_headers, 'origin': self._transport.get_extra_info('addr', ' ')[0], 'query': self._query, 'form': {}, 'compression': cmod, 'multipart-data': [] } if body: # pragma: no cover resp['content'] = body else: resp['content'] = self._body.decode('utf-8', 'ignore') ct = self._headers.get('content-type', '').lower() # application/x-www-form-urlencoded if ct == 'application/x-www-form-urlencoded': resp['form'] = urllib.parse.parse_qs(self._body.decode('latin1')) # multipart/form-data elif ct.startswith('multipart/form-data'): # pragma: no cover out = io.BytesIO() for key, val in self._headers.items(): out.write(bytes('{}: {}\r\n'.format(key, val), 'latin1')) out.write(b'\r\n') out.write(self._body) out.write(b'\r\n') out.seek(0) message = email.parser.BytesParser().parse(out) if message.is_multipart(): for msg in message.get_payload(): if msg.is_multipart(): logging.warning('multipart msg is not expected') else: key, params = cgi.parse_header( msg.get('content-disposition', '')) params['data'] = msg.get_payload() params['content-type'] = msg.get_content_type() cte = msg.get('content-transfer-encoding') if cte is not None: resp['content-transfer-encoding'] = cte resp['multipart-data'].append(params) body = json.dumps(resp, indent=4, sort_keys=True) # default headers hdrs = [('Connection', 'close'), ('Content-Type', 'application/json')] if chunked: hdrs.append(('Transfer-Encoding', 'chunked')) else: hdrs.append(('Content-Length', str(len(body)))) # extra headers if headers: hdrs.extend(headers.items()) if chunked: response.enable_chunked_encoding() # headers response.add_headers(*hdrs) response.send_headers() # write payload if write_body: try: write_body(response, body) except: return else: response.write(body.encode('utf8')) response.write_eof() # keep-alive if response.keep_alive(): self._srv.keep_alive(True) class Functional(Router): @Router.define('/method/([A-Za-z]+)$') def method(self, match): self._response(self._start_response(200)) @Router.define('/keepalive$') def keepalive(self, match): self._transport._requests = getattr( self._transport, '_requests', 0) + 1 resp = self._start_response(200) if 'close=' in self._query: self._response( resp, 'requests={}'.format(self._transport._requests)) else: self._response( resp, 'requests={}'.format(self._transport._requests), headers={'CONNECTION': 'keep-alive'}) @Router.define('/cookies$') def cookies(self, match): cookies = http.cookies.SimpleCookie() cookies['c1'] = 'cookie1' cookies['c2'] = 'cookie2' resp = self._start_response(200) for cookie in cookies.output(header='').split('\n'): resp.add_header('Set-Cookie', cookie.strip()) resp.add_header( 'Set-Cookie', 'ISAWPLB{A7F52349-3531-4DA9-8776-F74BC6F4F1BB}=' '{925EC0B8-CB17-4BEB-8A35-1033813B0523}; HttpOnly; Path=/') self._response(resp) @Router.define('/cookies_partial$') def cookies_partial(self, match): cookies = http.cookies.SimpleCookie() cookies['c1'] = 'other_cookie1' resp = self._start_response(200) for cookie in cookies.output(header='').split('\n'): resp.add_header('Set-Cookie', cookie.strip()) self._response(resp) @Router.define('/broken$') def broken(self, match): resp = self._start_response(200) def write_body(resp, body): self._transport.close() raise ValueError() self._response( resp, body=json.dumps({'t': (b'0' * 1024).decode('utf-8')}), write_body=write_body) class TestHttpClientFunctional(unittest.TestCase): def setUp(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(None) def tearDown(self): # just in case if we have transport close callbacks test_utils.run_briefly(self.loop) self.loop.close() gc.collect() def test_POST_DATA_with_charset(self): with run_server(self.loop, router=Functional) as httpd: url = httpd.url('method', 'post') form = aiohttp.FormData() form.add_field('name', 'текст', content_type='text/plain; charset=koi8-r') r = self.loop.run_until_complete( client.request( 'post', url, data=form, loop=self.loop)) content = self.loop.run_until_complete(r.json()) self.assertEqual(1, len(content['multipart-data'])) field = content['multipart-data'][0] self.assertEqual('name', field['name']) self.assertEqual('текст', field['data']) self.assertEqual(r.status, 200) def test_POST_DATA_with_content_transfer_encoding(self): with run_server(self.loop, router=Functional) as httpd: url = httpd.url('method', 'post') form = aiohttp.FormData() form.add_field('name', b'123', content_transfer_encoding='base64') r = self.loop.run_until_complete( client.request( 'post', url, data=form, loop=self.loop)) content = self.loop.run_until_complete(r.json()) self.assertEqual(1, len(content['multipart-data'])) field = content['multipart-data'][0] self.assertEqual('name', field['name']) self.assertEqual(b'123', binascii.a2b_base64(field['data'])) # self.assertEqual('base64', field['content-transfer-encoding']) self.assertEqual(r.status, 200) def test_POST_MULTIPART(self): with run_server(self.loop, router=Functional) as httpd: url = httpd.url('method', 'post') with MultipartWriter('form-data') as writer: writer.append('foo') writer.append_json({'bar': 'баз'}) writer.append_form([('тест', '4'), ('сетс', '2')]) r = self.loop.run_until_complete( client.request('post', url, data=writer, loop=self.loop)) content = self.loop.run_until_complete(r.json()) self.assertEqual(3, len(content['multipart-data'])) self.assertEqual({'content-type': 'text/plain', 'data': 'foo'}, content['multipart-data'][0]) self.assertEqual({'content-type': 'application/json', 'data': '{"bar": "\\u0431\\u0430\\u0437"}'}, content['multipart-data'][1]) self.assertEqual( {'content-type': 'application/x-www-form-urlencoded', 'data': '%D1%82%D0%B5%D1%81%D1%82=4&' '%D1%81%D0%B5%D1%82%D1%81=2'}, content['multipart-data'][2]) self.assertEqual(r.status, 200) r.close() def test_POST_STREAM_DATA(self): with run_server(self.loop, router=Functional) as httpd: url = httpd.url('method', 'post') here = os.path.dirname(__file__) fname = os.path.join(here, 'sample.key') with open(fname, 'rb') as f: data = f.read() fut = helpers.create_future(self.loop) @asyncio.coroutine def stream(): yield from fut yield data self.loop.call_later(0.01, fut.set_result, True) r = self.loop.run_until_complete( client.request( 'post', url, data=stream(), headers={'Content-Length': str(len(data))}, loop=self.loop)) content = self.loop.run_until_complete(r.json()) r.close() self.assertEqual(str(len(data)), content['headers']['Content-Length']) self.assertEqual('application/octet-stream', content['headers']['Content-Type']) def test_POST_StreamReader(self): with run_server(self.loop, router=Functional) as httpd: url = httpd.url('method', 'post') here = os.path.dirname(__file__) fname = os.path.join(here, 'sample.key') with open(fname, 'rb') as f: data = f.read() stream = aiohttp.StreamReader(loop=self.loop) stream.feed_data(data) stream.feed_eof() r = self.loop.run_until_complete( client.request( 'post', url, data=stream, headers={'Content-Length': str(len(data))}, loop=self.loop)) content = self.loop.run_until_complete(r.json()) r.close() self.assertEqual(str(len(data)), content['headers']['Content-Length']) def test_POST_DataQueue(self): with run_server(self.loop, router=Functional) as httpd: url = httpd.url('method', 'post') here = os.path.dirname(__file__) fname = os.path.join(here, 'sample.key') with open(fname, 'rb') as f: data = f.read() stream = aiohttp.DataQueue(loop=self.loop) stream.feed_data(data[:100], 100) stream.feed_data(data[100:], len(data[100:])) stream.feed_eof() r = self.loop.run_until_complete( client.request( 'post', url, data=stream, headers={'Content-Length': str(len(data))}, loop=self.loop)) content = self.loop.run_until_complete(r.json()) r.close() self.assertEqual(str(len(data)), content['headers']['Content-Length']) def test_POST_ChunksQueue(self): with run_server(self.loop, router=Functional) as httpd: url = httpd.url('method', 'post') here = os.path.dirname(__file__) fname = os.path.join(here, 'sample.key') with open(fname, 'rb') as f: data = f.read() stream = aiohttp.ChunksQueue(loop=self.loop) stream.feed_data(data[:100], 100) d = data[100:] stream.feed_data(d, len(d)) stream.feed_eof() r = self.loop.run_until_complete( client.request( 'post', url, data=stream, headers={'Content-Length': str(len(data))}, loop=self.loop)) content = self.loop.run_until_complete(r.json()) r.close() self.assertEqual(str(len(data)), content['headers']['Content-Length']) def test_request_conn_closed(self): with run_server(self.loop, router=Functional) as httpd: httpd['close'] = True with self.assertRaises(aiohttp.ClientHttpProcessingError): self.loop.run_until_complete( client.request('get', httpd.url('method', 'get'), loop=self.loop)) def test_session_close(self): conn = aiohttp.TCPConnector(loop=self.loop) with run_server(self.loop, router=Functional) as httpd: r = self.loop.run_until_complete( client.request( 'get', httpd.url('keepalive') + '?close=1', connector=conn, loop=self.loop)) self.assertEqual(r.status, 200) content = self.loop.run_until_complete(r.json()) self.assertEqual(content['content'], 'requests=1') r.close() r = self.loop.run_until_complete( client.request('get', httpd.url('keepalive'), connector=conn, loop=self.loop)) self.assertEqual(r.status, 200) content = self.loop.run_until_complete(r.json()) self.assertEqual(content['content'], 'requests=1') r.close() conn.close() def test_multidict_headers(self): with run_server(self.loop, router=Functional) as httpd: url = httpd.url('method', 'post') data = b'sample data' r = self.loop.run_until_complete( client.request( 'post', url, data=data, headers=MultiDict( {'Content-Length': str(len(data))}), loop=self.loop)) content = self.loop.run_until_complete(r.json()) r.close() self.assertEqual(str(len(data)), content['headers']['Content-Length']) def test_close_implicit_connector(self): @asyncio.coroutine def go(url): r = yield from client.request('GET', url, loop=self.loop) connection = r.connection self.assertIsNotNone(connection) connector = connection._connector self.assertIsNotNone(connector) yield from r.read() self.assertEqual(0, len(connector._conns)) with run_server(self.loop, router=Functional) as httpd: url = httpd.url('keepalive') self.loop.run_until_complete(go(url)) def test_dont_close_explicit_connector(self): @asyncio.coroutine def go(url): connector = aiohttp.TCPConnector(loop=self.loop) r = yield from client.request('GET', url, connector=connector, loop=self.loop) yield from r.read() self.assertEqual(1, len(connector._conns)) connector.close() with run_server(self.loop, router=Functional) as httpd: url = httpd.url('keepalive') self.loop.run_until_complete(go(url)) def test_server_close_keepalive_connection(self): class Proto(asyncio.Protocol): def connection_made(self, transport): self.transp = transport self.data = b'' def data_received(self, data): self.data += data if data.endswith(b'\r\n\r\n'): self.transp.write( b'HTTP/1.1 200 OK\r\n' b'CONTENT-LENGTH: 2\r\n' b'CONNECTION: close\r\n' b'\r\n' b'ok') self.transp.close() def connection_lost(self, exc): self.transp = None @asyncio.coroutine def go(): server = yield from self.loop.create_server( Proto, '127.0.0.1', unused_port()) addr = server.sockets[0].getsockname() connector = aiohttp.TCPConnector(loop=self.loop) url = 'http://{}:{}/'.format(*addr) for i in range(2): r = yield from client.request('GET', url, connector=connector, loop=self.loop) yield from r.read() self.assertEqual(0, len(connector._conns)) connector.close() server.close() yield from server.wait_closed() self.loop.run_until_complete(go()) def test_handle_keepalive_on_closed_connection(self): class Proto(asyncio.Protocol): def connection_made(self, transport): self.transp = transport self.data = b'' def data_received(self, data): self.data += data if data.endswith(b'\r\n\r\n'): self.transp.write( b'HTTP/1.1 200 OK\r\n' b'CONTENT-LENGTH: 2\r\n' b'\r\n' b'ok') self.transp.close() def connection_lost(self, exc): self.transp = None @asyncio.coroutine def go(): server = yield from self.loop.create_server( Proto, '127.0.0.1', unused_port()) addr = server.sockets[0].getsockname() connector = aiohttp.TCPConnector(loop=self.loop) url = 'http://{}:{}/'.format(*addr) r = yield from client.request('GET', url, connector=connector, loop=self.loop) yield from r.read() self.assertEqual(1, len(connector._conns)) with self.assertRaises(aiohttp.ClientError): yield from client.request('GET', url, connector=connector, loop=self.loop) self.assertEqual(0, len(connector._conns)) connector.close() server.close() yield from server.wait_closed() self.loop.run_until_complete(go()) @mock.patch('aiohttp.client_reqrep.client_logger') def test_session_cookies(self, m_log): with run_server(self.loop, router=Functional) as httpd: session = client.ClientSession(loop=self.loop) resp = self.loop.run_until_complete( session.request('get', httpd.url('cookies'))) self.assertEqual(resp.cookies['c1'].value, 'cookie1') self.assertEqual(resp.cookies['c2'].value, 'cookie2') resp.close() # Add the received cookies as shared for sending them to the test # server, which is only accessible via IP session.cookie_jar.update_cookies(resp.cookies) # Assert, that we send those cookies in next requests r = self.loop.run_until_complete( session.request('get', httpd.url('method', 'get'))) self.assertEqual(r.status, 200) content = self.loop.run_until_complete(r.json()) self.assertEqual( content['headers']['Cookie'], 'c1=cookie1; c2=cookie2') r.close() session.close() def test_session_headers(self): with run_server(self.loop, router=Functional) as httpd: session = client.ClientSession( loop=self.loop, headers={ "X-Real-IP": "192.168.0.1" }) r = self.loop.run_until_complete( session.request('get', httpd.url('method', 'get'))) self.assertEqual(r.status, 200) content = self.loop.run_until_complete(r.json()) self.assertIn( "X-Real-Ip", content['headers']) self.assertEqual( content['headers']["X-Real-Ip"], "192.168.0.1") r.close() session.close() def test_session_headers_merge(self): with run_server(self.loop, router=Functional) as httpd: session = client.ClientSession( loop=self.loop, headers=[ ("X-Real-IP", "192.168.0.1"), ("X-Sent-By", "requests")]) r = self.loop.run_until_complete( session.request('get', httpd.url('method', 'get'), headers={"X-Sent-By": "aiohttp"})) self.assertEqual(r.status, 200) content = self.loop.run_until_complete(r.json()) self.assertIn( "X-Real-Ip", content['headers']) self.assertIn( "X-Sent-By", content['headers']) self.assertEqual( content['headers']["X-Real-Ip"], "192.168.0.1") self.assertEqual( content['headers']["X-Sent-By"], "aiohttp") r.close() session.close() def test_session_auth(self): with run_server(self.loop, router=Functional) as httpd: session = client.ClientSession( loop=self.loop, auth=helpers.BasicAuth("login", "pass")) r = self.loop.run_until_complete( session.request('get', httpd.url('method', 'get'))) self.assertEqual(r.status, 200) content = self.loop.run_until_complete(r.json()) self.assertIn( "Authorization", content['headers']) self.assertEqual( content['headers']["Authorization"], "Basic bG9naW46cGFzcw==") r.close() session.close() def test_session_auth_override(self): with run_server(self.loop, router=Functional) as httpd: session = client.ClientSession( loop=self.loop, auth=helpers.BasicAuth("login", "pass")) r = self.loop.run_until_complete( session.request('get', httpd.url('method', 'get'), auth=helpers.BasicAuth("other_login", "pass"))) self.assertEqual(r.status, 200) content = self.loop.run_until_complete(r.json()) self.assertIn( "Authorization", content['headers']) self.assertEqual( content['headers']["Authorization"], "Basic b3RoZXJfbG9naW46cGFzcw==") r.close() session.close() def test_session_auth_header_conflict(self): with run_server(self.loop, router=Functional) as httpd: session = client.ClientSession( loop=self.loop, auth=helpers.BasicAuth("login", "pass")) headers = {'Authorization': "Basic b3RoZXJfbG9naW46cGFzcw=="} with self.assertRaises(ValueError): self.loop.run_until_complete( session.request('get', httpd.url('method', 'get'), headers=headers)) session.close() aiohttp-1.2.0/tests/sample.key0000664000175000017500000000156713025134363017174 0ustar travistravis00000000000000-----BEGIN RSA PRIVATE KEY----- MIICXQIBAAKBgQCnt3s+J7L0xP/YdAQOacpPi9phlrzKZhcXL3XMu2LCUg2fNJpx /47Vc5TZSaO11uO7gdwVz3Z7Q2epAgwo59JLffLt5fia8+a/SlPweI/j4+wcIIIi qusnLfpqR8cIAavgZ06cLYCDvb9wMlheIvSJY12skc1nnphWS2YJ0Xm6uQIDAQAB AoGABfm8k19Yue3W68BecKEGS0VBV57GRTPT+MiBGvVGNIQ15gk6w3sGfMZsdD1y bsUkQgcDb2d/4i5poBTpl/+Cd41V+c20IC/sSl5X1IEreHMKSLhy/uyjyiyfXlP1 iXhToFCgLWwENWc8LzfUV8vuAV5WG6oL9bnudWzZxeqx8V0CQQDR7xwVj6LN70Eb DUhSKLkusmFw5Gk9NJ/7wZ4eHg4B8c9KNVvSlLCLhcsVTQXuqYeFpOqytI45SneP lr0vrvsDAkEAzITYiXu6ox5huDCG7imX2W9CAYuX638urLxBqBXMS7GqBzojD6RL 21Q8oPwJWJquERa3HDScq1deiQbM9uKIkwJBAIa1PLslGN216Xv3UPHPScyKD/aF ynXIv+OnANPoiyp6RH4ksQ/18zcEGiVH8EeNpvV9tlAHhb+DZibQHgNr74sCQQC0 zhToplu/bVKSlUQUNO0rqrI9z30FErDewKeCw5KSsIRSU1E/uM3fHr9iyq4wiL6u GNjUtKZ0y46lsT9uW6LFAkB5eqeEQnshAdr3X5GykWHJ8DDGBXPPn6Rce1NX4RSq V9khG2z1bFyfo+hMqpYnF2k32hVq3E54RS8YYnwBsVof -----END RSA PRIVATE KEY----- aiohttp-1.2.0/tests/test_web_middleware.py0000664000175000017500000000476513025134363021567 0ustar travistravis00000000000000import asyncio import pytest from aiohttp import web @asyncio.coroutine def test_middleware_modifies_response(loop, test_client): @asyncio.coroutine def handler(request): return web.Response(body=b'OK') @asyncio.coroutine def middleware_factory(app, handler): @asyncio.coroutine def middleware(request): resp = yield from handler(request) assert 200 == resp.status resp.set_status(201) resp.text = resp.text + '[MIDDLEWARE]' return resp return middleware app = web.Application(loop=loop) app.middlewares.append(middleware_factory) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.get('/') assert 201 == resp.status txt = yield from resp.text() assert 'OK[MIDDLEWARE]' == txt @asyncio.coroutine def test_middleware_handles_exception(loop, test_client): @asyncio.coroutine def handler(request): raise RuntimeError('Error text') @asyncio.coroutine def middleware_factory(app, handler): @asyncio.coroutine def middleware(request): with pytest.raises(RuntimeError) as ctx: yield from handler(request) return web.Response(status=501, text=str(ctx.value) + '[MIDDLEWARE]') return middleware app = web.Application(loop=loop) app.middlewares.append(middleware_factory) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.get('/') assert 501 == resp.status txt = yield from resp.text() assert 'Error text[MIDDLEWARE]' == txt @asyncio.coroutine def test_middleware_chain(loop, test_client): @asyncio.coroutine def handler(request): return web.Response(text='OK') def make_factory(num): @asyncio.coroutine def factory(app, handler): def middleware(request): resp = yield from handler(request) resp.text = resp.text + '[{}]'.format(num) return resp return middleware return factory app = web.Application(loop=loop) app.middlewares.append(make_factory(1)) app.middlewares.append(make_factory(2)) app.router.add_route('GET', '/', handler) client = yield from test_client(app) resp = yield from client.get('/') assert 200 == resp.status txt = yield from resp.text() assert 'OK[2][1]' == txt aiohttp-1.2.0/tests/test_web_application.py0000664000175000017500000001144713025134363021750 0ustar travistravis00000000000000import asyncio from unittest import mock import pytest from aiohttp import helpers, log, web from aiohttp.abc import AbstractRouter def test_app_ctor(loop): app = web.Application(loop=loop) assert loop is app.loop assert app.logger is log.web_logger def test_app_call(loop): app = web.Application(loop=loop) assert app is app() def test_app_default_loop(loop): asyncio.set_event_loop(loop) app = web.Application() assert loop is app.loop @pytest.mark.parametrize('debug', [True, False]) def test_app_make_handler_debug_exc(loop, mocker, debug): app = web.Application(loop=loop, debug=debug) srv = mocker.patch('aiohttp.web.Server') app.make_handler() with pytest.warns(DeprecationWarning) as exc: app.make_handler(debug=debug) assert 'parameter is deprecated' in exc[0].message.args[0] assert srv.call_count == 2 srv.assert_called_with(app._handle, request_factory=app._make_request, loop=loop, debug=debug) with pytest.raises(ValueError) as exc: app.make_handler(debug=not debug) assert 'The value of `debug` parameter conflicts with the' in str(exc) @asyncio.coroutine def test_app_register_on_finish(loop): app = web.Application(loop=loop) cb1 = mock.Mock() cb2 = mock.Mock() app.on_cleanup.append(cb1) app.on_cleanup.append(cb2) yield from app.cleanup() cb1.assert_called_once_with(app) cb2.assert_called_once_with(app) @asyncio.coroutine def test_app_register_coro(loop): app = web.Application(loop=loop) fut = helpers.create_future(loop) @asyncio.coroutine def cb(app): yield from asyncio.sleep(0.001, loop=loop) fut.set_result(123) app.on_cleanup.append(cb) yield from app.cleanup() assert fut.done() assert 123 == fut.result() @asyncio.coroutine def test_app_register_and_finish_are_deprecated(loop): app = web.Application(loop=loop) cb1 = mock.Mock() cb2 = mock.Mock() with pytest.warns(DeprecationWarning): app.register_on_finish(cb1, 1, b=2) with pytest.warns(DeprecationWarning): app.register_on_finish(cb2, 2, c=3) with pytest.warns(DeprecationWarning): yield from app.finish() cb1.assert_called_once_with(app, 1, b=2) cb2.assert_called_once_with(app, 2, c=3) def test_non_default_router(loop): router = mock.Mock(spec=AbstractRouter) app = web.Application(loop=loop, router=router) assert router is app.router def test_logging(loop): logger = mock.Mock() app = web.Application(loop=loop) app.logger = logger assert app.logger is logger @asyncio.coroutine def test_on_shutdown(loop): app = web.Application(loop=loop) called = False @asyncio.coroutine def on_shutdown(app_param): nonlocal called assert app is app_param called = True app.on_shutdown.append(on_shutdown) yield from app.shutdown() assert called @asyncio.coroutine def test_on_startup(loop): app = web.Application(loop=loop) blocking_called = False long_running1_called = False long_running2_called = False all_long_running_called = False def on_startup_blocking(app_param): nonlocal blocking_called assert app is app_param blocking_called = True @asyncio.coroutine def long_running1(app_param): nonlocal long_running1_called assert app is app_param long_running1_called = True @asyncio.coroutine def long_running2(app_param): nonlocal long_running2_called assert app is app_param long_running2_called = True @asyncio.coroutine def on_startup_all_long_running(app_param): nonlocal all_long_running_called assert app is app_param all_long_running_called = True return (yield from asyncio.gather(long_running1(app_param), long_running2(app_param), loop=app_param.loop)) app.on_startup.append(on_startup_blocking) app.on_startup.append(on_startup_all_long_running) yield from app.startup() assert blocking_called assert long_running1_called assert long_running2_called assert all_long_running_called def test_app_delitem(loop): app = web.Application(loop=loop) app['key'] = 'value' assert len(app) == 1 del app['key'] assert len(app) == 0 def test_secure_proxy_ssl_header_default(loop): app = web.Application(loop=loop) assert app._secure_proxy_ssl_header is None @asyncio.coroutine def test_secure_proxy_ssl_header_non_default(loop): app = web.Application(loop=loop) hdr = ('X-Forwarded-Proto', 'https') app.make_handler(secure_proxy_ssl_header=hdr) assert app._secure_proxy_ssl_header is hdr aiohttp-1.2.0/tests/test_stream_protocol.py0000664000175000017500000000170113025134363022014 0ustar travistravis00000000000000from unittest import mock from aiohttp import parsers def test_connection_made(loop): tr = mock.Mock() proto = parsers.StreamProtocol(loop=loop) assert proto.transport is None proto.connection_made(tr) assert proto.transport is tr def test_connection_lost(loop): proto = parsers.StreamProtocol(loop=loop) proto.connection_made(mock.Mock()) proto.connection_lost(None) assert proto.transport is None assert proto.writer is None assert proto.reader._eof def test_connection_lost_exc(loop): proto = parsers.StreamProtocol(loop=loop) proto.connection_made(mock.Mock()) exc = ValueError() proto.connection_lost(exc) assert proto.reader.exception() is exc def test_data_received(loop): proto = parsers.StreamProtocol(loop=loop) proto.connection_made(mock.Mock()) proto.reader = mock.Mock() proto.data_received(b'data') proto.reader.feed_data.assert_called_with(b'data') aiohttp-1.2.0/tests/test_client_session.py0000664000175000017500000003557213025134363021636 0ustar travistravis00000000000000import asyncio import contextlib import gc import http.cookies import re import types from unittest import mock import pytest from multidict import CIMultiDict, MultiDict from yarl import URL import aiohttp from aiohttp import web from aiohttp.client import ClientSession from aiohttp.connector import BaseConnector, TCPConnector @pytest.fixture def connector(loop): conn = BaseConnector(loop=loop) transp = mock.Mock() conn._conns['a'] = [(transp, 'proto', 123)] return conn @pytest.yield_fixture def create_session(loop): session = None def maker(*args, **kwargs): nonlocal session session = ClientSession(*args, loop=loop, **kwargs) return session yield maker if session is not None: session.close() @pytest.fixture def session(create_session): return create_session() @pytest.fixture def params(): return dict( headers={"Authorization": "Basic ..."}, max_redirects=2, encoding="latin1", version=aiohttp.HttpVersion10, compress="deflate", chunked=True, expect100=True, read_until_eof=False) def test_init_headers_simple_dict(create_session): session = create_session(headers={"h1": "header1", "h2": "header2"}) assert (sorted(session._default_headers.items()) == ([("H1", "header1"), ("H2", "header2")])) def test_init_headers_list_of_tuples(create_session): session = create_session(headers=[("h1", "header1"), ("h2", "header2"), ("h3", "header3")]) assert (session._default_headers == CIMultiDict([("h1", "header1"), ("h2", "header2"), ("h3", "header3")])) def test_init_headers_MultiDict(create_session): session = create_session(headers=MultiDict([("h1", "header1"), ("h2", "header2"), ("h3", "header3")])) assert (session._default_headers == CIMultiDict([("H1", "header1"), ("H2", "header2"), ("H3", "header3")])) def test_init_headers_list_of_tuples_with_duplicates(create_session): session = create_session(headers=[("h1", "header11"), ("h2", "header21"), ("h1", "header12")]) assert (session._default_headers == CIMultiDict([("H1", "header11"), ("H2", "header21"), ("H1", "header12")])) def test_init_cookies_with_simple_dict(create_session): session = create_session(cookies={"c1": "cookie1", "c2": "cookie2"}) cookies = session.cookie_jar.filter_cookies() assert set(cookies) == {'c1', 'c2'} assert cookies['c1'].value == 'cookie1' assert cookies['c2'].value == 'cookie2' def test_init_cookies_with_list_of_tuples(create_session): session = create_session(cookies=[("c1", "cookie1"), ("c2", "cookie2")]) cookies = session.cookie_jar.filter_cookies() assert set(cookies) == {'c1', 'c2'} assert cookies['c1'].value == 'cookie1' assert cookies['c2'].value == 'cookie2' def test_merge_headers(create_session): # Check incoming simple dict session = create_session(headers={"h1": "header1", "h2": "header2"}) headers = session._prepare_headers({"h1": "h1"}) assert isinstance(headers, CIMultiDict) assert headers == CIMultiDict([("h2", "header2"), ("h1", "h1")]) def test_merge_headers_with_multi_dict(create_session): session = create_session(headers={"h1": "header1", "h2": "header2"}) headers = session._prepare_headers(MultiDict([("h1", "h1")])) assert isinstance(headers, CIMultiDict) assert headers == CIMultiDict([("h2", "header2"), ("h1", "h1")]) def test_merge_headers_with_list_of_tuples(create_session): session = create_session(headers={"h1": "header1", "h2": "header2"}) headers = session._prepare_headers([("h1", "h1")]) assert isinstance(headers, CIMultiDict) assert headers == CIMultiDict([("h2", "header2"), ("h1", "h1")]) def test_merge_headers_with_list_of_tuples_duplicated_names(create_session): session = create_session(headers={"h1": "header1", "h2": "header2"}) headers = session._prepare_headers([("h1", "v1"), ("h1", "v2")]) assert isinstance(headers, CIMultiDict) assert headers == CIMultiDict([("H2", "header2"), ("H1", "v1"), ("H1", "v2")]) def test_http_GET(session, params): with mock.patch("aiohttp.client.ClientSession._request") as patched: session.get("http://test.example.com", params={"x": 1}, **params) assert patched.called, "`ClientSession._request` not called" assert list(patched.call_args) == [("GET", "http://test.example.com",), dict( params={"x": 1}, allow_redirects=True, **params)] def test_http_OPTIONS(session, params): with mock.patch("aiohttp.client.ClientSession._request") as patched: session.options("http://opt.example.com", params={"x": 2}, **params) assert patched.called, "`ClientSession._request` not called" assert list(patched.call_args) == [("OPTIONS", "http://opt.example.com",), dict( params={"x": 2}, allow_redirects=True, **params)] def test_http_HEAD(session, params): with mock.patch("aiohttp.client.ClientSession._request") as patched: session.head("http://head.example.com", params={"x": 2}, **params) assert patched.called, "`ClientSession._request` not called" assert list(patched.call_args) == [("HEAD", "http://head.example.com",), dict( params={"x": 2}, allow_redirects=False, **params)] def test_http_POST(session, params): with mock.patch("aiohttp.client.ClientSession._request") as patched: session.post("http://post.example.com", params={"x": 2}, data="Some_data", **params) assert patched.called, "`ClientSession._request` not called" assert list(patched.call_args) == [("POST", "http://post.example.com",), dict( params={"x": 2}, data="Some_data", **params)] def test_http_PUT(session, params): with mock.patch("aiohttp.client.ClientSession._request") as patched: session.put("http://put.example.com", params={"x": 2}, data="Some_data", **params) assert patched.called, "`ClientSession._request` not called" assert list(patched.call_args) == [("PUT", "http://put.example.com",), dict( params={"x": 2}, data="Some_data", **params)] def test_http_PATCH(session, params): with mock.patch("aiohttp.client.ClientSession._request") as patched: session.patch("http://patch.example.com", params={"x": 2}, data="Some_data", **params) assert patched.called, "`ClientSession._request` not called" assert list(patched.call_args) == [("PATCH", "http://patch.example.com",), dict( params={"x": 2}, data="Some_data", **params)] def test_http_DELETE(session, params): with mock.patch("aiohttp.client.ClientSession._request") as patched: session.delete("http://delete.example.com", params={"x": 2}, **params) assert patched.called, "`ClientSession._request` not called" assert list(patched.call_args) == [("DELETE", "http://delete.example.com",), dict( params={"x": 2}, **params)] def test_close(create_session, connector): session = create_session(connector=connector) session.close() assert session.connector is None assert connector.closed def test_closed(session): assert not session.closed session.close() assert session.closed def test_connector(create_session, loop): connector = TCPConnector(loop=loop) session = create_session(connector=connector) assert session.connector is connector def test_connector_loop(loop): with contextlib.ExitStack() as stack: another_loop = asyncio.new_event_loop() stack.enter_context(contextlib.closing(another_loop)) connector = TCPConnector(loop=another_loop) stack.enter_context(contextlib.closing(connector)) with pytest.raises(ValueError) as ctx: ClientSession(connector=connector, loop=loop) assert re.match("loop argument must agree with connector", str(ctx.value)) def test_detach(session): conn = session.connector try: assert not conn.closed session.detach() assert session.connector is None assert session.closed assert not conn.closed finally: conn.close() @asyncio.coroutine def test_request_closed_session(session): session.close() with pytest.raises(RuntimeError): yield from session.request('get', '/') def test_close_flag_for_closed_connector(session): conn = session.connector assert not session.closed conn.close() assert session.closed def test_double_close(connector, create_session): session = create_session(connector=connector) session.close() assert session.connector is None session.close() assert session.closed assert connector.closed def test_del(connector, loop): # N.B. don't use session fixture, it stores extra reference internally session = ClientSession(connector=connector, loop=loop) loop.set_exception_handler(lambda loop, ctx: None) with pytest.warns(ResourceWarning): del session gc.collect() def test_context_manager(connector, loop): with ClientSession(loop=loop, connector=connector) as session: pass assert session.closed def test_borrow_connector_loop(connector, create_session, loop): session = ClientSession(connector=connector, loop=None) try: assert session._loop, loop finally: session.close() @asyncio.coroutine def test_reraise_os_error(create_session): err = OSError(1, "permission error") req = mock.Mock() req_factory = mock.Mock(return_value=req) req.send = mock.Mock(side_effect=err) session = create_session(request_class=req_factory) @asyncio.coroutine def create_connection(req): # return self.transport, self.protocol return mock.Mock(), mock.Mock() session._connector._create_connection = create_connection with pytest.raises(aiohttp.ClientOSError) as ctx: yield from session.request('get', 'http://example.com') e = ctx.value assert e.errno == err.errno assert e.strerror == err.strerror @asyncio.coroutine def test_request_ctx_manager_props(loop): yield from asyncio.sleep(0, loop=loop) # to make it a task with aiohttp.ClientSession(loop=loop) as client: ctx_mgr = client.get('http://example.com') next(ctx_mgr) assert isinstance(ctx_mgr.gi_frame, types.FrameType) assert not ctx_mgr.gi_running assert isinstance(ctx_mgr.gi_code, types.CodeType) yield from asyncio.sleep(0.1, loop=loop) @asyncio.coroutine def test_cookie_jar_usage(loop, test_client): req_url = None jar = mock.Mock() jar.filter_cookies.return_value = None @asyncio.coroutine def handler(request): nonlocal req_url req_url = "http://%s/" % request.host resp = web.Response() resp.set_cookie("response", "resp_value") return resp app = web.Application(loop=loop) app.router.add_route('GET', '/', handler) session = yield from test_client(app, cookies={"request": "req_value"}, cookie_jar=jar) # Updating the cookie jar with initial user defined cookies jar.update_cookies.assert_called_with({"request": "req_value"}) jar.update_cookies.reset_mock() resp = yield from session.get("/") yield from resp.release() # Filtering the cookie jar before sending the request, # getting the request URL as only parameter jar.filter_cookies.assert_called_with(URL(req_url)) # Updating the cookie jar with the response cookies assert jar.update_cookies.called resp_cookies = jar.update_cookies.call_args[0][0] assert isinstance(resp_cookies, http.cookies.SimpleCookie) assert "response" in resp_cookies assert resp_cookies["response"].value == "resp_value" def test_session_default_version(loop): session = aiohttp.ClientSession(loop=loop) assert session.version == aiohttp.HttpVersion11 def test_session_loop(loop): session = aiohttp.ClientSession(loop=loop) assert session.loop is loop def test_proxy_str(session, params): with mock.patch("aiohttp.client.ClientSession._request") as patched: session.get("http://test.example.com", proxy='http://proxy.com', **params) assert patched.called, "`ClientSession._request` not called" assert list(patched.call_args) == [("GET", "http://test.example.com",), dict( allow_redirects=True, proxy='http://proxy.com', **params)] def test_create_session_outside_of_coroutine(loop): with pytest.warns(ResourceWarning): sess = ClientSession(loop=loop) sess.close() aiohttp-1.2.0/tests/test_websocket_handshake.py0000664000175000017500000001152013025134363022574 0ustar travistravis00000000000000"""Tests for http/websocket.py""" import base64 import hashlib import os from unittest import mock import multidict import pytest from aiohttp import errors, protocol from aiohttp._ws_impl import WS_KEY, do_handshake @pytest.fixture() def transport(): return mock.Mock() @pytest.fixture() def message(): headers = multidict.MultiDict() return protocol.RawRequestMessage( 'GET', '/path', (1, 0), headers, [], True, None) def gen_ws_headers(protocols=''): key = base64.b64encode(os.urandom(16)).decode() hdrs = [('Upgrade', 'websocket'), ('Connection', 'upgrade'), ('Sec-Websocket-Version', '13'), ('Sec-Websocket-Key', key)] if protocols: hdrs += [('Sec-Websocket-Protocol', protocols)] return hdrs, key def test_not_get(message, transport): with pytest.raises(errors.HttpProcessingError): do_handshake('POST', message.headers, transport) def test_no_upgrade(message, transport): with pytest.raises(errors.HttpBadRequest): do_handshake(message.method, message.headers, transport) def test_no_connection(message, transport): message.headers.extend([('Upgrade', 'websocket'), ('Connection', 'keep-alive')]) with pytest.raises(errors.HttpBadRequest): do_handshake(message.method, message.headers, transport) def test_protocol_version(message, transport): message.headers.extend([('Upgrade', 'websocket'), ('Connection', 'upgrade')]) with pytest.raises(errors.HttpBadRequest): do_handshake(message.method, message.headers, transport) message.headers.extend([('Upgrade', 'websocket'), ('Connection', 'upgrade'), ('Sec-Websocket-Version', '1')]) with pytest.raises(errors.HttpBadRequest): do_handshake(message.method, message.headers, transport) def test_protocol_key(message, transport): message.headers.extend([('Upgrade', 'websocket'), ('Connection', 'upgrade'), ('Sec-Websocket-Version', '13')]) with pytest.raises(errors.HttpBadRequest): do_handshake(message.method, message.headers, transport) message.headers.extend([('Upgrade', 'websocket'), ('Connection', 'upgrade'), ('Sec-Websocket-Version', '13'), ('Sec-Websocket-Key', '123')]) with pytest.raises(errors.HttpBadRequest): do_handshake(message.method, message.headers, transport) sec_key = base64.b64encode(os.urandom(2)) message.headers.extend([('Upgrade', 'websocket'), ('Connection', 'upgrade'), ('Sec-Websocket-Version', '13'), ('Sec-Websocket-Key', sec_key.decode())]) with pytest.raises(errors.HttpBadRequest): do_handshake(message.method, message.headers, transport) def test_handshake(message, transport): hdrs, sec_key = gen_ws_headers() message.headers.extend(hdrs) status, headers, parser, writer, protocol = do_handshake( message.method, message.headers, transport) assert status == 101 assert protocol is None key = base64.b64encode( hashlib.sha1(sec_key.encode() + WS_KEY).digest()) headers = dict(headers) assert headers['Sec-Websocket-Accept'] == key.decode() def test_handshake_protocol(message, transport): '''Tests if one protocol is returned by do_handshake''' proto = 'chat' message.headers.extend(gen_ws_headers(proto)[0]) _, resp_headers, _, _, protocol = do_handshake( message.method, message.headers, transport, protocols=[proto]) assert protocol == proto # also test if we reply with the protocol resp_headers = dict(resp_headers) assert resp_headers['Sec-Websocket-Protocol'] == proto def test_handshake_protocol_agreement(message, transport): '''Tests if the right protocol is selected given multiple''' best_proto = 'worse_proto' wanted_protos = ['best', 'chat', 'worse_proto'] server_protos = 'worse_proto,chat' message.headers.extend(gen_ws_headers(server_protos)[0]) _, resp_headers, _, _, protocol = do_handshake( message.method, message.headers, transport, protocols=wanted_protos) assert protocol == best_proto def test_handshake_protocol_unsupported(log, message, transport): '''Tests if a protocol mismatch handshake warns and returns None''' proto = 'chat' message.headers.extend(gen_ws_headers('test')[0]) with log('aiohttp.websocket') as ctx: _, _, _, _, protocol = do_handshake( message.method, message.headers, transport, protocols=[proto]) assert protocol is None assert (ctx.records[-1].msg == 'Client protocols %r don’t overlap server-known ones %r') aiohttp-1.2.0/tests/test_web_response.py0000664000175000017500000006434213025134363021305 0ustar travistravis00000000000000import asyncio import datetime import json import re from unittest import mock import pytest from multidict import CIMultiDict from aiohttp import hdrs, signals from aiohttp.protocol import HttpVersion, HttpVersion10, HttpVersion11 from aiohttp.test_utils import make_mocked_request from aiohttp.web import ContentCoding, Response, StreamResponse, json_response def make_request(method, path, headers=CIMultiDict(), version=HttpVersion11, **kwargs): app = kwargs.pop('app', None) or mock.Mock() app._debug = False app.on_response_prepare = signals.Signal(app) writer = kwargs.pop('writer', None) or mock.Mock() return make_mocked_request(method, path, headers, version=version, writer=writer, app=app, **kwargs) def test_stream_response_ctor(): resp = StreamResponse() assert 200 == resp.status assert resp.keep_alive is None def test_content_length(): resp = StreamResponse() assert resp.content_length is None def test_content_length_setter(): resp = StreamResponse() resp.content_length = 234 assert 234 == resp.content_length def test_drop_content_length_header_on_setting_len_to_None(): resp = StreamResponse() resp.content_length = 1 assert "1" == resp.headers['Content-Length'] resp.content_length = None assert 'Content-Length' not in resp.headers def test_set_content_length_to_None_on_non_set(): resp = StreamResponse() resp.content_length = None assert 'Content-Length' not in resp.headers resp.content_length = None assert 'Content-Length' not in resp.headers def test_setting_content_type(): resp = StreamResponse() resp.content_type = 'text/html' assert 'text/html' == resp.headers['content-type'] def test_setting_charset(): resp = StreamResponse() resp.content_type = 'text/html' resp.charset = 'koi8-r' assert 'text/html; charset=koi8-r' == resp.headers['content-type'] def test_default_charset(): resp = StreamResponse() assert resp.charset is None def test_reset_charset(): resp = StreamResponse() resp.content_type = 'text/html' resp.charset = None assert resp.charset is None def test_reset_charset_after_setting(): resp = StreamResponse() resp.content_type = 'text/html' resp.charset = 'koi8-r' resp.charset = None assert resp.charset is None def test_charset_without_content_type(): resp = StreamResponse() with pytest.raises(RuntimeError): resp.charset = 'koi8-r' def test_last_modified_initial(): resp = StreamResponse() assert resp.last_modified is None def test_last_modified_string(): resp = StreamResponse() dt = datetime.datetime(1990, 1, 2, 3, 4, 5, 0, datetime.timezone.utc) resp.last_modified = 'Mon, 2 Jan 1990 03:04:05 GMT' assert resp.last_modified == dt def test_last_modified_timestamp(): resp = StreamResponse() dt = datetime.datetime(1970, 1, 1, 0, 0, 0, 0, datetime.timezone.utc) resp.last_modified = 0 assert resp.last_modified == dt resp.last_modified = 0.0 assert resp.last_modified == dt def test_last_modified_datetime(): resp = StreamResponse() dt = datetime.datetime(2001, 2, 3, 4, 5, 6, 0, datetime.timezone.utc) resp.last_modified = dt assert resp.last_modified == dt def test_last_modified_reset(): resp = StreamResponse() resp.last_modified = 0 resp.last_modified = None assert resp.last_modified is None @asyncio.coroutine def test_start(): req = make_request('GET', '/') resp = StreamResponse() assert resp.keep_alive is None with mock.patch('aiohttp.web_reqrep.ResponseImpl'): msg = yield from resp.prepare(req) assert msg.send_headers.called msg2 = yield from resp.prepare(req) assert msg is msg2 assert resp.keep_alive req2 = make_request('GET', '/') with pytest.raises(RuntimeError): yield from resp.prepare(req2) @asyncio.coroutine def test_chunked_encoding(): req = make_request('GET', '/') resp = StreamResponse() assert not resp.chunked resp.enable_chunked_encoding() assert resp.chunked with mock.patch('aiohttp.web_reqrep.ResponseImpl'): msg = yield from resp.prepare(req) assert msg.chunked @asyncio.coroutine def test_chunk_size(): req = make_request('GET', '/') resp = StreamResponse() assert not resp.chunked resp.enable_chunked_encoding(chunk_size=8192) assert resp.chunked with mock.patch('aiohttp.web_reqrep.ResponseImpl'): msg = yield from resp.prepare(req) assert msg.chunked msg.add_chunking_filter.assert_called_with(8192) assert msg.filter is not None @asyncio.coroutine def test_chunked_encoding_forbidden_for_http_10(): req = make_request('GET', '/', version=HttpVersion10) resp = StreamResponse() resp.enable_chunked_encoding() with pytest.raises(RuntimeError) as ctx: yield from resp.prepare(req) assert re.match("Using chunked encoding is forbidden for HTTP/1.0", str(ctx.value)) @asyncio.coroutine def test_compression_no_accept(): req = make_request('GET', '/') resp = StreamResponse() assert not resp.chunked assert not resp.compression resp.enable_compression() assert resp.compression with mock.patch('aiohttp.web_reqrep.ResponseImpl'): msg = yield from resp.prepare(req) assert not msg.add_compression_filter.called @asyncio.coroutine def test_force_compression_no_accept_backwards_compat(): req = make_request('GET', '/') resp = StreamResponse() assert not resp.chunked assert not resp.compression resp.enable_compression(force=True) assert resp.compression with mock.patch('aiohttp.web_reqrep.ResponseImpl'): msg = yield from resp.prepare(req) assert msg.add_compression_filter.called assert msg.filter is not None @asyncio.coroutine def test_force_compression_false_backwards_compat(): req = make_request('GET', '/') resp = StreamResponse() assert not resp.compression resp.enable_compression(force=False) assert resp.compression with mock.patch('aiohttp.web_reqrep.ResponseImpl'): msg = yield from resp.prepare(req) assert not msg.add_compression_filter.called @asyncio.coroutine def test_compression_default_coding(): req = make_request( 'GET', '/', headers=CIMultiDict({hdrs.ACCEPT_ENCODING: 'gzip, deflate'})) resp = StreamResponse() assert not resp.chunked assert not resp.compression resp.enable_compression() assert resp.compression with mock.patch('aiohttp.web_reqrep.ResponseImpl'): msg = yield from resp.prepare(req) msg.add_compression_filter.assert_called_with('deflate') assert 'deflate' == resp.headers.get(hdrs.CONTENT_ENCODING) assert msg.filter is not None @asyncio.coroutine def test_force_compression_deflate(): req = make_request( 'GET', '/', headers=CIMultiDict({hdrs.ACCEPT_ENCODING: 'gzip, deflate'})) resp = StreamResponse() resp.enable_compression(ContentCoding.deflate) assert resp.compression with mock.patch('aiohttp.web_reqrep.ResponseImpl'): msg = yield from resp.prepare(req) msg.add_compression_filter.assert_called_with('deflate') assert 'deflate' == resp.headers.get(hdrs.CONTENT_ENCODING) @asyncio.coroutine def test_force_compression_no_accept_deflate(): req = make_request('GET', '/') resp = StreamResponse() resp.enable_compression(ContentCoding.deflate) assert resp.compression with mock.patch('aiohttp.web_reqrep.ResponseImpl'): msg = yield from resp.prepare(req) msg.add_compression_filter.assert_called_with('deflate') assert 'deflate' == resp.headers.get(hdrs.CONTENT_ENCODING) @asyncio.coroutine def test_force_compression_gzip(): req = make_request( 'GET', '/', headers=CIMultiDict({hdrs.ACCEPT_ENCODING: 'gzip, deflate'})) resp = StreamResponse() resp.enable_compression(ContentCoding.gzip) assert resp.compression with mock.patch('aiohttp.web_reqrep.ResponseImpl'): msg = yield from resp.prepare(req) msg.add_compression_filter.assert_called_with('gzip') assert 'gzip' == resp.headers.get(hdrs.CONTENT_ENCODING) @asyncio.coroutine def test_force_compression_no_accept_gzip(): req = make_request('GET', '/') resp = StreamResponse() resp.enable_compression(ContentCoding.gzip) assert resp.compression with mock.patch('aiohttp.web_reqrep.ResponseImpl'): msg = yield from resp.prepare(req) msg.add_compression_filter.assert_called_with('gzip') assert 'gzip' == resp.headers.get(hdrs.CONTENT_ENCODING) @asyncio.coroutine def test_delete_content_length_if_compression_enabled(): req = make_request('GET', '/') resp = Response(body=b'answer') assert 6 == resp.content_length resp.enable_compression(ContentCoding.gzip) with mock.patch('aiohttp.web_reqrep.ResponseImpl'): yield from resp.prepare(req) assert resp.content_length is None @asyncio.coroutine def test_write_non_byteish(): resp = StreamResponse() yield from resp.prepare(make_request('GET', '/')) with pytest.raises(AssertionError): resp.write(123) def test_write_before_start(): resp = StreamResponse() with pytest.raises(RuntimeError): resp.write(b'data') @asyncio.coroutine def test_cannot_write_after_eof(): resp = StreamResponse() writer = mock.Mock() yield from resp.prepare(make_request('GET', '/', writer=writer)) resp.write(b'data') writer.drain.return_value = () yield from resp.write_eof() writer.write.reset_mock() with pytest.raises(RuntimeError): resp.write(b'next data') assert not writer.write.called @asyncio.coroutine def test_cannot_write_eof_before_headers(): resp = StreamResponse() with pytest.raises(RuntimeError): yield from resp.write_eof() @asyncio.coroutine def test_cannot_write_eof_twice(): resp = StreamResponse() writer = mock.Mock() yield from resp.prepare(make_request('GET', '/', writer=writer)) resp.write(b'data') writer.drain.return_value = () yield from resp.write_eof() assert writer.write.called writer.write.reset_mock() yield from resp.write_eof() assert not writer.write.called @asyncio.coroutine def test_write_returns_drain(): resp = StreamResponse() yield from resp.prepare(make_request('GET', '/')) assert () == resp.write(b'data') @asyncio.coroutine def test_write_returns_empty_tuple_on_empty_data(): resp = StreamResponse() yield from resp.prepare(make_request('GET', '/')) assert () == resp.write(b'') def test_force_close(): resp = StreamResponse() assert resp.keep_alive is None resp.force_close() assert resp.keep_alive is False def test_response_cookies(): resp = StreamResponse() assert resp.cookies == {} assert str(resp.cookies) == '' resp.set_cookie('name', 'value') assert str(resp.cookies) == 'Set-Cookie: name=value; Path=/' resp.set_cookie('name', 'other_value') assert str(resp.cookies) == 'Set-Cookie: name=other_value; Path=/' resp.cookies['name'] = 'another_other_value' resp.cookies['name']['max-age'] = 10 assert (str(resp.cookies) == 'Set-Cookie: name=another_other_value; Max-Age=10; Path=/') resp.del_cookie('name') expected = ('Set-Cookie: name=("")?; ' 'expires=Thu, 01 Jan 1970 00:00:00 GMT; Max-Age=0; Path=/') assert re.match(expected, str(resp.cookies)) resp.set_cookie('name', 'value', domain='local.host') expected = 'Set-Cookie: name=value; Domain=local.host; Path=/' assert str(resp.cookies) == expected def test_response_cookie_path(): resp = StreamResponse() assert resp.cookies == {} resp.set_cookie('name', 'value', path='/some/path') assert str(resp.cookies) == 'Set-Cookie: name=value; Path=/some/path' resp.set_cookie('name', 'value', expires='123') assert (str(resp.cookies) == 'Set-Cookie: name=value; expires=123; Path=/') resp.set_cookie('name', 'value', domain='example.com', path='/home', expires='123', max_age='10', secure=True, httponly=True, version='2.0') assert (str(resp.cookies).lower() == 'set-cookie: name=value; ' 'domain=example.com; ' 'expires=123; ' 'httponly; ' 'max-age=10; ' 'path=/home; ' 'secure; ' 'version=2.0') def test_response_cookie__issue_del_cookie(): resp = StreamResponse() assert resp.cookies == {} assert str(resp.cookies) == '' resp.del_cookie('name') expected = ('Set-Cookie: name=("")?; ' 'expires=Thu, 01 Jan 1970 00:00:00 GMT; Max-Age=0; Path=/') assert re.match(expected, str(resp.cookies)) def test_cookie_set_after_del(): resp = StreamResponse() resp.del_cookie('name') resp.set_cookie('name', 'val') # check for Max-Age dropped expected = 'Set-Cookie: name=val; Path=/' assert str(resp.cookies) == expected def test_set_status_with_reason(): resp = StreamResponse() resp.set_status(200, "Everithing is fine!") assert 200 == resp.status assert "Everithing is fine!" == resp.reason @asyncio.coroutine def test_start_force_close(): req = make_request('GET', '/') resp = StreamResponse() resp.force_close() assert not resp.keep_alive msg = yield from resp.prepare(req) assert not resp.keep_alive assert msg.closing @asyncio.coroutine def test___repr__(): req = make_request('GET', '/path/to') resp = StreamResponse(reason=301) yield from resp.prepare(req) assert "" == repr(resp) def test___repr__not_started(): resp = StreamResponse(reason=301) assert "" == repr(resp) @asyncio.coroutine def test_keep_alive_http10_default(): req = make_request('GET', '/', version=HttpVersion10) resp = StreamResponse() yield from resp.prepare(req) assert not resp.keep_alive @asyncio.coroutine def test_keep_alive_http10_switched_on(): headers = CIMultiDict(Connection='keep-alive') req = make_request('GET', '/', version=HttpVersion10, headers=headers) req._message = req._message._replace(should_close=False) resp = StreamResponse() yield from resp.prepare(req) assert resp.keep_alive @asyncio.coroutine def test_keep_alive_http09(): headers = CIMultiDict(Connection='keep-alive') req = make_request('GET', '/', version=HttpVersion(0, 9), headers=headers) resp = StreamResponse() yield from resp.prepare(req) assert not resp.keep_alive def test_start_twice(): req = make_request('GET', '/') resp = StreamResponse() with pytest.warns(DeprecationWarning): impl1 = resp.start(req) impl2 = resp.start(req) assert impl1 is impl2 @asyncio.coroutine def test_prepare_calls_signal(): app = mock.Mock() req = make_request('GET', '/', app=app) resp = StreamResponse() sig = mock.Mock() app.on_response_prepare.append(sig) yield from resp.prepare(req) sig.assert_called_with(req, resp) def test_get_nodelay_unprepared(): resp = StreamResponse() with pytest.raises(RuntimeError): resp.tcp_nodelay def test_set_nodelay_unprepared(): resp = StreamResponse() with pytest.raises(RuntimeError): resp.set_tcp_nodelay(True) @asyncio.coroutine def test_get_nodelay_prepared(): resp = StreamResponse() writer = mock.Mock() writer.tcp_nodelay = False req = make_request('GET', '/', writer=writer) yield from resp.prepare(req) assert not resp.tcp_nodelay def test_set_nodelay_prepared(): resp = StreamResponse() writer = mock.Mock() req = make_request('GET', '/', writer=writer) yield from resp.prepare(req) resp.set_tcp_nodelay(True) writer.set_tcp_nodelay.assert_called_with(True) def test_get_cork_unprepared(): resp = StreamResponse() with pytest.raises(RuntimeError): resp.tcp_cork def test_set_cork_unprepared(): resp = StreamResponse() with pytest.raises(RuntimeError): resp.set_tcp_cork(True) @asyncio.coroutine def test_get_cork_prepared(): resp = StreamResponse() writer = mock.Mock() writer.tcp_cork = False req = make_request('GET', '/', writer=writer) yield from resp.prepare(req) assert not resp.tcp_cork def test_set_cork_prepared(): resp = StreamResponse() writer = mock.Mock() req = make_request('GET', '/', writer=writer) yield from resp.prepare(req) resp.set_tcp_cork(True) writer.set_tcp_cork.assert_called_with(True) # Response class def test_response_ctor(): resp = Response() assert 200 == resp.status assert 'OK' == resp.reason assert resp.body is None assert 0 == resp.content_length assert (CIMultiDict([('CONTENT-TYPE', 'application/octet-stream'), ('CONTENT-LENGTH', '0')]) == resp.headers) def test_ctor_with_headers_and_status(): resp = Response(body=b'body', status=201, headers={'Age': '12'}) assert 201 == resp.status assert b'body' == resp.body assert 4 == resp.content_length assert (CIMultiDict([('AGE', '12'), ('CONTENT-TYPE', 'application/octet-stream'), ('CONTENT-LENGTH', '4')]) == resp.headers) def test_ctor_content_type(): resp = Response(content_type='application/json') assert 200 == resp.status assert 'OK' == resp.reason assert (CIMultiDict([('CONTENT-TYPE', 'application/json'), ('CONTENT-LENGTH', '0')]) == resp.headers) def test_ctor_text_body_combined(): with pytest.raises(ValueError): Response(body=b'123', text='test text') def test_ctor_text(): resp = Response(text='test text') assert 200 == resp.status assert 'OK' == resp.reason assert (CIMultiDict( [('CONTENT-TYPE', 'text/plain; charset=utf-8'), ('CONTENT-LENGTH', '9')]) == resp.headers) assert resp.body == b'test text' assert resp.text == 'test text' def test_ctor_charset(): resp = Response(text='текст', charset='koi8-r') assert 'текст'.encode('koi8-r') == resp.body assert 'koi8-r' == resp.charset def test_ctor_charset_default_utf8(): resp = Response(text='test test', charset=None) assert 'utf-8' == resp.charset def test_ctor_charset_in_content_type(): with pytest.raises(ValueError): Response(text='test test', content_type='text/plain; charset=utf-8') def test_ctor_charset_without_text(): resp = Response(content_type='text/plain', charset='koi8-r') assert 'koi8-r' == resp.charset def test_ctor_both_content_type_param_and_header_with_text(): with pytest.raises(ValueError): Response(headers={'Content-Type': 'application/json'}, content_type='text/html', text='text') def test_ctor_both_charset_param_and_header_with_text(): with pytest.raises(ValueError): Response(headers={'Content-Type': 'application/json'}, charset='koi8-r', text='text') def test_ctor_both_content_type_param_and_header(): with pytest.raises(ValueError): Response(headers={'Content-Type': 'application/json'}, content_type='text/html') def test_ctor_both_charset_param_and_header(): with pytest.raises(ValueError): Response(headers={'Content-Type': 'application/json'}, charset='koi8-r') def test_assign_nonbyteish_body(): resp = Response(body=b'data') with pytest.raises(TypeError): resp.body = 123 assert b'data' == resp.body assert 4 == resp.content_length def test_assign_nonstr_text(): resp = Response(text='test') with pytest.raises(TypeError): resp.text = b'123' assert b'test' == resp.body assert 4 == resp.content_length @asyncio.coroutine def test_send_headers_for_empty_body(): writer = mock.Mock() req = make_request('GET', '/', writer=writer) resp = Response() writer.drain.return_value = () buf = b'' def append(data): nonlocal buf buf += data writer.write.side_effect = append yield from resp.prepare(req) yield from resp.write_eof() txt = buf.decode('utf8') assert re.match('HTTP/1.1 200 OK\r\n' 'Content-Type: application/octet-stream\r\n' 'Content-Length: 0\r\n' 'Date: .+\r\n' 'Server: .+\r\n\r\n', txt) @asyncio.coroutine def test_render_with_body(): writer = mock.Mock() req = make_request('GET', '/', writer=writer) resp = Response(body=b'data') writer.drain.return_value = () buf = b'' def append(data): nonlocal buf buf += data writer.write.side_effect = append yield from resp.prepare(req) yield from resp.write_eof() txt = buf.decode('utf8') assert re.match('HTTP/1.1 200 OK\r\n' 'Content-Type: application/octet-stream\r\n' 'Content-Length: 4\r\n' 'Date: .+\r\n' 'Server: .+\r\n\r\n' 'data', txt) @asyncio.coroutine def test_send_set_cookie_header(): resp = Response() resp.cookies['name'] = 'value' writer = mock.Mock() req = make_request('GET', '/', writer=writer) writer.drain.return_value = () buf = b'' def append(data): nonlocal buf buf += data writer.write.side_effect = append yield from resp.prepare(req) yield from resp.write_eof() txt = buf.decode('utf8') assert re.match('HTTP/1.1 200 OK\r\n' 'Content-Type: application/octet-stream\r\n' 'Content-Length: 0\r\n' 'Set-Cookie: name=value\r\n' 'Date: .+\r\n' 'Server: .+\r\n\r\n', txt) def test_set_text_with_content_type(): resp = Response() resp.content_type = "text/html" resp.text = "text" assert "text" == resp.text assert b"text" == resp.body assert "text/html" == resp.content_type def test_set_text_with_charset(): resp = Response() resp.content_type = 'text/plain' resp.charset = "KOI8-R" resp.text = "текст" assert "текст" == resp.text assert "текст".encode('koi8-r') == resp.body assert "koi8-r" == resp.charset def test_default_content_type_in_stream_response(): resp = StreamResponse() assert resp.content_type == 'application/octet-stream' def test_default_content_type_in_response(): resp = Response() assert resp.content_type == 'application/octet-stream' def test_content_type_with_set_text(): resp = Response(text='text') assert resp.content_type == 'text/plain' def test_content_type_with_set_body(): resp = Response(body=b'body') assert resp.content_type == 'application/octet-stream' def test_started_when_not_started(): resp = StreamResponse() assert not resp.prepared @asyncio.coroutine def test_started_when_started(): resp = StreamResponse() yield from resp.prepare(make_request('GET', '/')) assert resp.prepared @asyncio.coroutine def test_drain_before_start(): resp = StreamResponse() with pytest.raises(RuntimeError): yield from resp.drain() @asyncio.coroutine def test_changing_status_after_prepare_raises(): resp = StreamResponse() yield from resp.prepare(make_request('GET', '/')) with pytest.raises(RuntimeError): resp.set_status(400) def test_nonstr_text_in_ctor(): with pytest.raises(TypeError): Response(text=b'data') def test_text_in_ctor_with_content_type(): resp = Response(text='data', content_type='text/html') assert 'data' == resp.text assert 'text/html' == resp.content_type def test_text_in_ctor_with_content_type_header(): resp = Response(text='текст', headers={'Content-Type': 'text/html; charset=koi8-r'}) assert 'текст'.encode('koi8-r') == resp.body assert 'text/html' == resp.content_type assert 'koi8-r' == resp.charset def test_text_in_ctor_with_content_type_header_multidict(): headers = CIMultiDict({'Content-Type': 'text/html; charset=koi8-r'}) resp = Response(text='текст', headers=headers) assert 'текст'.encode('koi8-r') == resp.body assert 'text/html' == resp.content_type assert 'koi8-r' == resp.charset def test_body_in_ctor_with_content_type_header_multidict(): headers = CIMultiDict({'Content-Type': 'text/html; charset=koi8-r'}) resp = Response(body='текст'.encode('koi8-r'), headers=headers) assert 'текст'.encode('koi8-r') == resp.body assert 'text/html' == resp.content_type assert 'koi8-r' == resp.charset def test_text_with_empty_payload(): resp = Response(status=200) assert resp.body is None assert resp.text is None def test_response_with_content_length_header_without_body(): resp = Response(headers={'Content-Length': 123}) assert resp.content_length == 123 class TestJSONResponse: def test_content_type_is_application_json_by_default(self): resp = json_response('') assert 'application/json' == resp.content_type def test_passing_text_only(self): resp = json_response(text=json.dumps('jaysawn')) assert resp.text == json.dumps('jaysawn') def test_data_and_text_raises_value_error(self): with pytest.raises(ValueError) as excinfo: json_response(data='foo', text='bar') expected_message = ( 'only one of data, text, or body should be specified' ) assert expected_message == excinfo.value.args[0] def test_data_and_body_raises_value_error(self): with pytest.raises(ValueError) as excinfo: json_response(data='foo', body=b'bar') expected_message = ( 'only one of data, text, or body should be specified' ) assert expected_message == excinfo.value.args[0] def test_text_is_json_encoded(self): resp = json_response({'foo': 42}) assert json.dumps({'foo': 42}) == resp.text def test_content_type_is_overrideable(self): resp = json_response({'foo': 42}, content_type='application/vnd.json+api') assert 'application/vnd.json+api' == resp.content_type aiohttp-1.2.0/tests/test_http_parser.py0000664000175000017500000005504213025134363021142 0ustar travistravis00000000000000"""Tests for aiohttp/protocol.py""" import asyncio import unittest import zlib from unittest import mock import aiohttp from aiohttp import CIMultiDict, errors, protocol class TestParseHeaders(unittest.TestCase): def setUp(self): asyncio.set_event_loop(None) self.parser = protocol.HttpParser(8190, 32768, 8190) def test_parse_headers(self): hdrs = (b'', b'test: line', b' continue', b'test2: data', b'', b'') headers, raw_headers, close, compression = self.parser.parse_headers( hdrs) self.assertEqual(list(headers.items()), [('Test', 'line\r\n continue'), ('Test2', 'data')]) self.assertEqual(raw_headers, [(b'TEST', b'line\r\n continue'), (b'TEST2', b'data')]) self.assertIsNone(close) self.assertIsNone(compression) def test_parse_headers_multi(self): hdrs = (b'', b'Set-Cookie: c1=cookie1', b'Set-Cookie: c2=cookie2', '') headers, raw_headers, close, compression = self.parser.parse_headers( hdrs) self.assertEqual(list(headers.items()), [('Set-Cookie', 'c1=cookie1'), ('Set-Cookie', 'c2=cookie2')]) self.assertEqual(raw_headers, [(b'SET-COOKIE', b'c1=cookie1'), (b'SET-COOKIE', b'c2=cookie2')]) self.assertIsNone(close) self.assertIsNone(compression) def test_conn_close(self): headers, raw_headers, close, compression = self.parser.parse_headers( [b'', b'connection: close', b'']) self.assertTrue(close) def test_conn_keep_alive(self): headers, raw_headers, close, compression = self.parser.parse_headers( [b'', b'connection: keep-alive', b'']) self.assertFalse(close) def test_conn_other(self): headers, raw_headers, close, compression = self.parser.parse_headers( [b'', b'connection: test', b'', b'']) self.assertIsNone(close) def test_compression_gzip(self): headers, raw_headers, close, compression = self.parser.parse_headers( [b'', b'content-encoding: gzip', b'', b'']) self.assertEqual('gzip', compression) def test_compression_deflate(self): headers, raw_headers, close, compression = self.parser.parse_headers( [b'', b'content-encoding: deflate', b'', b'']) self.assertEqual('deflate', compression) def test_compression_unknown(self): headers, raw_headers, close, compression = self.parser.parse_headers( [b'', b'content-encoding: compress', b'', b'']) self.assertIsNone(compression) def test_max_field_size(self): with self.assertRaises(errors.LineTooLong) as cm: parser = protocol.HttpParser(8190, 32768, 5) parser.parse_headers( [b'', b'test: line data data\r\n', b'data\r\n', b'\r\n']) self.assertIn("request header field TEST", str(cm.exception)) def test_max_continuation_headers_size(self): with self.assertRaises(errors.LineTooLong) as cm: parser = protocol.HttpParser(8190, 32768, 5) parser.parse_headers([b'', b'test: line\r\n', b' test\r\n', b'\r\n']) self.assertIn("request header field TEST", str(cm.exception)) def test_max_header_size(self): with self.assertRaises(errors.LineTooLong) as cm: parser = protocol.HttpParser(5, 5, 5) parser.parse_headers( [b'', b'test: line data data\r\n', b'data\r\n', b'\r\n']) self.assertIn("request header", str(cm.exception)) def test_invalid_header(self): with self.assertRaisesRegex( errors.InvalidHeader, "(400, message='Invalid HTTP Header: test line)"): self.parser.parse_headers([b'', b'test line\r\n', b'\r\n']) def test_invalid_name(self): with self.assertRaisesRegex( errors.InvalidHeader, "(400, message='Invalid HTTP Header: TEST..)"): self.parser.parse_headers([b'', b'test[]: line\r\n', b'\r\n']) class TestDeflateBuffer(unittest.TestCase): def setUp(self): self.stream = mock.Mock() asyncio.set_event_loop(None) def test_feed_data(self): buf = aiohttp.FlowControlDataQueue(self.stream) dbuf = protocol.DeflateBuffer(buf, 'deflate') dbuf.zlib = mock.Mock() dbuf.zlib.decompress.return_value = b'line' dbuf.feed_data(b'data', 4) self.assertEqual([b'line'], list(d for d, _ in buf._buffer)) def test_feed_data_err(self): buf = aiohttp.FlowControlDataQueue(self.stream) dbuf = protocol.DeflateBuffer(buf, 'deflate') exc = ValueError() dbuf.zlib = mock.Mock() dbuf.zlib.decompress.side_effect = exc self.assertRaises( errors.ContentEncodingError, dbuf.feed_data, b'data', 4) def test_feed_eof(self): buf = aiohttp.FlowControlDataQueue(self.stream) dbuf = protocol.DeflateBuffer(buf, 'deflate') dbuf.zlib = mock.Mock() dbuf.zlib.flush.return_value = b'line' dbuf.feed_eof() self.assertEqual([b'line'], list(d for d, _ in buf._buffer)) self.assertTrue(buf._eof) def test_feed_eof_err(self): buf = aiohttp.FlowControlDataQueue(self.stream) dbuf = protocol.DeflateBuffer(buf, 'deflate') dbuf.zlib = mock.Mock() dbuf.zlib.flush.return_value = b'line' dbuf.zlib.eof = False self.assertRaises(errors.ContentEncodingError, dbuf.feed_eof) class TestParsePayload(unittest.TestCase): def setUp(self): self.stream = mock.Mock() asyncio.set_event_loop(None) def test_parse_eof_payload(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(None).parse_eof_payload(out, buf) next(p) p.send(b'data') try: p.throw(aiohttp.EofStream()) except StopIteration: pass self.assertEqual([(bytearray(b'data'), 4)], list(out._buffer)) def test_parse_length_payload(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(None).parse_length_payload(out, buf, 4) next(p) p.send(b'da') p.send(b't') try: p.send(b'aline') except StopIteration: pass self.assertEqual(3, len(out._buffer)) self.assertEqual(b'data', b''.join(d for d, _ in out._buffer)) self.assertEqual(b'line', bytes(buf)) def test_parse_length_payload_eof(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(None).parse_length_payload(out, buf, 4) next(p) p.send(b'da') self.assertRaises(aiohttp.EofStream, p.throw, aiohttp.EofStream) def test_parse_chunked_payload(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(None).parse_chunked_payload(out, buf) next(p) try: p.send(b'4\r\ndata\r\n4\r\nline\r\n0\r\ntest\r\n') except StopIteration: pass self.assertEqual(b'dataline', b''.join(d for d, _ in out._buffer)) self.assertEqual(b'', bytes(buf)) def test_parse_chunked_payload_chunks(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(None).parse_chunked_payload(out, buf) next(p) p.send(b'4\r\ndata\r') p.send(b'\n4') p.send(b'\r') p.send(b'\n') p.send(b'line\r\n0\r\n') self.assertRaises(StopIteration, p.send, b'test\r\n') self.assertEqual(b'dataline', b''.join(d for d, _ in out._buffer)) def test_parse_chunked_payload_incomplete(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(None).parse_chunked_payload(out, buf) next(p) p.send(b'4\r\ndata\r\n') self.assertRaises(aiohttp.EofStream, p.throw, aiohttp.EofStream) def test_parse_chunked_payload_extension(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(None).parse_chunked_payload(out, buf) next(p) try: p.send(b'4;test\r\ndata\r\n4\r\nline\r\n0\r\ntest\r\n') except StopIteration: pass self.assertEqual(b'dataline', b''.join(d for d, _ in out._buffer)) def test_parse_chunked_payload_size_error(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(None).parse_chunked_payload(out, buf) next(p) self.assertRaises(errors.TransferEncodingError, p.send, b'blah\r\n') def test_http_payload_parser_length_broken(self): msg = protocol.RawRequestMessage( 'GET', '/', (1, 1), CIMultiDict([('CONTENT-LENGTH', 'qwe')]), [(b'CONTENT-LENGTH', b'qwe')], None, None) out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(msg)(out, buf) self.assertRaises(errors.InvalidHeader, next, p) def test_http_payload_parser_length_wrong(self): msg = protocol.RawRequestMessage( 'GET', '/', (1, 1), CIMultiDict([('CONTENT-LENGTH', '-1')]), [(b'CONTENT-LENGTH', b'-1')], None, None) out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(msg)(out, buf) self.assertRaises(errors.InvalidHeader, next, p) def test_http_payload_parser_length(self): msg = protocol.RawRequestMessage( 'GET', '/', (1, 1), CIMultiDict([('CONTENT-LENGTH', '2')]), [(b'CONTENT-LENGTH', b'2')], None, None) out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(msg)(out, buf) next(p) try: p.send(b'1245') except StopIteration: pass self.assertEqual(b'12', b''.join(d for d, _ in out._buffer)) self.assertEqual(b'45', bytes(buf)) def test_http_payload_parser_no_length(self): msg = protocol.RawRequestMessage( 'GET', '/', (1, 1), CIMultiDict(), [], None, None) out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(msg, readall=False)(out, buf) self.assertRaises(StopIteration, next, p) self.assertEqual(b'', b''.join(out._buffer)) self.assertTrue(out._eof) _comp = zlib.compressobj(wbits=-zlib.MAX_WBITS) _COMPRESSED = b''.join([_comp.compress(b'data'), _comp.flush()]) def test_http_payload_parser_deflate(self): msg = protocol.RawRequestMessage( 'GET', '/', (1, 1), CIMultiDict([('CONTENT-LENGTH', str(len(self._COMPRESSED)))]), [(b'CONTENT-LENGTH', str(len(self._COMPRESSED)).encode('ascii'))], None, 'deflate') out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(msg)(out, buf) next(p) self.assertRaises(StopIteration, p.send, self._COMPRESSED) self.assertEqual(b'data', b''.join(d for d, _ in out._buffer)) def test_http_payload_parser_deflate_disabled(self): msg = protocol.RawRequestMessage( 'GET', '/', (1, 1), CIMultiDict([('CONTENT-LENGTH', len(self._COMPRESSED))]), [(b'CONTENT-LENGTH', str(len(self._COMPRESSED)).encode('ascii'))], None, 'deflate') out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(msg, compression=False)(out, buf) next(p) self.assertRaises(StopIteration, p.send, self._COMPRESSED) self.assertEqual(self._COMPRESSED, b''.join(d for d, _ in out._buffer)) def test_http_payload_parser_websocket(self): msg = protocol.RawRequestMessage( 'GET', '/', (1, 1), CIMultiDict([('SEC-WEBSOCKET-KEY1', '13')]), [(b'SEC-WEBSOCKET-KEY1', b'13')], None, None) out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(msg)(out, buf) next(p) self.assertRaises(StopIteration, p.send, b'1234567890') self.assertEqual(b'12345678', b''.join(d for d, _ in out._buffer)) def test_http_payload_parser_chunked(self): msg = protocol.RawRequestMessage( 'GET', '/', (1, 1), CIMultiDict([('TRANSFER-ENCODING', 'chunked')]), [(b'TRANSFER-ENCODING', b'chunked')], None, None) out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(msg)(out, buf) next(p) self.assertRaises(StopIteration, p.send, b'4;test\r\ndata\r\n4\r\nline\r\n0\r\ntest\r\n') self.assertEqual(b'dataline', b''.join(d for d, _ in out._buffer)) def test_http_payload_parser_eof(self): msg = protocol.RawRequestMessage( 'GET', '/', (1, 1), CIMultiDict(), [], None, None) out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(msg, readall=True)(out, buf) next(p) p.send(b'data') p.send(b'line') self.assertRaises(StopIteration, p.throw, aiohttp.EofStream()) self.assertEqual(b'dataline', b''.join(d for d, _ in out._buffer)) def test_http_payload_parser_length_zero(self): msg = protocol.RawRequestMessage( 'GET', '/', (1, 1), CIMultiDict([('CONTENT-LENGTH', '0')]), [(b'CONTENT-LENGTH', b'0')], None, None) out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpPayloadParser(msg)(out, buf) self.assertRaises(StopIteration, next, p) self.assertEqual(b'', b''.join(out._buffer)) class TestParseRequest(unittest.TestCase): def setUp(self): self.stream = mock.Mock() asyncio.set_event_loop(None) def test_http_request_parser_max_headers(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpRequestParser(8190, 20, 8190)(out, buf) next(p) self.assertRaises( errors.LineTooLong, p.send, b'get /path HTTP/1.1\r\ntest: line\r\ntest2: data\r\n\r\n') def test_http_request_parser(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpRequestParser()(out, buf) next(p) try: p.send(b'get /path HTTP/1.1\r\n\r\n') except StopIteration: pass result = out._buffer[0][0] self.assertEqual( ('GET', '/path', (1, 1), CIMultiDict(), [], False, None), result) def test_http_request_parser_utf8(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpRequestParser()(out, buf) next(p) msg = 'get /path HTTP/1.1\r\nx-test:тест\r\n\r\n'.encode('utf-8') try: p.send(msg) except StopIteration: pass result, length = out._buffer[0] self.assertEqual(len(msg), length) self.assertEqual( ('GET', '/path', (1, 1), CIMultiDict([('X-TEST', 'тест')]), [(b'X-TEST', 'тест'.encode('utf-8'))], False, None), result) def test_http_request_parser_non_utf8(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpRequestParser()(out, buf) next(p) msg = 'get /path HTTP/1.1\r\nx-test:тест\r\n\r\n'.encode('cp1251') try: p.send(msg) except StopIteration: pass result, length = out._buffer[0] self.assertEqual(len(msg), length) self.assertEqual( ('GET', '/path', (1, 1), CIMultiDict([('X-TEST', 'тест'.encode('cp1251').decode( 'utf-8', 'surrogateescape'))]), [(b'X-TEST', 'тест'.encode('cp1251'))], False, None), result) def test_http_request_parser_eof(self): # HttpRequestParser does fail on EofStream() out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpRequestParser()(out, buf) next(p) p.send(b'get /path HTTP/1.1\r\n') try: p.throw(aiohttp.EofStream()) except aiohttp.EofStream: pass self.assertFalse(out._buffer) def test_http_request_parser_two_slashes(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpRequestParser()(out, buf) next(p) try: p.send(b'get //path HTTP/1.1\r\n\r\n') except StopIteration: pass self.assertEqual( ('GET', '//path', (1, 1), CIMultiDict(), [], False, None), out._buffer[0][0]) def test_http_request_parser_bad_status_line(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpRequestParser()(out, buf) next(p) self.assertRaises( errors.BadStatusLine, p.send, b'\r\n\r\n') def test_http_request_parser_bad_method(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpRequestParser()(out, buf) next(p) self.assertRaises( errors.BadStatusLine, p.send, b'!12%()+=~$ /get HTTP/1.1\r\n\r\n') def test_http_request_parser_bad_version(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpRequestParser()(out, buf) next(p) self.assertRaises( errors.BadStatusLine, p.send, b'GET //get HT/11\r\n\r\n') class TestParseResponse(unittest.TestCase): def setUp(self): self.stream = mock.Mock() asyncio.set_event_loop(None) def test_http_response_parser_utf8(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpResponseParser()(out, buf) next(p) msg = 'HTTP/1.1 200 Ok\r\nx-test:тест\r\n\r\n'.encode('utf-8') try: p.send(msg) except StopIteration: pass v, s, r, h = out._buffer[0][0][:4] self.assertEqual(v, (1, 1)) self.assertEqual(s, 200) self.assertEqual(r, 'Ok') self.assertEqual(h, CIMultiDict([('X-TEST', 'тест')])) def test_http_response_parser_bad_status_line(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpResponseParser()(out, buf) next(p) self.assertRaises(errors.BadStatusLine, p.send, b'\r\n\r\n') def test_http_response_parser_bad_status_line_too_long(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpResponseParser( max_headers=2, max_line_size=2)(out, buf) next(p) self.assertRaises( errors.LineTooLong, p.send, b'HTTP/1.1 200 Ok\r\n\r\n') def test_http_response_parser_bad_status_line_eof(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpResponseParser()(out, buf) next(p) self.assertRaises(aiohttp.EofStream, p.throw, aiohttp.EofStream()) def test_http_response_parser_bad_version(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpResponseParser()(out, buf) next(p) with self.assertRaises(errors.BadStatusLine) as cm: p.send(b'HT/11 200 Ok\r\n\r\n') self.assertEqual('HT/11 200 Ok', cm.exception.args[0]) def test_http_response_parser_no_reason(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpResponseParser()(out, buf) next(p) try: p.send(b'HTTP/1.1 200\r\n\r\n') except StopIteration: pass v, s, r = out._buffer[0][0][:3] self.assertEqual(v, (1, 1)) self.assertEqual(s, 200) self.assertEqual(r, '') def test_http_response_parser_bad(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpResponseParser()(out, buf) next(p) with self.assertRaises(errors.BadStatusLine) as cm: p.send(b'HTT/1\r\n\r\n') self.assertIn('HTT/1', str(cm.exception)) def test_http_response_parser_code_under_100(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpResponseParser()(out, buf) next(p) with self.assertRaises(errors.BadStatusLine) as cm: p.send(b'HTTP/1.1 99 test\r\n\r\n') self.assertIn('HTTP/1.1 99 test', str(cm.exception)) def test_http_response_parser_code_above_999(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpResponseParser()(out, buf) next(p) with self.assertRaises(errors.BadStatusLine) as cm: p.send(b'HTTP/1.1 9999 test\r\n\r\n') self.assertIn('HTTP/1.1 9999 test', str(cm.exception)) def test_http_response_parser_code_not_int(self): out = aiohttp.FlowControlDataQueue(self.stream) buf = aiohttp.ParserBuffer() p = protocol.HttpResponseParser()(out, buf) next(p) with self.assertRaises(errors.BadStatusLine) as cm: p.send(b'HTTP/1.1 ttt test\r\n\r\n') self.assertIn('HTTP/1.1 ttt test', str(cm.exception)) aiohttp-1.2.0/tests/test_proxy.py0000664000175000017500000005143013025134363017765 0ustar travistravis00000000000000import asyncio import gc import socket import unittest from unittest import mock from yarl import URL import aiohttp from aiohttp.client_reqrep import ClientRequest, ClientResponse from aiohttp.test_utils import make_mocked_coro class TestProxy(unittest.TestCase): def setUp(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(None) def tearDown(self): # just in case if we have transport close callbacks self.loop.stop() self.loop.run_forever() self.loop.close() gc.collect() @mock.patch('aiohttp.connector.ClientRequest') def test_connect(self, ClientRequestMock): req = ClientRequest( 'GET', URL('http://www.python.org'), proxy=URL('http://proxy.example.com'), loop=self.loop ) self.assertEqual(str(req.proxy), 'http://proxy.example.com') # mock all the things! connector = aiohttp.TCPConnector(loop=self.loop) connector._resolve_host = make_mocked_coro([mock.MagicMock()]) tr, proto = mock.Mock(), mock.Mock() self.loop.create_connection = make_mocked_coro((tr, proto)) conn = self.loop.run_until_complete(connector.connect(req)) self.assertEqual(req.url, URL('http://www.python.org')) self.assertIs(conn._transport, tr) self.assertIs(conn._protocol, proto) ClientRequestMock.assert_called_with( 'GET', URL('http://proxy.example.com'), auth=None, headers={'Host': 'www.python.org'}, loop=self.loop) def test_proxy_auth(self): with self.assertRaises(ValueError) as ctx: ClientRequest( 'GET', URL('http://python.org'), proxy=URL('http://proxy.example.com'), proxy_auth=('user', 'pass'), loop=mock.Mock()) self.assertEqual( ctx.exception.args[0], "proxy_auth must be None or BasicAuth() tuple", ) @mock.patch('aiohttp.Request') def test_connect_request_with_unicode_host(self, Request_mock): loop = mock.Mock() request = ClientRequest("CONNECT", URL("http://éé.com/"), loop=loop) request.response_class = mock.Mock() request.write_bytes = mock.Mock() request.write_bytes.return_value = asyncio.Future(loop=loop) request.write_bytes.return_value.set_result(None) request.send(mock.Mock(), mock.Mock()) Request_mock.assert_called_with(mock.ANY, mock.ANY, "xn--9caa.com:80", mock.ANY) def test_proxy_connection_error(self): connector = aiohttp.TCPConnector(loop=self.loop) connector._resolve_host = make_mocked_coro( raise_exception=OSError('dont take it serious')) req = ClientRequest( 'GET', URL('http://www.python.org'), proxy=URL('http://proxy.example.com'), loop=self.loop, ) expected_headers = dict(req.headers) with self.assertRaises(aiohttp.ProxyConnectionError): self.loop.run_until_complete(connector.connect(req)) self.assertEqual(req.url.path, '/') self.assertEqual(dict(req.headers), expected_headers) @mock.patch('aiohttp.connector.ClientRequest') def test_auth(self, ClientRequestMock): proxy_req = ClientRequest( 'GET', URL('http://proxy.example.com'), auth=aiohttp.helpers.BasicAuth('user', 'pass'), loop=self.loop ) ClientRequestMock.return_value = proxy_req self.assertIn('AUTHORIZATION', proxy_req.headers) self.assertNotIn('PROXY-AUTHORIZATION', proxy_req.headers) connector = aiohttp.TCPConnector(loop=self.loop) connector._resolve_host = make_mocked_coro([mock.MagicMock()]) tr, proto = mock.Mock(), mock.Mock() self.loop.create_connection = make_mocked_coro((tr, proto)) req = ClientRequest( 'GET', URL('http://www.python.org'), proxy=URL('http://proxy.example.com'), proxy_auth=aiohttp.helpers.BasicAuth('user', 'pass'), loop=self.loop, ) self.assertNotIn('AUTHORIZATION', req.headers) self.assertNotIn('PROXY-AUTHORIZATION', req.headers) conn = self.loop.run_until_complete(connector.connect(req)) self.assertEqual(req.url, URL('http://www.python.org')) self.assertNotIn('AUTHORIZATION', req.headers) self.assertIn('PROXY-AUTHORIZATION', req.headers) self.assertNotIn('AUTHORIZATION', proxy_req.headers) self.assertNotIn('PROXY-AUTHORIZATION', proxy_req.headers) ClientRequestMock.assert_called_with( 'GET', URL('http://proxy.example.com'), auth=aiohttp.helpers.BasicAuth('user', 'pass'), loop=mock.ANY, headers=mock.ANY) conn.close() def test_auth_utf8(self): proxy_req = ClientRequest( 'GET', URL('http://proxy.example.com'), auth=aiohttp.helpers.BasicAuth('юзер', 'пасс', 'utf-8'), loop=self.loop) self.assertIn('AUTHORIZATION', proxy_req.headers) @mock.patch('aiohttp.connector.ClientRequest') def test_auth_from_url(self, ClientRequestMock): proxy_req = ClientRequest('GET', URL('http://user:pass@proxy.example.com'), loop=self.loop) ClientRequestMock.return_value = proxy_req self.assertIn('AUTHORIZATION', proxy_req.headers) self.assertNotIn('PROXY-AUTHORIZATION', proxy_req.headers) connector = aiohttp.TCPConnector(loop=self.loop) connector._resolve_host = make_mocked_coro([mock.MagicMock()]) tr, proto = mock.Mock(), mock.Mock() self.loop.create_connection = make_mocked_coro((tr, proto)) req = ClientRequest( 'GET', URL('http://www.python.org'), proxy=URL('http://user:pass@proxy.example.com'), loop=self.loop, ) self.assertNotIn('AUTHORIZATION', req.headers) self.assertNotIn('PROXY-AUTHORIZATION', req.headers) conn = self.loop.run_until_complete(connector.connect(req)) self.assertEqual(req.url, URL('http://www.python.org')) self.assertNotIn('AUTHORIZATION', req.headers) self.assertIn('PROXY-AUTHORIZATION', req.headers) self.assertNotIn('AUTHORIZATION', proxy_req.headers) self.assertNotIn('PROXY-AUTHORIZATION', proxy_req.headers) ClientRequestMock.assert_called_with( 'GET', URL('http://user:pass@proxy.example.com'), auth=None, loop=mock.ANY, headers=mock.ANY) conn.close() @mock.patch('aiohttp.connector.ClientRequest') def test_auth__not_modifying_request(self, ClientRequestMock): proxy_req = ClientRequest('GET', URL('http://user:pass@proxy.example.com'), loop=self.loop) ClientRequestMock.return_value = proxy_req proxy_req_headers = dict(proxy_req.headers) connector = aiohttp.TCPConnector(loop=self.loop) connector._resolve_host = make_mocked_coro( raise_exception=OSError('nothing personal')) req = ClientRequest( 'GET', URL('http://www.python.org'), proxy=URL('http://user:pass@proxy.example.com'), loop=self.loop, ) req_headers = dict(req.headers) with self.assertRaises(aiohttp.ProxyConnectionError): self.loop.run_until_complete(connector.connect(req)) self.assertEqual(req.headers, req_headers) self.assertEqual(req.url.path, '/') self.assertEqual(proxy_req.headers, proxy_req_headers) @mock.patch('aiohttp.connector.ClientRequest') def test_https_connect(self, ClientRequestMock): proxy_req = ClientRequest('GET', URL('http://proxy.example.com'), loop=self.loop) ClientRequestMock.return_value = proxy_req proxy_resp = ClientResponse('get', URL('http://proxy.example.com')) proxy_resp._loop = self.loop proxy_req.send = send_mock = mock.Mock() send_mock.return_value = proxy_resp proxy_resp.start = make_mocked_coro(mock.Mock(status=200)) connector = aiohttp.TCPConnector(loop=self.loop) connector._resolve_host = make_mocked_coro( [{'hostname': 'hostname', 'host': '127.0.0.1', 'port': 80, 'family': socket.AF_INET, 'proto': 0, 'flags': 0}]) tr, proto = mock.Mock(), mock.Mock() self.loop.create_connection = make_mocked_coro((tr, proto)) req = ClientRequest( 'GET', URL('https://www.python.org'), proxy=URL('http://proxy.example.com'), loop=self.loop, ) self.loop.run_until_complete(connector._create_connection(req)) self.assertEqual(req.url.path, '/') self.assertEqual(proxy_req.method, 'CONNECT') self.assertEqual(proxy_req.url, URL('https://www.python.org')) tr.close.assert_called_once_with() tr.get_extra_info.assert_called_with('socket', default=None) self.loop.run_until_complete(proxy_req.close()) proxy_resp.close() self.loop.run_until_complete(req.close()) @mock.patch('aiohttp.connector.ClientRequest') def test_https_connect_runtime_error(self, ClientRequestMock): proxy_req = ClientRequest('GET', URL('http://proxy.example.com'), loop=self.loop) ClientRequestMock.return_value = proxy_req proxy_resp = ClientResponse('get', URL('http://proxy.example.com')) proxy_resp._loop = self.loop proxy_req.send = send_mock = mock.Mock() send_mock.return_value = proxy_resp proxy_resp.start = make_mocked_coro(mock.Mock(status=200)) connector = aiohttp.TCPConnector(loop=self.loop) connector._resolve_host = make_mocked_coro( [{'hostname': 'hostname', 'host': '127.0.0.1', 'port': 80, 'family': socket.AF_INET, 'proto': 0, 'flags': 0}]) tr, proto = mock.Mock(), mock.Mock() tr.get_extra_info.return_value = None self.loop.create_connection = make_mocked_coro((tr, proto)) req = ClientRequest( 'GET', URL('https://www.python.org'), proxy=URL('http://proxy.example.com'), loop=self.loop, ) with self.assertRaisesRegex( RuntimeError, "Transport does not expose socket instance"): self.loop.run_until_complete(connector._create_connection(req)) self.loop.run_until_complete(proxy_req.close()) proxy_resp.close() self.loop.run_until_complete(req.close()) @mock.patch('aiohttp.connector.ClientRequest') def test_https_connect_http_proxy_error(self, ClientRequestMock): proxy_req = ClientRequest('GET', URL('http://proxy.example.com'), loop=self.loop) ClientRequestMock.return_value = proxy_req proxy_resp = ClientResponse('get', URL('http://proxy.example.com')) proxy_resp._loop = self.loop proxy_req.send = send_mock = mock.Mock() send_mock.return_value = proxy_resp proxy_resp.start = make_mocked_coro( mock.Mock(status=400, reason='bad request')) connector = aiohttp.TCPConnector(loop=self.loop) connector = aiohttp.TCPConnector(loop=self.loop) connector._resolve_host = make_mocked_coro( [{'hostname': 'hostname', 'host': '127.0.0.1', 'port': 80, 'family': socket.AF_INET, 'proto': 0, 'flags': 0}]) tr, proto = mock.Mock(), mock.Mock() tr.get_extra_info.return_value = None self.loop.create_connection = make_mocked_coro((tr, proto)) req = ClientRequest( 'GET', URL('https://www.python.org'), proxy=URL('http://proxy.example.com'), loop=self.loop, ) with self.assertRaisesRegex( aiohttp.HttpProxyError, "400, message='bad request'"): self.loop.run_until_complete(connector._create_connection(req)) self.loop.run_until_complete(proxy_req.close()) proxy_resp.close() self.loop.run_until_complete(req.close()) @mock.patch('aiohttp.connector.ClientRequest') def test_https_connect_resp_start_error(self, ClientRequestMock): proxy_req = ClientRequest('GET', URL('http://proxy.example.com'), loop=self.loop) ClientRequestMock.return_value = proxy_req proxy_resp = ClientResponse('get', URL('http://proxy.example.com')) proxy_resp._loop = self.loop proxy_req.send = send_mock = mock.Mock() send_mock.return_value = proxy_resp proxy_resp.start = make_mocked_coro( raise_exception=OSError("error message")) connector = aiohttp.TCPConnector(loop=self.loop) connector._resolve_host = make_mocked_coro( [{'hostname': 'hostname', 'host': '127.0.0.1', 'port': 80, 'family': socket.AF_INET, 'proto': 0, 'flags': 0}]) tr, proto = mock.Mock(), mock.Mock() tr.get_extra_info.return_value = None self.loop.create_connection = make_mocked_coro((tr, proto)) req = ClientRequest( 'GET', URL('https://www.python.org'), proxy=URL('http://proxy.example.com'), loop=self.loop, ) with self.assertRaisesRegex(OSError, "error message"): self.loop.run_until_complete(connector._create_connection(req)) @mock.patch('aiohttp.connector.ClientRequest') def test_request_port(self, ClientRequestMock): proxy_req = ClientRequest('GET', URL('http://proxy.example.com'), loop=self.loop) ClientRequestMock.return_value = proxy_req connector = aiohttp.TCPConnector(loop=self.loop) connector._resolve_host = make_mocked_coro( [{'hostname': 'hostname', 'host': '127.0.0.1', 'port': 80, 'family': socket.AF_INET, 'proto': 0, 'flags': 0}]) tr, proto = mock.Mock(), mock.Mock() tr.get_extra_info.return_value = None self.loop.create_connection = make_mocked_coro((tr, proto)) req = ClientRequest( 'GET', URL('http://localhost:1234/path'), proxy=URL('http://proxy.example.com'), loop=self.loop, ) self.loop.run_until_complete(connector._create_connection(req)) self.assertEqual(req.url, URL('http://localhost:1234/path')) def test_proxy_auth_property(self): req = aiohttp.ClientRequest( 'GET', URL('http://localhost:1234/path'), proxy=URL('http://proxy.example.com'), proxy_auth=aiohttp.helpers.BasicAuth('user', 'pass'), loop=self.loop) self.assertEqual(('user', 'pass', 'latin1'), req.proxy_auth) def test_proxy_auth_property_default(self): req = aiohttp.ClientRequest( 'GET', URL('http://localhost:1234/path'), proxy=URL('http://proxy.example.com'), loop=self.loop) self.assertIsNone(req.proxy_auth) @mock.patch('aiohttp.connector.ClientRequest') def test_https_connect_pass_ssl_context(self, ClientRequestMock): proxy_req = ClientRequest('GET', URL('http://proxy.example.com'), loop=self.loop) ClientRequestMock.return_value = proxy_req proxy_resp = ClientResponse('get', URL('http://proxy.example.com')) proxy_resp._loop = self.loop proxy_req.send = send_mock = mock.Mock() send_mock.return_value = proxy_resp proxy_resp.start = make_mocked_coro(mock.Mock(status=200)) connector = aiohttp.TCPConnector(loop=self.loop) connector._resolve_host = make_mocked_coro( [{'hostname': 'hostname', 'host': '127.0.0.1', 'port': 80, 'family': socket.AF_INET, 'proto': 0, 'flags': 0}]) tr, proto = mock.Mock(), mock.Mock() self.loop.create_connection = make_mocked_coro((tr, proto)) req = ClientRequest( 'GET', URL('https://www.python.org'), proxy=URL('http://proxy.example.com'), loop=self.loop, ) self.loop.run_until_complete(connector._create_connection(req)) self.loop.create_connection.assert_called_with( mock.ANY, ssl=connector.ssl_context, sock=mock.ANY, server_hostname='www.python.org') self.assertEqual(req.url.path, '/') self.assertEqual(proxy_req.method, 'CONNECT') self.assertEqual(proxy_req.url, URL('https://www.python.org')) tr.close.assert_called_once_with() tr.get_extra_info.assert_called_with('socket', default=None) self.loop.run_until_complete(proxy_req.close()) proxy_resp.close() self.loop.run_until_complete(req.close()) @mock.patch('aiohttp.connector.ClientRequest') def test_https_auth(self, ClientRequestMock): proxy_req = ClientRequest('GET', URL('http://proxy.example.com'), auth=aiohttp.helpers.BasicAuth('user', 'pass'), loop=self.loop) ClientRequestMock.return_value = proxy_req proxy_resp = ClientResponse('get', URL('http://proxy.example.com')) proxy_resp._loop = self.loop proxy_req.send = send_mock = mock.Mock() send_mock.return_value = proxy_resp proxy_resp.start = make_mocked_coro(mock.Mock(status=200)) connector = aiohttp.TCPConnector(loop=self.loop) connector._resolve_host = make_mocked_coro( [{'hostname': 'hostname', 'host': '127.0.0.1', 'port': 80, 'family': socket.AF_INET, 'proto': 0, 'flags': 0}]) tr, proto = mock.Mock(), mock.Mock() self.loop.create_connection = make_mocked_coro((tr, proto)) self.assertIn('AUTHORIZATION', proxy_req.headers) self.assertNotIn('PROXY-AUTHORIZATION', proxy_req.headers) req = ClientRequest( 'GET', URL('https://www.python.org'), proxy=URL('http://proxy.example.com'), loop=self.loop ) self.assertNotIn('AUTHORIZATION', req.headers) self.assertNotIn('PROXY-AUTHORIZATION', req.headers) self.loop.run_until_complete(connector._create_connection(req)) self.assertEqual(req.url.path, '/') self.assertNotIn('AUTHORIZATION', req.headers) self.assertNotIn('PROXY-AUTHORIZATION', req.headers) self.assertNotIn('AUTHORIZATION', proxy_req.headers) self.assertIn('PROXY-AUTHORIZATION', proxy_req.headers) connector._resolve_host.assert_called_with('proxy.example.com', 80) self.loop.run_until_complete(proxy_req.close()) proxy_resp.close() self.loop.run_until_complete(req.close()) class TestProxyConnector(unittest.TestCase): """ Backward compatibility simple test. Most testing happens in TextProxy. """ def setUp(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(None) def tearDown(self): # just in case if we have transport close callbacks self.loop.stop() self.loop.run_forever() self.loop.close() gc.collect() def test_ctor(self): connector = aiohttp.ProxyConnector( URL('http://localhost:8118'), proxy_auth=aiohttp.helpers.BasicAuth('user', 'pass'), loop=self.loop, ) self.assertEqual('http://localhost:8118', str(connector.proxy)) self.assertEqual( aiohttp.helpers.BasicAuth('user', 'pass'), connector.proxy_auth ) self.assertTrue(connector.force_close) @mock.patch('aiohttp.connector.ClientRequest') def test_connect(self, ClientRequestMock): req = ClientRequest('GET', URL('http://www.python.org'), loop=self.loop) self.assertEqual(req.url.path, '/') connector = aiohttp.ProxyConnector(URL('http://proxy.example.com'), loop=self.loop) self.assertIs(self.loop, connector._loop) connector._resolve_host = make_mocked_coro([mock.MagicMock()]) tr, proto = mock.Mock(), mock.Mock() self.loop.create_connection = make_mocked_coro((tr, proto)) conn = self.loop.run_until_complete(connector.connect(req)) self.assertEqual(req.url, URL('http://www.python.org')) self.assertIs(conn._transport, tr) self.assertIs(conn._protocol, proto) # resolve_host.assert_called_once_with('proxy.example.com', 80) tr.get_extra_info.assert_called_once_with('sslcontext') ClientRequestMock.assert_called_with( 'GET', URL('http://proxy.example.com'), auth=None, headers={'Host': 'www.python.org'}, loop=self.loop) conn.close() aiohttp-1.2.0/tests/test_websocket_writer.py0000664000175000017500000000342313025134363022165 0ustar travistravis00000000000000import random from unittest import mock import pytest from aiohttp._ws_impl import WebSocketWriter @pytest.fixture def transport(): return mock.Mock() @pytest.fixture def writer(transport): return WebSocketWriter(transport, use_mask=False) def test_pong(transport, writer): writer.pong() transport.write.assert_called_with(b'\x8a\x00') def test_ping(transport, writer): writer.ping() transport.write.assert_called_with(b'\x89\x00') def test_send_text(transport, writer): writer.send(b'text') transport.write.assert_called_with(b'\x81\x04text') def test_send_binary(transport, writer): writer.send('binary', True) transport.write.assert_called_with(b'\x82\x06binary') def test_send_binary_long(transport, writer): writer.send(b'b' * 127, True) assert transport.write.call_args[0][0].startswith(b'\x82~\x00\x7fb') def test_send_binary_very_long(transport, writer): writer.send(b'b' * 65537, True) assert (transport.write.call_args_list[0][0][0] == b'\x82\x7f\x00\x00\x00\x00\x00\x01\x00\x01') assert transport.write.call_args_list[1][0][0] == b'b' * 65537 def test_close(transport, writer): writer.close(1001, 'msg') transport.write.assert_called_with(b'\x88\x05\x03\xe9msg') writer.close(1001, b'msg') transport.write.assert_called_with(b'\x88\x05\x03\xe9msg') # Test that Service Restart close code is also supported writer.close(1012, b'msg') transport.write.assert_called_with(b'\x88\x05\x03\xf4msg') def test_send_text_masked(transport, writer): writer = WebSocketWriter(transport, use_mask=True, random=random.Random(123)) writer.send(b'text') transport.write.assert_called_with(b'\x81\x84\rg\xb3fy\x02\xcb\x12') aiohttp-1.2.0/tests/test_web_exceptions.py0000664000175000017500000001116513025134363021623 0ustar travistravis00000000000000import asyncio import collections import re from unittest import mock import pytest from aiohttp import signals, web from aiohttp.test_utils import make_mocked_request @pytest.fixture def buf(): return bytearray() @pytest.fixture def request(buf): method = 'GET' path = '/' writer = mock.Mock() writer.drain.return_value = () def append(data): buf.extend(data) writer.write.side_effect = append app = mock.Mock() app._debug = False app.on_response_prepare = signals.Signal(app) req = make_mocked_request(method, path, app=app, writer=writer) return req def test_all_http_exceptions_exported(): assert 'HTTPException' in web.__all__ for name in dir(web): if name.startswith('_'): continue obj = getattr(web, name) if isinstance(obj, type) and issubclass(obj, web.HTTPException): assert name in web.__all__ @asyncio.coroutine def test_HTTPOk(buf, request): resp = web.HTTPOk() yield from resp.prepare(request) yield from resp.write_eof() txt = buf.decode('utf8') assert re.match(('HTTP/1.1 200 OK\r\n' 'Content-Type: text/plain; charset=utf-8\r\n' 'Content-Length: 7\r\n' 'Date: .+\r\n' 'Server: .+\r\n\r\n' '200: OK'), txt) def test_terminal_classes_has_status_code(): terminals = set() for name in dir(web): obj = getattr(web, name) if isinstance(obj, type) and issubclass(obj, web.HTTPException): terminals.add(obj) dup = frozenset(terminals) for cls1 in dup: for cls2 in dup: if cls1 in cls2.__bases__: terminals.discard(cls1) for cls in terminals: assert cls.status_code is not None codes = collections.Counter(cls.status_code for cls in terminals) assert None not in codes assert 1 == codes.most_common(1)[0][1] @asyncio.coroutine def test_HTTPFound(buf, request): resp = web.HTTPFound(location='/redirect') assert '/redirect' == resp.location assert '/redirect' == resp.headers['location'] yield from resp.prepare(request) yield from resp.write_eof() txt = buf.decode('utf8') assert re.match('HTTP/1.1 302 Found\r\n' 'Content-Type: text/plain; charset=utf-8\r\n' 'Content-Length: 10\r\n' 'Location: /redirect\r\n' 'Date: .+\r\n' 'Server: .+\r\n\r\n' '302: Found', txt) def test_HTTPFound_empty_location(): with pytest.raises(ValueError): web.HTTPFound(location='') with pytest.raises(ValueError): web.HTTPFound(location=None) @asyncio.coroutine def test_HTTPMethodNotAllowed(buf, request): resp = web.HTTPMethodNotAllowed('get', ['POST', 'PUT']) assert 'GET' == resp.method assert ['POST', 'PUT'] == resp.allowed_methods assert 'POST,PUT' == resp.headers['allow'] yield from resp.prepare(request) yield from resp.write_eof() txt = buf.decode('utf8') assert re.match('HTTP/1.1 405 Method Not Allowed\r\n' 'Content-Type: text/plain; charset=utf-8\r\n' 'Content-Length: 23\r\n' 'Allow: POST,PUT\r\n' 'Date: .+\r\n' 'Server: .+\r\n\r\n' '405: Method Not Allowed', txt) def test_override_body_with_text(): resp = web.HTTPNotFound(text="Page not found") assert 404 == resp.status assert "Page not found".encode('utf-8') == resp.body assert "Page not found" == resp.text assert "text/plain" == resp.content_type assert "utf-8" == resp.charset def test_override_body_with_binary(): txt = "Page not found" resp = web.HTTPNotFound(body=txt.encode('utf-8'), content_type="text/html") assert 404 == resp.status assert txt.encode('utf-8') == resp.body assert txt == resp.text assert "text/html" == resp.content_type assert resp.charset is None def test_default_body(): resp = web.HTTPOk() assert b'200: OK' == resp.body def test_empty_body_204(): resp = web.HTTPNoContent() assert resp.body is None def test_empty_body_205(): resp = web.HTTPNoContent() assert resp.body is None def test_empty_body_304(): resp = web.HTTPNoContent() resp.body is None def test_link_header_451(buf, request): resp = web.HTTPUnavailableForLegalReasons(link='http://warning.or.kr/') assert 'http://warning.or.kr/' == resp.link assert '; rel="blocked-by"' == resp.headers['Link'] aiohttp-1.2.0/tests/autobahn/0000775000175000017500000000000013025135427016773 5ustar travistravis00000000000000aiohttp-1.2.0/tests/autobahn/fuzzingserver.json0000664000175000017500000000033113025134363022604 0ustar travistravis00000000000000 { "url": "ws://localhost:9001", "options": {"failByDrop": false}, "outdir": "./reports/clients", "webport": 8080, "cases": ["*"], "exclude-cases": ["12.*", "13.*"], "exclude-agent-cases": {} } aiohttp-1.2.0/tests/autobahn/client.py0000664000175000017500000000251413025134363020623 0ustar travistravis00000000000000#!/usr/bin/env python3 import asyncio import aiohttp def client(loop, url, name): ws = yield from aiohttp.ws_connect(url + '/getCaseCount') num_tests = int((yield from ws.receive()).data) print('running %d cases' % num_tests) yield from ws.close() for i in range(1, num_tests + 1): print('running test case:', i) text_url = url + '/runCase?case=%d&agent=%s' % (i, name) ws = yield from aiohttp.ws_connect(text_url) while True: msg = yield from ws.receive() if msg.type == aiohttp.MsgType.text: ws.send_str(msg.data) elif msg.type == aiohttp.MsgType.binary: ws.send_bytes(msg.data) elif msg.type == aiohttp.MsgType.close: yield from ws.close() break else: break url = url + '/updateReports?agent=%s' % name ws = yield from aiohttp.ws_connect(url) yield from ws.close() def run(loop, url, name): try: yield from client(loop, url, name) except: import traceback traceback.print_exc() if __name__ == '__main__': loop = asyncio.get_event_loop() try: loop.run_until_complete(run(loop, 'http://localhost:9001', 'aiohttp')) except KeyboardInterrupt: pass finally: loop.close() aiohttp-1.2.0/tests/autobahn/server.py0000664000175000017500000000274613025134363020662 0ustar travistravis00000000000000#!/usr/bin/env python3 import asyncio import logging from aiohttp import web @asyncio.coroutine def wshandler(request): ws = web.WebSocketResponse(autoclose=False) ok, protocol = ws.can_start(request) if not ok: return web.HTTPBadRequest() yield from ws.prepare(request) while True: msg = yield from ws.receive() if msg.type == web.MsgType.text: ws.send_str(msg.data) elif msg.type == web.MsgType.binary: ws.send_bytes(msg.data) elif msg.type == web.MsgType.close: yield from ws.close() break else: break return ws @asyncio.coroutine def main(loop): app = web.Application(loop=loop) app.router.add_route('GET', '/', wshandler) handler = app.make_handler() srv = yield from loop.create_server(handler, '127.0.0.1', 9001) print("Server started at http://127.0.0.1:9001") return app, srv, handler @asyncio.coroutine def finish(app, srv, handler): srv.close() yield from handler.finish_connections() yield from srv.wait_closed() if __name__ == '__main__': loop = asyncio.get_event_loop() logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(levelname)s %(message)s') loop = asyncio.get_event_loop() app, srv, handler = loop.run_until_complete(main(loop)) try: loop.run_forever() except KeyboardInterrupt: loop.run_until_complete(finish(app, srv, handler)) aiohttp-1.2.0/tests/autobahn/fuzzingclient.json0000664000175000017500000000042413025134363022557 0ustar travistravis00000000000000{ "options": {"failByDrop": false}, "outdir": "./reports/servers", "servers": [{"agent": "AutobahnServer", "url": "ws://localhost:9001", "options": {"version": 18}}], "cases": ["*"], "exclude-cases": ["12.*", "13.*"], "exclude-agent-cases": {} } aiohttp-1.2.0/tests/test_wsgi.py0000664000175000017500000002663513025134363017566 0ustar travistravis00000000000000"""Tests for http/wsgi.py""" import asyncio import io import socket import unittest from unittest import mock import multidict import aiohttp from aiohttp import helpers, protocol, wsgi class TestHttpWsgiServerProtocol(unittest.TestCase): def setUp(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(None) self.wsgi = mock.Mock() self.reader = mock.Mock() self.writer = mock.Mock() self.writer.drain.return_value = () self.transport = mock.Mock() self.transport.get_extra_info.side_effect = [ mock.Mock(family=socket.AF_INET), ('1.2.3.4', 1234), ('2.3.4.5', 80)] self.headers = multidict.CIMultiDict({"HOST": "python.org"}) self.raw_headers = [(b"HOST", b"python.org")] self.message = protocol.RawRequestMessage( 'GET', '/path', (1, 0), self.headers, self.raw_headers, True, 'deflate') self.payload = aiohttp.FlowControlDataQueue(self.reader) self.payload.feed_data(b'data', 4) self.payload.feed_data(b'data', 4) self.payload.feed_eof() def tearDown(self): self.loop.close() def test_ctor(self): srv = wsgi.WSGIServerHttpProtocol(self.wsgi, loop=self.loop) self.assertIs(srv.wsgi, self.wsgi) self.assertFalse(srv.readpayload) def _make_one(self, **kw): srv = wsgi.WSGIServerHttpProtocol(self.wsgi, loop=self.loop, **kw) srv.reader = self.reader srv.writer = self.writer srv.transport = self.transport return srv.create_wsgi_environ(self.message, self.payload) def _make_srv(self, app=None, **kw): if app is None: app = self.wsgi srv = wsgi.WSGIServerHttpProtocol(app, loop=self.loop, **kw) srv.reader = self.reader srv.writer = self.writer srv.transport = self.transport return srv def test_environ(self): environ = self._make_one() self.assertEqual(environ['RAW_URI'], '/path') self.assertEqual(environ['wsgi.async'], True) def test_environ_headers(self): self.headers.extend( (('SCRIPT_NAME', 'script'), ('CONTENT-TYPE', 'text/plain'), ('CONTENT-LENGTH', '209'), ('X_TEST', '123'), ('X_TEST', '456'))) environ = self._make_one() print(environ) self.assertEqual(environ['CONTENT_TYPE'], 'text/plain') self.assertEqual(environ['CONTENT_LENGTH'], '209') self.assertEqual(environ['HTTP_X_TEST'], '123,456') self.assertEqual(environ['SCRIPT_NAME'], 'script') self.assertEqual(environ['SERVER_NAME'], 'python.org') self.assertEqual(environ['SERVER_PORT'], '80') get_extra_info_calls = self.transport.get_extra_info.mock_calls expected_calls = [ mock.call('socket'), mock.call('peername'), ] self.assertEqual(expected_calls, get_extra_info_calls) def test_environ_host_header_alternate_port(self): self.headers.update({'HOST': 'example.com:9999'}) environ = self._make_one() self.assertEqual(environ['SERVER_PORT'], '9999') def test_environ_host_header_alternate_port_ssl(self): self.headers.update({'HOST': 'example.com:9999'}) environ = self._make_one(is_ssl=True) self.assertEqual(environ['SERVER_PORT'], '9999') def test_wsgi_response(self): srv = self._make_srv() resp = srv.create_wsgi_response(self.message) self.assertIsInstance(resp, wsgi.WsgiResponse) def test_wsgi_response_start_response(self): srv = self._make_srv() resp = srv.create_wsgi_response(self.message) resp.start_response( '200 OK', [('CONTENT-TYPE', 'text/plain')]) self.assertEqual(resp.status, '200 OK') self.assertIsInstance(resp.response, protocol.Response) def test_wsgi_response_start_response_exc(self): srv = self._make_srv() resp = srv.create_wsgi_response(self.message) resp.start_response( '200 OK', [('CONTENT-TYPE', 'text/plain')], ['', ValueError()]) self.assertEqual(resp.status, '200 OK') self.assertIsInstance(resp.response, protocol.Response) def test_wsgi_response_start_response_exc_status(self): srv = self._make_srv() resp = srv.create_wsgi_response(self.message) resp.start_response('200 OK', [('CONTENT-TYPE', 'text/plain')]) self.assertRaises( ValueError, resp.start_response, '500 Err', [('CONTENT-TYPE', 'text/plain')], ['', ValueError()]) @mock.patch('aiohttp.wsgi.aiohttp') def test_wsgi_response_101_upgrade_to_websocket(self, m_asyncio): srv = self._make_srv() resp = srv.create_wsgi_response(self.message) resp.start_response( '101 Switching Protocols', (('UPGRADE', 'websocket'), ('CONNECTION', 'upgrade'))) self.assertEqual(resp.status, '101 Switching Protocols') self.assertTrue(m_asyncio.Response.return_value.send_headers.called) def test_file_wrapper(self): fobj = io.BytesIO(b'data') wrapper = wsgi.FileWrapper(fobj, 2) self.assertIs(wrapper, iter(wrapper)) self.assertTrue(hasattr(wrapper, 'close')) self.assertEqual(next(wrapper), b'da') self.assertEqual(next(wrapper), b'ta') self.assertRaises(StopIteration, next, wrapper) wrapper = wsgi.FileWrapper(b'data', 2) self.assertFalse(hasattr(wrapper, 'close')) def test_handle_request_futures(self): def wsgi_app(env, start): start('200 OK', [('Content-Type', 'text/plain')]) f1 = helpers.create_future(self.loop) f1.set_result(b'data') fut = helpers.create_future(self.loop) fut.set_result([f1]) return fut srv = self._make_srv(wsgi_app) self.loop.run_until_complete( srv.handle_request(self.message, self.payload)) content = b''.join( [c[1][0] for c in self.writer.write.mock_calls]) self.assertTrue(content.startswith(b'HTTP/1.0 200 OK')) self.assertTrue(content.endswith(b'data')) def test_handle_request_simple(self): def wsgi_app(env, start): start('200 OK', [('Content-Type', 'text/plain')]) return [b'data'] stream = asyncio.StreamReader(loop=self.loop) stream.feed_data(b'data') stream.feed_eof() self.message = protocol.RawRequestMessage( 'GET', '/path', (1, 1), self.headers, self.raw_headers, True, 'deflate') srv = self._make_srv(wsgi_app, readpayload=True) self.loop.run_until_complete( srv.handle_request(self.message, self.payload)) content = b''.join( [c[1][0] for c in self.writer.write.mock_calls]) self.assertTrue(content.startswith(b'HTTP/1.1 200 OK')) self.assertTrue(content.endswith(b'data\r\n0\r\n\r\n')) self.assertFalse(srv._keepalive) def test_handle_request_io(self): def wsgi_app(env, start): start('200 OK', [('Content-Type', 'text/plain')]) return io.BytesIO(b'data') srv = self._make_srv(wsgi_app) self.loop.run_until_complete( srv.handle_request(self.message, self.payload)) content = b''.join( [c[1][0] for c in self.writer.write.mock_calls]) self.assertTrue(content.startswith(b'HTTP/1.0 200 OK')) self.assertTrue(content.endswith(b'data')) def test_handle_request_keep_alive(self): def wsgi_app(env, start): start('200 OK', [('Content-Type', 'text/plain')]) return [b'data'] stream = asyncio.StreamReader(loop=self.loop) stream.feed_data(b'data') stream.feed_eof() self.message = protocol.RawRequestMessage( 'GET', '/path', (1, 1), self.headers, self.raw_headers, False, 'deflate') srv = self._make_srv(wsgi_app, readpayload=True) self.loop.run_until_complete( srv.handle_request(self.message, self.payload)) content = b''.join( [c[1][0] for c in self.writer.write.mock_calls]) self.assertTrue(content.startswith(b'HTTP/1.1 200 OK')) self.assertTrue(content.endswith(b'data\r\n0\r\n\r\n')) self.assertTrue(srv._keepalive) def test_handle_request_readpayload(self): def wsgi_app(env, start): start('200 OK', [('Content-Type', 'text/plain')]) return [env['wsgi.input'].read()] srv = self._make_srv(wsgi_app, readpayload=True) self.loop.run_until_complete( srv.handle_request(self.message, self.payload)) content = b''.join( [c[1][0] for c in self.writer.write.mock_calls]) self.assertTrue(content.startswith(b'HTTP/1.0 200 OK')) self.assertTrue(content.endswith(b'data')) def test_dont_unquote_environ_path_info(self): path = '/path/some%20text' self.message = protocol.RawRequestMessage( 'GET', path, (1, 0), self.headers, self.raw_headers, True, 'deflate') environ = self._make_one() self.assertEqual(environ['PATH_INFO'], path) def test_authorization(self): # This header should be removed according to CGI/1.1 and WSGI but # in our case basic auth is not handled by server, so should # not be removed self.headers.extend({'AUTHORIZATION': 'spam'}) self.message = protocol.RawRequestMessage( 'GET', '/', (1, 1), self.headers, self.raw_headers, True, 'deflate') environ = self._make_one() self.assertEqual('spam', environ['HTTP_AUTHORIZATION']) def test_http_1_0_no_host(self): headers = multidict.MultiDict({}) self.message = protocol.RawRequestMessage( 'GET', '/', (1, 0), headers, [], True, 'deflate') environ = self._make_one() self.assertEqual(environ['SERVER_NAME'], '2.3.4.5') self.assertEqual(environ['SERVER_PORT'], '80') def test_family_inet6(self): self.transport.get_extra_info.side_effect = [ mock.Mock(family=socket.AF_INET6), ("::", 1122, 0, 0), ('2.3.4.5', 80)] self.message = protocol.RawRequestMessage( 'GET', '/', (1, 0), self.headers, self.raw_headers, True, 'deflate') environ = self._make_one() self.assertEqual(environ['SERVER_NAME'], 'python.org') self.assertEqual(environ['SERVER_PORT'], '80') self.assertEqual(environ['REMOTE_ADDR'], '::') self.assertEqual(environ['REMOTE_PORT'], '1122') def test_family_unix(self): if not hasattr(socket, "AF_UNIX"): self.skipTest("No UNIX address family. (Windows?)") self.transport.get_extra_info.side_effect = [ mock.Mock(family=socket.AF_UNIX)] headers = multidict.MultiDict({ 'SERVER_NAME': '1.2.3.4', 'SERVER_PORT': '5678', 'REMOTE_ADDR': '4.3.2.1', 'REMOTE_PORT': '8765'}) self.message = protocol.RawRequestMessage( 'GET', '/', (1, 0), headers, self.raw_headers, True, 'deflate') environ = self._make_one() self.assertEqual(environ['SERVER_NAME'], '1.2.3.4') self.assertEqual(environ['SERVER_PORT'], '5678') self.assertEqual(environ['REMOTE_ADDR'], '4.3.2.1') self.assertEqual(environ['REMOTE_PORT'], '8765') aiohttp-1.2.0/tests/sample.crt0000664000175000017500000000146613025134363017172 0ustar travistravis00000000000000-----BEGIN CERTIFICATE----- MIICMzCCAZwCCQDFl4ys0fU7iTANBgkqhkiG9w0BAQUFADBeMQswCQYDVQQGEwJV UzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNU2FuLUZyYW5jaXNjbzEi MCAGA1UECgwZUHl0aG9uIFNvZnR3YXJlIEZvbmRhdGlvbjAeFw0xMzAzMTgyMDA3 MjhaFw0yMzAzMTYyMDA3MjhaMF4xCzAJBgNVBAYTAlVTMRMwEQYDVQQIDApDYWxp Zm9ybmlhMRYwFAYDVQQHDA1TYW4tRnJhbmNpc2NvMSIwIAYDVQQKDBlQeXRob24g U29mdHdhcmUgRm9uZGF0aW9uMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCn t3s+J7L0xP/YdAQOacpPi9phlrzKZhcXL3XMu2LCUg2fNJpx/47Vc5TZSaO11uO7 gdwVz3Z7Q2epAgwo59JLffLt5fia8+a/SlPweI/j4+wcIIIiqusnLfpqR8cIAavg Z06cLYCDvb9wMlheIvSJY12skc1nnphWS2YJ0Xm6uQIDAQABMA0GCSqGSIb3DQEB BQUAA4GBAE9PknG6pv72+5z/gsDGYy8sK5UNkbWSNr4i4e5lxVsF03+/M71H+3AB MxVX4+A+Vlk2fmU+BrdHIIUE0r1dDcO3josQ9hc9OJpp5VLSQFP8VeuJCmzYPp9I I8WbW93cnXnChTrYQVdgVoFdv7GE9YgU7NYkrGIM0nZl1/f/bHPB -----END CERTIFICATE----- aiohttp-1.2.0/tests/test_urldispatch.py0000664000175000017500000007273013025134363021134 0ustar travistravis00000000000000import asyncio import os import pathlib import re from collections.abc import Container, Iterable, Mapping, MutableMapping, Sized from urllib.parse import unquote import pytest from yarl import URL import aiohttp from aiohttp import hdrs, web from aiohttp.test_utils import make_mocked_request from aiohttp.web import HTTPMethodNotAllowed, HTTPNotFound, Response from aiohttp.web_urldispatcher import (AbstractResource, ResourceRoute, SystemRoute, UrlDispatcher, View, _defaultExpectHandler) def make_request(method, path): return make_mocked_request(method, path) def make_handler(): @asyncio.coroutine def handler(request): return Response(request) # pragma: no cover return handler @pytest.fixture def app(loop): return web.Application(loop=loop) @pytest.fixture def router(app): return app.router @pytest.fixture def fill_routes(router): def go(): route1 = router.add_route('GET', '/plain', make_handler()) route2 = router.add_route('GET', '/variable/{name}', make_handler()) resource = router.add_static('/static', os.path.dirname(aiohttp.__file__)) return [route1, route2] + list(resource) return go def test_register_uncommon_http_methods(router): uncommon_http_methods = { 'PROPFIND', 'PROPPATCH', 'COPY', 'LOCK', 'UNLOCK' 'MOVE', 'SUBSCRIBE', 'UNSUBSCRIBE', 'NOTIFY' } for method in uncommon_http_methods: router.add_route(method, '/handler/to/path', make_handler()) @asyncio.coroutine def test_add_route_root(router): handler = make_handler() router.add_route('GET', '/', handler) req = make_request('GET', '/') info = yield from router.resolve(req) assert info is not None assert 0 == len(info) assert handler is info.handler assert info.route.name is None @asyncio.coroutine def test_add_route_simple(router): handler = make_handler() router.add_route('GET', '/handler/to/path', handler) req = make_request('GET', '/handler/to/path') info = yield from router.resolve(req) assert info is not None assert 0 == len(info) assert handler is info.handler assert info.route.name is None @asyncio.coroutine def test_add_with_matchdict(router): handler = make_handler() router.add_route('GET', '/handler/{to}', handler) req = make_request('GET', '/handler/tail') info = yield from router.resolve(req) assert info is not None assert {'to': 'tail'} == info assert handler is info.handler assert info.route.name is None @asyncio.coroutine def test_add_route_with_add_get_shortcut(router): handler = make_handler() router.add_get('/handler/to/path', handler) req = make_request('GET', '/handler/to/path') info = yield from router.resolve(req) assert info is not None assert 0 == len(info) assert handler is info.handler assert info.route.name is None @asyncio.coroutine def test_add_route_with_add_post_shortcut(router): handler = make_handler() router.add_post('/handler/to/path', handler) req = make_request('POST', '/handler/to/path') info = yield from router.resolve(req) assert info is not None assert 0 == len(info) assert handler is info.handler assert info.route.name is None @asyncio.coroutine def test_add_route_with_add_put_shortcut(router): handler = make_handler() router.add_put('/handler/to/path', handler) req = make_request('PUT', '/handler/to/path') info = yield from router.resolve(req) assert info is not None assert 0 == len(info) assert handler is info.handler assert info.route.name is None @asyncio.coroutine def test_add_route_with_add_patch_shortcut(router): handler = make_handler() router.add_patch('/handler/to/path', handler) req = make_request('PATCH', '/handler/to/path') info = yield from router.resolve(req) assert info is not None assert 0 == len(info) assert handler is info.handler assert info.route.name is None @asyncio.coroutine def test_add_route_with_add_delete_shortcut(router): handler = make_handler() router.add_delete('/handler/to/path', handler) req = make_request('DELETE', '/handler/to/path') info = yield from router.resolve(req) assert info is not None assert 0 == len(info) assert handler is info.handler assert info.route.name is None @asyncio.coroutine def test_add_route_with_add_head_shortcut(router): handler = make_handler() router.add_head('/handler/to/path', handler) req = make_request('HEAD', '/handler/to/path') info = yield from router.resolve(req) assert info is not None assert 0 == len(info) assert handler is info.handler assert info.route.name is None @asyncio.coroutine def test_add_with_name(router): handler = make_handler() router.add_route('GET', '/handler/to/path', handler, name='name') req = make_request('GET', '/handler/to/path') info = yield from router.resolve(req) assert info is not None assert 'name' == info.route.name @asyncio.coroutine def test_add_with_tailing_slash(router): handler = make_handler() router.add_route('GET', '/handler/to/path/', handler) req = make_request('GET', '/handler/to/path/') info = yield from router.resolve(req) assert info is not None assert {} == info assert handler is info.handler def test_add_invalid_path(router): handler = make_handler() with pytest.raises(ValueError): router.add_route('GET', '/{/', handler) def test_add_url_invalid1(router): handler = make_handler() with pytest.raises(ValueError): router.add_route('post', '/post/{id', handler) def test_add_url_invalid2(router): handler = make_handler() with pytest.raises(ValueError): router.add_route('post', '/post/{id{}}', handler) def test_add_url_invalid3(router): handler = make_handler() with pytest.raises(ValueError): router.add_route('post', '/post/{id{}', handler) def test_add_url_invalid4(router): handler = make_handler() with pytest.raises(ValueError): router.add_route('post', '/post/{id"}', handler) @asyncio.coroutine def test_add_url_escaping(router): handler = make_handler() router.add_route('GET', '/+$', handler) req = make_request('GET', '/+$') info = yield from router.resolve(req) assert info is not None assert handler is info.handler @asyncio.coroutine def test_any_method(router): handler = make_handler() route = router.add_route(hdrs.METH_ANY, '/', handler) req = make_request('GET', '/') info1 = yield from router.resolve(req) assert info1 is not None assert route is info1.route req = make_request('POST', '/') info2 = yield from router.resolve(req) assert info2 is not None assert info1.route is info2.route @asyncio.coroutine def test_match_second_result_in_table(router): handler1 = make_handler() handler2 = make_handler() router.add_route('GET', '/h1', handler1) router.add_route('POST', '/h2', handler2) req = make_request('POST', '/h2') info = yield from router.resolve(req) assert info is not None assert {} == info assert handler2 is info.handler @asyncio.coroutine def test_raise_method_not_allowed(router): handler1 = make_handler() handler2 = make_handler() router.add_route('GET', '/', handler1) router.add_route('POST', '/', handler2) req = make_request('PUT', '/') match_info = yield from router.resolve(req) assert isinstance(match_info.route, SystemRoute) assert {} == match_info with pytest.raises(HTTPMethodNotAllowed) as ctx: yield from match_info.handler(req) exc = ctx.value assert 'PUT' == exc.method assert 405 == exc.status assert {'POST', 'GET'} == exc.allowed_methods @asyncio.coroutine def test_raise_method_not_found(router): handler = make_handler() router.add_route('GET', '/a', handler) req = make_request('GET', '/b') match_info = yield from router.resolve(req) assert isinstance(match_info.route, SystemRoute) assert {} == match_info with pytest.raises(HTTPNotFound) as ctx: yield from match_info.handler(req) exc = ctx.value assert 404 == exc.status def test_double_add_url_with_the_same_name(router): handler1 = make_handler() handler2 = make_handler() router.add_route('GET', '/get', handler1, name='name') regexp = ("Duplicate 'name', already handled by") with pytest.raises(ValueError) as ctx: router.add_route('GET', '/get_other', handler2, name='name') assert re.match(regexp, str(ctx.value)) def test_route_plain(router): handler = make_handler() route = router.add_route('GET', '/get', handler, name='name') route2 = next(iter(router['name'])) url = route2.url() assert '/get' == url assert route is route2 def test_route_unknown_route_name(router): with pytest.raises(KeyError): router['unknown'] def test_route_dynamic(router): handler = make_handler() route = router.add_route('GET', '/get/{name}', handler, name='name') route2 = next(iter(router['name'])) url = route2.url(parts={'name': 'John'}) assert '/get/John' == url assert route is route2 def test_route_with_qs(router): handler = make_handler() router.add_route('GET', '/get', handler, name='name') url = router['name'].url(query=[('a', 'b'), ('c', '1')]) assert '/get?a=b&c=1' == url def test_add_static(router): resource = router.add_static('/st', os.path.dirname(aiohttp.__file__), name='static') assert router['static'] is resource url = resource.url(filename='/dir/a.txt') assert '/st/dir/a.txt' == url assert len(resource) == 2 def test_plain_not_match(router): handler = make_handler() router.add_route('GET', '/get/path', handler, name='name') route = router['name'] assert route._match('/another/path') is None def test_dynamic_not_match(router): handler = make_handler() router.add_route('GET', '/get/{name}', handler, name='name') route = router['name'] assert route._match('/another/path') is None @asyncio.coroutine def test_static_not_match(router): router.add_static('/pre', os.path.dirname(aiohttp.__file__), name='name') resource = router['name'] ret = yield from resource.resolve( make_mocked_request('GET', '/another/path')) assert (None, set()) == ret def test_dynamic_with_trailing_slash(router): handler = make_handler() router.add_route('GET', '/get/{name}/', handler, name='name') route = router['name'] assert {'name': 'John'} == route._match('/get/John/') def test_len(router): handler = make_handler() router.add_route('GET', '/get1', handler, name='name1') router.add_route('GET', '/get2', handler, name='name2') assert 2 == len(router) def test_iter(router): handler = make_handler() router.add_route('GET', '/get1', handler, name='name1') router.add_route('GET', '/get2', handler, name='name2') assert {'name1', 'name2'} == set(iter(router)) def test_contains(router): handler = make_handler() router.add_route('GET', '/get1', handler, name='name1') router.add_route('GET', '/get2', handler, name='name2') assert 'name1' in router assert 'name3' not in router def test_static_repr(router): router.add_static('/get', os.path.dirname(aiohttp.__file__), name='name') assert re.match(r"+++)': nothing to repeat") assert ctx.value.__cause__ is None def test_route_dynamic_with_regex_spec(router): handler = make_handler() route = router.add_route('GET', '/get/{num:^\d+}', handler, name='name') url = route.url(parts={'num': '123'}) assert '/get/123' == url def test_route_dynamic_with_regex_spec_and_trailing_slash(router): handler = make_handler() route = router.add_route('GET', '/get/{num:^\d+}/', handler, name='name') url = route.url(parts={'num': '123'}) assert '/get/123/' == url def test_route_dynamic_with_regex(router): handler = make_handler() route = router.add_route('GET', r'/{one}/{two:.+}', handler) url = route.url(parts={'one': 1, 'two': 2}) assert '/1/2' == url @asyncio.coroutine def test_regular_match_info(router): handler = make_handler() router.add_route('GET', '/get/{name}', handler) req = make_request('GET', '/get/john') match_info = yield from router.resolve(req) assert {'name': 'john'} == match_info assert re.match(">", repr(match_info)) @asyncio.coroutine def test_not_found_repr(router): req = make_request('POST', '/path/to') match_info = yield from router.resolve(req) assert "" == repr(match_info) @asyncio.coroutine def test_not_allowed_repr(router): handler = make_handler() router.add_route('GET', '/path/to', handler) handler2 = make_handler() router.add_route('POST', '/path/to', handler2) req = make_request('PUT', '/path/to') match_info = yield from router.resolve(req) assert "" == repr(match_info) def test_default_expect_handler(router): route = router.add_route('GET', '/', make_handler()) assert route._expect_handler is _defaultExpectHandler def test_custom_expect_handler_plain(router): @asyncio.coroutine def handler(request): pass route = router.add_route( 'GET', '/', make_handler(), expect_handler=handler) assert route._expect_handler is handler assert isinstance(route, ResourceRoute) def test_custom_expect_handler_dynamic(router): @asyncio.coroutine def handler(request): pass route = router.add_route( 'GET', '/get/{name}', make_handler(), expect_handler=handler) assert route._expect_handler is handler assert isinstance(route, ResourceRoute) def test_expect_handler_non_coroutine(router): def handler(request): pass with pytest.raises(AssertionError): router.add_route('GET', '/', make_handler(), expect_handler=handler) @asyncio.coroutine def test_dynamic_match_non_ascii(router): handler = make_handler() router.add_route('GET', '/{var}', handler) req = make_request( 'GET', '/%D1%80%D1%83%D1%81%20%D1%82%D0%B5%D0%BA%D1%81%D1%82') match_info = yield from router.resolve(req) assert {'var': 'рус текст'} == match_info @asyncio.coroutine def test_dynamic_match_with_static_part(router): handler = make_handler() router.add_route('GET', '/{name}.html', handler) req = make_request('GET', '/file.html') match_info = yield from router.resolve(req) assert {'name': 'file'} == match_info @asyncio.coroutine def test_dynamic_match_two_part2(router): handler = make_handler() router.add_route('GET', '/{name}.{ext}', handler) req = make_request('GET', '/file.html') match_info = yield from router.resolve(req) assert {'name': 'file', 'ext': 'html'} == match_info @asyncio.coroutine def test_dynamic_match_unquoted_path(router): handler = make_handler() router.add_route('GET', '/{path}/{subpath}', handler) resource_id = 'my%2Fpath%7Cwith%21some%25strange%24characters' req = make_request('GET', '/path/{0}'.format(resource_id)) match_info = yield from router.resolve(req) assert match_info == { 'path': 'path', 'subpath': unquote(resource_id) } def test_add_route_not_started_with_slash(router): with pytest.raises(ValueError): handler = make_handler() router.add_route('GET', 'invalid_path', handler) def test_add_route_invalid_method(router): sample_bad_methods = { 'BAD METHOD', 'B@D_METHOD', '[BAD_METHOD]', '{BAD_METHOD}', '(BAD_METHOD)', 'B?D_METHOD', } for bad_method in sample_bad_methods: with pytest.raises(ValueError): handler = make_handler() router.add_route(bad_method, '/path', handler) def test_routes_view_len(router, fill_routes): fill_routes() assert 4 == len(router.routes()) def test_routes_view_iter(router, fill_routes): routes = fill_routes() assert list(routes) == list(router.routes()) def test_routes_view_contains(router, fill_routes): routes = fill_routes() for route in routes: assert route in router.routes() def test_routes_abc(router): assert isinstance(router.routes(), Sized) assert isinstance(router.routes(), Iterable) assert isinstance(router.routes(), Container) def test_named_resources_abc(router): assert isinstance(router.named_resources(), Mapping) assert not isinstance(router.named_resources(), MutableMapping) def test_named_resources(router): route1 = router.add_route('GET', '/plain', make_handler(), name='route1') route2 = router.add_route('GET', '/variable/{name}', make_handler(), name='route2') route3 = router.add_static('/static', os.path.dirname(aiohttp.__file__), name='route3') names = {route1.name, route2.name, route3.name} assert 3 == len(router.named_resources()) for name in names: assert name in router.named_resources() assert isinstance(router.named_resources()[name], AbstractResource) def test_resource_iter(router): resource = router.add_resource('/path') r1 = resource.add_route('GET', lambda req: None) r2 = resource.add_route('POST', lambda req: None) assert 2 == len(resource) assert [r1, r2] == list(resource) def test_deprecate_bare_generators(router): resource = router.add_resource('/path') def gen(request): yield with pytest.warns(DeprecationWarning): resource.add_route('GET', gen) def test_view_route(router): resource = router.add_resource('/path') route = resource.add_route('GET', View) assert View is route.handler def test_resource_route_match(router): resource = router.add_resource('/path') route = resource.add_route('GET', lambda req: None) assert {} == route.resource._match('/path') def test_error_on_double_route_adding(router): resource = router.add_resource('/path') resource.add_route('GET', lambda: None) with pytest.raises(RuntimeError): resource.add_route('GET', lambda: None) def test_error_on_adding_route_after_wildcard(router): resource = router.add_resource('/path') resource.add_route('*', lambda: None) with pytest.raises(RuntimeError): resource.add_route('GET', lambda: None) @asyncio.coroutine def test_http_exception_is_none_when_resolved(router): handler = make_handler() router.add_route('GET', '/', handler) req = make_request('GET', '/') info = yield from router.resolve(req) assert info.http_exception is None @asyncio.coroutine def test_http_exception_is_not_none_when_not_resolved(router): handler = make_handler() router.add_route('GET', '/', handler) req = make_request('GET', '/abc') info = yield from router.resolve(req) assert info.http_exception.status == 404 @asyncio.coroutine def test_match_info_get_info_plain(router): handler = make_handler() router.add_route('GET', '/', handler) req = make_request('GET', '/') info = yield from router.resolve(req) assert info.get_info() == {'path': '/'} @asyncio.coroutine def test_match_info_get_info_dynamic(router): handler = make_handler() router.add_route('GET', '/{a}', handler) req = make_request('GET', '/value') info = yield from router.resolve(req) assert info.get_info() == { 'pattern': re.compile('\\/(?P[^{}/]+)'), 'formatter': '/{a}'} @asyncio.coroutine def test_match_info_get_info_dynamic2(router): handler = make_handler() router.add_route('GET', '/{a}/{b}', handler) req = make_request('GET', '/path/to') info = yield from router.resolve(req) assert info.get_info() == { 'pattern': re.compile('\\/(?P[^{}/]+)\\/(?P[^{}/]+)'), 'formatter': '/{a}/{b}'} def test_static_resource_get_info(router): directory = pathlib.Path(aiohttp.__file__).parent resource = router.add_static('/st', directory) assert resource.get_info() == {'directory': directory, 'prefix': '/st'} @asyncio.coroutine def test_system_route_get_info(router): handler = make_handler() router.add_route('GET', '/', handler) req = make_request('GET', '/abc') info = yield from router.resolve(req) assert info.get_info()['http_exception'].status == 404 def test_resources_view_len(router): router.add_resource('/plain') router.add_resource('/variable/{name}') assert 2 == len(router.resources()) def test_resources_view_iter(router): resource1 = router.add_resource('/plain') resource2 = router.add_resource('/variable/{name}') resources = [resource1, resource2] assert list(resources) == list(router.resources()) def test_resources_view_contains(router): resource1 = router.add_resource('/plain') resource2 = router.add_resource('/variable/{name}') resources = [resource1, resource2] for resource in resources: assert resource in router.resources() def test_resources_abc(router): assert isinstance(router.resources(), Sized) assert isinstance(router.resources(), Iterable) assert isinstance(router.resources(), Container) def test_static_route_user_home(router): here = pathlib.Path(aiohttp.__file__).parent home = pathlib.Path(os.path.expanduser('~')) if not str(here).startswith(str(home)): # pragma: no cover pytest.skip("aiohttp folder is not placed in user's HOME") static_dir = '~/' + str(here.relative_to(home)) route = router.add_static('/st', static_dir) assert here == route.get_info()['directory'] def test_static_route_points_to_file(router): here = pathlib.Path(aiohttp.__file__).parent / '__init__.py' with pytest.raises(ValueError): router.add_static('/st', here) @asyncio.coroutine def test_404_for_static_resource(router): resource = router.add_static('/st', os.path.dirname(aiohttp.__file__)) ret = yield from resource.resolve( make_mocked_request('GET', '/unknown/path')) assert (None, set()) == ret @asyncio.coroutine def test_405_for_resource_adapter(router): resource = router.add_static('/st', os.path.dirname(aiohttp.__file__)) ret = yield from resource.resolve( make_mocked_request('POST', '/st/abc.py')) assert (None, {'HEAD', 'GET'}) == ret @asyncio.coroutine def test_check_allowed_method_for_found_resource(router): handler = make_handler() resource = router.add_resource('/') resource.add_route('GET', handler) ret = yield from resource.resolve(make_mocked_request('GET', '/')) assert ret[0] is not None assert {'GET'} == ret[1] def test_url_for_in_static_resource(router): resource = router.add_static('/static', os.path.dirname(aiohttp.__file__)) assert URL('/static/file.txt') == resource.url_for(filename='file.txt') def test_url_for_in_static_resource_pathlib(router): resource = router.add_static('/static', os.path.dirname(aiohttp.__file__)) assert URL('/static/file.txt') == resource.url_for( filename=pathlib.Path('file.txt')) def test_url_for_in_resource_route(router): route = router.add_route('GET', '/get/{name}', make_handler(), name='name') assert URL('/get/John') == route.url_for(name='John') def test_subapp_get_info(router, loop): subapp = web.Application(loop=loop) resource = router.add_subapp('/pre', subapp) assert resource.get_info() == {'prefix': '/pre', 'app': subapp} def test_subapp_url(router, loop): subapp = web.Application(loop=loop) resource = router.add_subapp('/pre', subapp) with pytest.raises(RuntimeError): resource.url() def test_subapp_url_for(router, loop): subapp = web.Application(loop=loop) resource = router.add_subapp('/pre', subapp) with pytest.raises(RuntimeError): resource.url_for() def test_subapp_repr(router, loop): subapp = web.Application(loop=loop) resource = router.add_subapp('/pre', subapp) assert repr(resource).startswith( ' end resp = yield from client.get('/', headers={'Range': 'bytes=100-0'}) assert resp.status == 416, "Range start can't be greater than end" resp.close() # start > end resp = yield from client.get('/', headers={'Range': 'bytes=10-9'}) assert resp.status == 416, "Range start can't be greater than end" resp.close() # non-number range resp = yield from client.get('/', headers={'Range': 'bytes=a-f'}) assert resp.status == 416, 'Range must be integers' resp.close() # double dash range resp = yield from client.get('/', headers={'Range': 'bytes=0--10'}) assert resp.status == 416, 'double dash in range' resp.close() # no range resp = yield from client.get('/', headers={'Range': 'bytes=-'}) assert resp.status == 416, 'no range given' resp.close() aiohttp-1.2.0/tests/test_run_app.py0000664000175000017500000000472213025134363020252 0ustar travistravis00000000000000import ssl from unittest import mock from aiohttp import web def test_run_app_http(loop, mocker): mocker.spy(loop, 'create_server') loop.call_later(0.05, loop.stop) app = web.Application(loop=loop) mocker.spy(app, 'startup') web.run_app(app, print=lambda *args: None) assert loop.is_closed() loop.create_server.assert_called_with(mock.ANY, '0.0.0.0', 8080, ssl=None, backlog=128) app.startup.assert_called_once_with() def test_run_app_http_access_format(loop, mocker): mocker.spy(loop, 'create_server') loop.call_later(0.05, loop.stop) app = web.Application(loop=loop) mocker.spy(app, 'startup') web.run_app(app, print=lambda *args: None, access_log_format='%a') assert loop.is_closed() cs = loop.create_server cs.assert_called_with(mock.ANY, '0.0.0.0', 8080, ssl=None, backlog=128) assert cs.call_args[0][0]._kwargs['access_log_format'] == '%a' app.startup.assert_called_once_with() def test_run_app_https(loop, mocker): mocker.spy(loop, 'create_server') loop.call_later(0.05, loop.stop) app = web.Application(loop=loop) mocker.spy(app, 'startup') ssl_context = ssl.create_default_context() web.run_app(app, ssl_context=ssl_context, print=lambda *args: None) assert loop.is_closed() loop.create_server.assert_called_with(mock.ANY, '0.0.0.0', 8443, ssl=ssl_context, backlog=128) app.startup.assert_called_once_with() def test_run_app_nondefault_host_port(loop, unused_port, mocker): port = unused_port() host = 'localhost' mocker.spy(loop, 'create_server') loop.call_later(0.05, loop.stop) app = web.Application(loop=loop) mocker.spy(app, 'startup') web.run_app(app, host=host, port=port, print=lambda *args: None) assert loop.is_closed() loop.create_server.assert_called_with(mock.ANY, host, port, ssl=None, backlog=128) app.startup.assert_called_once_with() def test_run_app_custom_backlog(loop, mocker): mocker.spy(loop, 'create_server') loop.call_later(0.05, loop.stop) app = web.Application(loop=loop) mocker.spy(app, 'startup') web.run_app(app, backlog=10, print=lambda *args: None) assert loop.is_closed() loop.create_server.assert_called_with(mock.ANY, '0.0.0.0', 8080, ssl=None, backlog=10) app.startup.assert_called_once_with() aiohttp-1.2.0/tests/test_client_connection.py0000664000175000017500000000566613025134363022313 0ustar travistravis00000000000000import gc from unittest import mock import pytest from aiohttp.connector import Connection @pytest.fixture def key(): return object() @pytest.fixture def connector(): return mock.Mock() @pytest.fixture def request(): return mock.Mock() @pytest.fixture def transport(): return mock.Mock() @pytest.fixture def protocol(): return mock.Mock() def test_del(connector, key, request, transport, protocol, loop): conn = Connection(connector, key, request, transport, protocol, loop) exc_handler = mock.Mock() loop.set_exception_handler(exc_handler) with pytest.warns(ResourceWarning): del conn gc.collect() connector._release.assert_called_with(key, request, transport, protocol, should_close=True) msg = {'client_connection': mock.ANY, # conn was deleted 'message': 'Unclosed connection'} if loop.get_debug(): msg['source_traceback'] = mock.ANY exc_handler.assert_called_with(loop, msg) def test_close(connector, key, request, transport, protocol, loop): conn = Connection(connector, key, request, transport, protocol, loop) assert not conn.closed conn.close() assert conn._transport is None connector._release.assert_called_with( key, request, transport, protocol, should_close=True) assert conn.closed def test_release(connector, key, request, transport, protocol, loop): conn = Connection(connector, key, request, transport, protocol, loop) assert not conn.closed conn.release() assert not transport.close.called assert conn._transport is None connector._release.assert_called_with( key, request, transport, protocol, should_close=False) assert conn.closed def test_release_released(connector, key, request, transport, protocol, loop): conn = Connection(connector, key, request, transport, protocol, loop) conn.release() connector._release.reset_mock() conn.release() assert not transport.close.called assert conn._transport is None assert not connector._release.called def test_detach(connector, key, request, transport, protocol, loop): conn = Connection(connector, key, request, transport, protocol, loop) assert not conn.closed conn.detach() assert conn._transport is None assert connector._release_acquired.called assert not connector._release.called assert conn.closed def test_detach_closed(connector, key, request, transport, protocol, loop): conn = Connection(connector, key, request, transport, protocol, loop) conn.release() conn.detach() assert not connector._release_acquired.called assert conn._transport is None aiohttp-1.2.0/Makefile0000664000175000017500000000503413025134363015470 0ustar travistravis00000000000000# Some simple testing tasks (sorry, UNIX only). .install-deps: requirements-dev.txt @pip install -U -r requirements-dev.txt @touch .install-deps isort: isort -rc aiohttp isort -rc tests isort -rc examples isort -rc demos flake: .flake .flake: .install-deps $(shell find aiohttp -type f) \ $(shell find tests -type f) \ $(shell find benchmark -type f) \ $(shell find examples -type f) \ $(shell find demos -type f) @flake8 aiohttp @if python -c "import sys; sys.exit(sys.version_info < (3,5))"; then \ flake8 examples tests demos benchmark && \ python setup.py check -rms; \ fi @if ! isort -c -rc aiohttp tests examples; then \ echo "Import sort errors, run 'make isort' to fix them!!!"; \ isort --diff -rc aiohttp tests benchmark examples; \ false; \ fi @touch .flake .develop: .install-deps $(shell find aiohttp -type f) .flake @pip install -e . @touch .develop test: .develop @py.test -q ./tests vtest: .develop @py.test -s -v ./tests cov cover coverage: tox cov-dev: .develop @py.test --cov=aiohttp --cov-report=term --cov-report=html tests @echo "open file://`pwd`/coverage/index.html" cov-dev-full: .develop @echo "Run without extensions" @AIOHTTP_NO_EXTENSIONS=1 py.test --cov=aiohttp tests @echo "Run in debug mode" @PYTHONASYNCIODEBUG=1 py.test --cov=aiohttp --cov-append tests @echo "Regular run" @py.test --cov=aiohttp --cov-report=term --cov-report=html --cov-append tests @echo "open file://`pwd`/coverage/index.html" clean: @rm -rf `find . -name __pycache__` @rm -f `find . -type f -name '*.py[co]' ` @rm -f `find . -type f -name '*~' ` @rm -f `find . -type f -name '.*~' ` @rm -f `find . -type f -name '@*' ` @rm -f `find . -type f -name '#*#' ` @rm -f `find . -type f -name '*.orig' ` @rm -f `find . -type f -name '*.rej' ` @rm -f .coverage @rm -rf coverage @rm -rf build @rm -rf cover @make -C docs clean @python setup.py clean @rm -f aiohttp/_multidict.html @rm -f aiohttp/_multidict.c @rm -f aiohttp/_multidict.*.so @rm -f aiohttp/_multidict.*.pyd @rm -f aiohttp/_websocket.html @rm -f aiohttp/_websocket.c @rm -f aiohttp/_websocket.*.so @rm -f aiohttp/_websocket.*.pyd @rm -rf .tox doc: @make -C docs html SPHINXOPTS="-W -E" @echo "open file://`pwd`/docs/_build/html/index.html" doc-spelling: @make -C docs spelling SPHINXOPTS="-W -E" install: @pip install -U pip @pip install -Ur requirements-dev.txt .PHONY: all build flake test vtest cov clean doc aiohttp-1.2.0/aiohttp.egg-info/0000775000175000017500000000000013025135427017172 5ustar travistravis00000000000000aiohttp-1.2.0/aiohttp.egg-info/PKG-INFO0000664000175000017500000001750513025135427020277 0ustar travistravis00000000000000Metadata-Version: 1.1 Name: aiohttp Version: 1.2.0 Summary: http client/server for asyncio Home-page: https://github.com/KeepSafe/aiohttp/ Author: Andrew Svetlov Author-email: andrew.svetlov@gmail.com License: Apache 2 Description: http client/server for asyncio ============================== .. image:: https://raw.github.com/KeepSafe/aiohttp/master/docs/_static/aiohttp-icon-128x128.png :height: 64px :width: 64px :alt: aiohttp logo .. image:: https://travis-ci.org/KeepSafe/aiohttp.svg?branch=master :target: https://travis-ci.org/KeepSafe/aiohttp :align: right .. image:: https://codecov.io/gh/KeepSafe/aiohttp/branch/master/graph/badge.svg :target: https://codecov.io/gh/KeepSafe/aiohttp .. image:: https://badge.fury.io/py/aiohttp.svg :target: https://badge.fury.io/py/aiohttp Features -------- - Supports both client and server side of HTTP protocol. - Supports both client and server Web-Sockets out-of-the-box. - Web-server has middlewares and pluggable routing. Getting started --------------- Client ^^^^^^ To retrieve something from the web: .. code-block:: python import aiohttp import asyncio async def fetch(session, url): with aiohttp.Timeout(10, loop=session.loop): async with session.get(url) as response: return await response.text() async def main(loop): async with aiohttp.ClientSession(loop=loop) as session: html = await fetch(session, 'http://python.org') print(html) if __name__ == '__main__': loop = asyncio.get_event_loop() loop.run_until_complete(main(loop)) Server ^^^^^^ This is simple usage example: .. code-block:: python from aiohttp import web async def handle(request): name = request.match_info.get('name', "Anonymous") text = "Hello, " + name return web.Response(text=text) async def wshandler(request): ws = web.WebSocketResponse() await ws.prepare(request) async for msg in ws: if msg.type == web.MsgType.text: ws.send_str("Hello, {}".format(msg.data)) elif msg.type == web.MsgType.binary: ws.send_bytes(msg.data) elif msg.type == web.MsgType.close: break return ws app = web.Application() app.router.add_get('/echo', wshandler) app.router.add_get('/', handle) app.router.add_get('/{name}', handle) web.run_app(app) Note: examples are written for Python 3.5+ and utilize PEP-492 aka async/await. If you are using Python 3.4 please replace ``await`` with ``yield from`` and ``async def`` with ``@coroutine`` e.g.:: async def coro(...): ret = await f() should be replaced by:: @asyncio.coroutine def coro(...): ret = yield from f() Documentation ------------- https://aiohttp.readthedocs.io/ Discussion list --------------- *aio-libs* google group: https://groups.google.com/forum/#!forum/aio-libs Requirements ------------ - Python >= 3.4.2 - async-timeout_ - chardet_ - multidict_ - yarl_ Optionally you may install the cChardet_ and aiodns_ libraries (highly recommended for sake of speed). .. _chardet: https://pypi.python.org/pypi/chardet .. _aiodns: https://pypi.python.org/pypi/aiodns .. _multidict: https://pypi.python.org/pypi/multidict .. _yarl: https://pypi.python.org/pypi/yarl .. _async-timeout: https://pypi.python.org/pypi/async_timeout .. _cChardet: https://pypi.python.org/pypi/cchardet License ------- ``aiohttp`` is offered under the Apache 2 license. Source code ------------ The latest developer version is available in a github repository: https://github.com/KeepSafe/aiohttp Benchmarks ---------- If you are interested in by efficiency, AsyncIO community maintains a list of benchmarks on the official wiki: https://github.com/python/asyncio/wiki/Benchmarks CHANGES ======= 1.2.0 (2016-12-17) ------------------ - Extract `BaseRequest` from `web.Request`, introduce `web.Server` (former `RequestHandlerFactory`), introduce new low-level web server which is not coupled with `web.Application` and routing #1362 - Make `TestServer.make_url` compatible with `yarl.URL` #1389 - Implement range requests for static files #1382 - Support task attribute for StreamResponse #1410 - Drop `TestClient.app` property, use `TestClient.server.app` instead (BACKWARD INCOMPATIBLE) - Drop `TestClient.handler` property, use `TestClient.server.handler` instead (BACKWARD INCOMPATIBLE) - `TestClient.server` property returns a test server instance, was `asyncio.AbstractServer` (BACKWARD INCOMPATIBLE) - Follow gunicorn's signal semantics in `Gunicorn[UVLoop]WebWorker` #1201 - Call worker_int and worker_abort callbacks in `Gunicorn[UVLoop]WebWorker` #1202 - Has functional tests for client proxy #1218 - Fix bugs with client proxy target path and proxy host with port #1413 - Fix bugs related to the use of unicode hostnames #1444 - Preserve cookie quoting/escaping #1453 - FileSender will send gzipped response if gzip version available #1426 - Don't override `Content-Length` header in `web.Response` if no body was set #1400 - Introduce `router.post_init()` for solving #1373 - Fix raise error in case of multiple calls of `TimeServive.stop()` - Allow to raise web exceptions on router resolving stage #1460 - Add a warning for session creation outside of coroutine #1468 - Avoid a race when application might start accepting incoming requests but startup signals are not processed yet e98e8c6 - Raise a `RuntimeError` when trying to change the status of the HTTP response after the headers have been sent #1480 - Fix bug with https proxy acquired cleanup #1340 - Use UTF-8 as the default encoding for multipart text parts #1484 Platform: UNKNOWN Classifier: License :: OSI Approved :: Apache Software License Classifier: Intended Audience :: Developers Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Development Status :: 5 - Production/Stable Classifier: Operating System :: POSIX Classifier: Operating System :: MacOS :: MacOS X Classifier: Operating System :: Microsoft :: Windows Classifier: Topic :: Internet :: WWW/HTTP aiohttp-1.2.0/aiohttp.egg-info/SOURCES.txt0000664000175000017500000000772113025135427021065 0ustar travistravis00000000000000CHANGES.rst CONTRIBUTORS.txt LICENSE.txt MANIFEST.in Makefile README.rst setup.cfg setup.py aiohttp/__init__.py aiohttp/_websocket.c aiohttp/_websocket.pyx aiohttp/_ws_impl.py aiohttp/abc.py aiohttp/client.py aiohttp/client_reqrep.py aiohttp/client_ws.py aiohttp/connector.py aiohttp/cookiejar.py aiohttp/errors.py aiohttp/file_sender.py aiohttp/hdrs.py aiohttp/helpers.py aiohttp/log.py aiohttp/multipart.py aiohttp/parsers.py aiohttp/protocol.py aiohttp/pytest_plugin.py aiohttp/resolver.py aiohttp/server.py aiohttp/signals.py aiohttp/streams.py aiohttp/test_utils.py aiohttp/web.py aiohttp/web_exceptions.py aiohttp/web_reqrep.py aiohttp/web_server.py aiohttp/web_urldispatcher.py aiohttp/web_ws.py aiohttp/worker.py aiohttp/wsgi.py aiohttp.egg-info/PKG-INFO aiohttp.egg-info/SOURCES.txt aiohttp.egg-info/dependency_links.txt aiohttp.egg-info/requires.txt aiohttp.egg-info/top_level.txt docs/Makefile docs/abc.rst docs/aiohttp-icon.ico docs/aiohttp-icon.svg docs/api.rst docs/changes.rst docs/client.rst docs/client_reference.rst docs/conf.py docs/contributing.rst docs/deployment.rst docs/essays.rst docs/faq.rst docs/glossary.rst docs/index.rst docs/logging.rst docs/make.bat docs/multipart.rst docs/new_router.rst docs/server.rst docs/spelling_wordlist.txt docs/streams.rst docs/testing.rst docs/third_party.rst docs/tutorial.rst docs/web.rst docs/web_lowlevel.rst docs/web_reference.rst docs/whats_new_1_1.rst docs/_static/aiohttp-icon-128x128.png docs/_static/aiohttp-icon-32x32.png docs/_static/aiohttp-icon-64x64.png docs/_static/aiohttp-icon-96x96.png examples/background_tasks.py examples/basic_srv.py examples/cli_app.py examples/client_auth.py examples/client_json.py examples/client_ws.py examples/curl.py examples/fake_server.py examples/lowlevel_srv.py examples/server.crt examples/server.csr examples/server.key examples/static_files.py examples/web_classview1.py examples/web_cookies.py examples/web_rewrite_headers_middleware.py examples/web_srv.py examples/web_ws.py examples/websocket.html examples/legacy/crawl.py examples/legacy/srv.py examples/legacy/tcp_protocol_parser.py tests/conftest.py tests/data.unknown_mime_type tests/hello.txt.gz tests/sample.crt tests/sample.crt.der tests/sample.key tests/software_development_in_picture.jpg tests/test_classbasedview.py tests/test_client_connection.py tests/test_client_functional.py tests/test_client_functional_oldstyle.py tests/test_client_request.py tests/test_client_response.py tests/test_client_session.py tests/test_client_ws.py tests/test_client_ws_functional.py tests/test_connector.py tests/test_cookiejar.py tests/test_errors.py tests/test_flowcontrol_streams.py tests/test_helpers.py tests/test_http_parser.py tests/test_multipart.py tests/test_parser_buffer.py tests/test_protocol.py tests/test_proxy.py tests/test_proxy_functional.py tests/test_pytest_plugin.py tests/test_resolver.py tests/test_run_app.py tests/test_server.py tests/test_signals.py tests/test_stream_parser.py tests/test_stream_protocol.py tests/test_stream_writer.py tests/test_streams.py tests/test_test_utils.py tests/test_urldispatch.py tests/test_web_application.py tests/test_web_cli.py tests/test_web_exceptions.py tests/test_web_functional.py tests/test_web_middleware.py tests/test_web_request.py tests/test_web_request_handler.py tests/test_web_response.py tests/test_web_sendfile.py tests/test_web_sendfile_functional.py tests/test_web_server.py tests/test_web_urldispatcher.py tests/test_web_websocket.py tests/test_web_websocket_functional.py tests/test_websocket_handshake.py tests/test_websocket_parser.py tests/test_websocket_writer.py tests/test_worker.py tests/test_wsgi.py tests/autobahn/client.py tests/autobahn/fuzzingclient.json tests/autobahn/fuzzingserver.json tests/autobahn/server.py tests/test_py35/test_cbv35.py tests/test_py35/test_client.py tests/test_py35/test_client_websocket_35.py tests/test_py35/test_multipart_35.py tests/test_py35/test_resp.py tests/test_py35/test_streams_35.py tests/test_py35/test_test_utils_35.py tests/test_py35/test_web_websocket_35.pyaiohttp-1.2.0/aiohttp.egg-info/requires.txt0000664000175000017500000000007213025135427021571 0ustar travistravis00000000000000chardet multidict>=2.1.4 async_timeout>=1.1.0 yarl>=0.8.1 aiohttp-1.2.0/aiohttp.egg-info/dependency_links.txt0000664000175000017500000000000113025135427023240 0ustar travistravis00000000000000 aiohttp-1.2.0/aiohttp.egg-info/top_level.txt0000664000175000017500000000001013025135427021713 0ustar travistravis00000000000000aiohttp aiohttp-1.2.0/PKG-INFO0000664000175000017500000001750513025135427015135 0ustar travistravis00000000000000Metadata-Version: 1.1 Name: aiohttp Version: 1.2.0 Summary: http client/server for asyncio Home-page: https://github.com/KeepSafe/aiohttp/ Author: Andrew Svetlov Author-email: andrew.svetlov@gmail.com License: Apache 2 Description: http client/server for asyncio ============================== .. image:: https://raw.github.com/KeepSafe/aiohttp/master/docs/_static/aiohttp-icon-128x128.png :height: 64px :width: 64px :alt: aiohttp logo .. image:: https://travis-ci.org/KeepSafe/aiohttp.svg?branch=master :target: https://travis-ci.org/KeepSafe/aiohttp :align: right .. image:: https://codecov.io/gh/KeepSafe/aiohttp/branch/master/graph/badge.svg :target: https://codecov.io/gh/KeepSafe/aiohttp .. image:: https://badge.fury.io/py/aiohttp.svg :target: https://badge.fury.io/py/aiohttp Features -------- - Supports both client and server side of HTTP protocol. - Supports both client and server Web-Sockets out-of-the-box. - Web-server has middlewares and pluggable routing. Getting started --------------- Client ^^^^^^ To retrieve something from the web: .. code-block:: python import aiohttp import asyncio async def fetch(session, url): with aiohttp.Timeout(10, loop=session.loop): async with session.get(url) as response: return await response.text() async def main(loop): async with aiohttp.ClientSession(loop=loop) as session: html = await fetch(session, 'http://python.org') print(html) if __name__ == '__main__': loop = asyncio.get_event_loop() loop.run_until_complete(main(loop)) Server ^^^^^^ This is simple usage example: .. code-block:: python from aiohttp import web async def handle(request): name = request.match_info.get('name', "Anonymous") text = "Hello, " + name return web.Response(text=text) async def wshandler(request): ws = web.WebSocketResponse() await ws.prepare(request) async for msg in ws: if msg.type == web.MsgType.text: ws.send_str("Hello, {}".format(msg.data)) elif msg.type == web.MsgType.binary: ws.send_bytes(msg.data) elif msg.type == web.MsgType.close: break return ws app = web.Application() app.router.add_get('/echo', wshandler) app.router.add_get('/', handle) app.router.add_get('/{name}', handle) web.run_app(app) Note: examples are written for Python 3.5+ and utilize PEP-492 aka async/await. If you are using Python 3.4 please replace ``await`` with ``yield from`` and ``async def`` with ``@coroutine`` e.g.:: async def coro(...): ret = await f() should be replaced by:: @asyncio.coroutine def coro(...): ret = yield from f() Documentation ------------- https://aiohttp.readthedocs.io/ Discussion list --------------- *aio-libs* google group: https://groups.google.com/forum/#!forum/aio-libs Requirements ------------ - Python >= 3.4.2 - async-timeout_ - chardet_ - multidict_ - yarl_ Optionally you may install the cChardet_ and aiodns_ libraries (highly recommended for sake of speed). .. _chardet: https://pypi.python.org/pypi/chardet .. _aiodns: https://pypi.python.org/pypi/aiodns .. _multidict: https://pypi.python.org/pypi/multidict .. _yarl: https://pypi.python.org/pypi/yarl .. _async-timeout: https://pypi.python.org/pypi/async_timeout .. _cChardet: https://pypi.python.org/pypi/cchardet License ------- ``aiohttp`` is offered under the Apache 2 license. Source code ------------ The latest developer version is available in a github repository: https://github.com/KeepSafe/aiohttp Benchmarks ---------- If you are interested in by efficiency, AsyncIO community maintains a list of benchmarks on the official wiki: https://github.com/python/asyncio/wiki/Benchmarks CHANGES ======= 1.2.0 (2016-12-17) ------------------ - Extract `BaseRequest` from `web.Request`, introduce `web.Server` (former `RequestHandlerFactory`), introduce new low-level web server which is not coupled with `web.Application` and routing #1362 - Make `TestServer.make_url` compatible with `yarl.URL` #1389 - Implement range requests for static files #1382 - Support task attribute for StreamResponse #1410 - Drop `TestClient.app` property, use `TestClient.server.app` instead (BACKWARD INCOMPATIBLE) - Drop `TestClient.handler` property, use `TestClient.server.handler` instead (BACKWARD INCOMPATIBLE) - `TestClient.server` property returns a test server instance, was `asyncio.AbstractServer` (BACKWARD INCOMPATIBLE) - Follow gunicorn's signal semantics in `Gunicorn[UVLoop]WebWorker` #1201 - Call worker_int and worker_abort callbacks in `Gunicorn[UVLoop]WebWorker` #1202 - Has functional tests for client proxy #1218 - Fix bugs with client proxy target path and proxy host with port #1413 - Fix bugs related to the use of unicode hostnames #1444 - Preserve cookie quoting/escaping #1453 - FileSender will send gzipped response if gzip version available #1426 - Don't override `Content-Length` header in `web.Response` if no body was set #1400 - Introduce `router.post_init()` for solving #1373 - Fix raise error in case of multiple calls of `TimeServive.stop()` - Allow to raise web exceptions on router resolving stage #1460 - Add a warning for session creation outside of coroutine #1468 - Avoid a race when application might start accepting incoming requests but startup signals are not processed yet e98e8c6 - Raise a `RuntimeError` when trying to change the status of the HTTP response after the headers have been sent #1480 - Fix bug with https proxy acquired cleanup #1340 - Use UTF-8 as the default encoding for multipart text parts #1484 Platform: UNKNOWN Classifier: License :: OSI Approved :: Apache Software License Classifier: Intended Audience :: Developers Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Development Status :: 5 - Production/Stable Classifier: Operating System :: POSIX Classifier: Operating System :: MacOS :: MacOS X Classifier: Operating System :: Microsoft :: Windows Classifier: Topic :: Internet :: WWW/HTTP aiohttp-1.2.0/setup.py0000664000175000017500000000674713025134363015556 0ustar travistravis00000000000000import codecs import os import re import sys from distutils.command.build_ext import build_ext from distutils.errors import (CCompilerError, DistutilsExecError, DistutilsPlatformError) from setuptools import Extension, setup from setuptools.command.test import test as TestCommand try: from Cython.Build import cythonize USE_CYTHON = True except ImportError: USE_CYTHON = False ext = '.pyx' if USE_CYTHON else '.c' extensions = [Extension('aiohttp._websocket', ['aiohttp/_websocket' + ext])] if USE_CYTHON: extensions = cythonize(extensions) class BuildFailed(Exception): pass class ve_build_ext(build_ext): # This class allows C extension building to fail. def run(self): try: build_ext.run(self) except (DistutilsPlatformError, FileNotFoundError): raise BuildFailed() def build_extension(self, ext): try: build_ext.build_extension(self, ext) except (CCompilerError, DistutilsExecError, DistutilsPlatformError, ValueError): raise BuildFailed() with codecs.open(os.path.join(os.path.abspath(os.path.dirname( __file__)), 'aiohttp', '__init__.py'), 'r', 'latin1') as fp: try: version = re.findall(r"^__version__ = '([^']+)'\r?$", fp.read(), re.M)[0] except IndexError: raise RuntimeError('Unable to determine version.') install_requires = ['chardet', 'multidict>=2.1.4', 'async_timeout>=1.1.0', 'yarl>=0.8.1'] if sys.version_info < (3, 4, 2): raise RuntimeError("aiohttp requires Python 3.4.2+") def read(f): return open(os.path.join(os.path.dirname(__file__), f)).read().strip() class PyTest(TestCommand): user_options = [] def run(self): import subprocess import sys errno = subprocess.call([sys.executable, '-m', 'pytest', 'tests']) raise SystemExit(errno) tests_require = install_requires + ['pytest', 'gunicorn', 'pytest-timeout'] args = dict( name='aiohttp', version=version, description='http client/server for asyncio', long_description='\n\n'.join((read('README.rst'), read('CHANGES.rst'))), classifiers=[ 'License :: OSI Approved :: Apache Software License', 'Intended Audience :: Developers', 'Programming Language :: Python', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Development Status :: 5 - Production/Stable', 'Operating System :: POSIX', 'Operating System :: MacOS :: MacOS X', 'Operating System :: Microsoft :: Windows', 'Topic :: Internet :: WWW/HTTP'], author='Nikolay Kim', author_email='fafhrd91@gmail.com', maintainer='Andrew Svetlov', maintainer_email='andrew.svetlov@gmail.com', url='https://github.com/KeepSafe/aiohttp/', license='Apache 2', packages=['aiohttp'], install_requires=install_requires, tests_require=tests_require, include_package_data=True, ext_modules=extensions, cmdclass=dict(build_ext=ve_build_ext, test=PyTest)) try: setup(**args) except BuildFailed: print("************************************************************") print("Cannot compile C accelerator module, use pure python version") print("************************************************************") del args['ext_modules'] del args['cmdclass'] setup(**args) aiohttp-1.2.0/CONTRIBUTORS.txt0000664000175000017500000000462413025134363016532 0ustar travistravis00000000000000Contributors ------------ A. Jesse Jiryu Davis Alejandro Gómez Aleksandr Danshyn Aleksey Kutepov Alex Hayes Alexander Bayandin Alexander Karpinsky Alexander Koshevoy Alexander Malev Alexander Mohr Alexander Shorin Alexander Travov Alexandru Mihai Alexey Firsov Alexey Popravka Alex Key Alex Khomchenko Alex Lisovoy Amy Boyle Andrei Ursulenko Andrej Antonov Andrew Leech Andrew Svetlov Andrii Soldatenko Anton Kasyanov Arthur Darcet Ben Bader Benedikt Reinartz Boris Feld Brett Cannon Brian C. Lane Brian Muller Carl George Chien-Wei Huang Chih-Yuan Chen Chris AtLee Chris Laws Chris Moore Christopher Schmitt Daniel García Daniel Nelson Danny Song David Michael Brown Denis Matiychuk Dima Veselov Dimitar Dimitrov Dmitry Shamov Dmitry Trofimov Dmytro Kuznetsov Dustin J. Mitchell Elizabeth Leddy Enrique Saez Erich Healy Eugene Chernyshov Eugene Naydenov Frederik Gladhorn Frederik Peter Aalund Gabriel Tremblay Gennady Andreyev Georges Dubus Greg Holt Gregory Haynes Günther Jena Hugo Herter Igor Pavlov Ingmar Steen Jacob Champion Jaesung Lee Jake Davis Jakub Wilk Jashandeep Sohi Jeroen van der Heijden Jesus Cea Jinkyu Yi Joel Watts Joongi Kim Julien Duponchelle Junjie Tao Justas Trimailovas Kay Zheng Kimmo Parviainen-Jalanko Kirill Klenov Kirill Malovitsa Kyrylo Perevozchikov Lars P. Søndergaard Louis-Philippe Huberdeau Lubomir Gelo Ludovic Gasc Lukasz Marcin Dobrzanski Manuel Miranda Marco Paolini Mariano Anaya Martin Richard Mathias Fröjdman Matthieu Hauglustaine Michael Ihnatenko Mikhail Kashkin Mikhail Lukyanchenko Misha Behersky Morgan Delahaye-Prat Moss Collum Mun Gwan-gyeong Nicolas Braem Nikolay Novik Olaf Conradi Pahaz Blinov Pankaj Pandey Pau Freixes Paul Colomiets Paulus Schoutsen Philipp A. Rafael Viotti Raúl Cumplido "Required Field" Robert Lu Samuel Colvin Sebastian Hanula Sebastian Hüther SeongSoo Cho Sergey Ninua Sergey Skripnick Serhii Kostel Simon Kennedy Sin-Woo Bang Stanislas Plum Stanislav Prokop Stephen Granade Steven Seguin Sviatoslav Bulbakha Taha Jahangir Taras Voinarovskyi Thomas Grainger Tolga Tezel Vaibhav Sagar Vamsi Krishna Avula Vasyl Baran Vikas Kawadia Vitalik Verhovodov Vitaly Haritonsky Vitaly Magerya Vladimir Kozlovski Vladimir Rutsky Vladimir Shulyak Vladimir Zakharov Willem de Groot Wilson Ong W. Trevor King Yannick Koechlin Young-Ho Cha Yury Selivanov Yusuke Tsutsumi Марк Коренберг Семён Марьясин aiohttp-1.2.0/LICENSE.txt0000664000175000017500000002610413025134363015654 0ustar travistravis00000000000000Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright 2013-2016 Nikolay Kim and Andrew Svetlov Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. aiohttp-1.2.0/CHANGES.rst0000664000175000017500000000355413025134363015637 0ustar travistravis00000000000000CHANGES ======= 1.2.0 (2016-12-17) ------------------ - Extract `BaseRequest` from `web.Request`, introduce `web.Server` (former `RequestHandlerFactory`), introduce new low-level web server which is not coupled with `web.Application` and routing #1362 - Make `TestServer.make_url` compatible with `yarl.URL` #1389 - Implement range requests for static files #1382 - Support task attribute for StreamResponse #1410 - Drop `TestClient.app` property, use `TestClient.server.app` instead (BACKWARD INCOMPATIBLE) - Drop `TestClient.handler` property, use `TestClient.server.handler` instead (BACKWARD INCOMPATIBLE) - `TestClient.server` property returns a test server instance, was `asyncio.AbstractServer` (BACKWARD INCOMPATIBLE) - Follow gunicorn's signal semantics in `Gunicorn[UVLoop]WebWorker` #1201 - Call worker_int and worker_abort callbacks in `Gunicorn[UVLoop]WebWorker` #1202 - Has functional tests for client proxy #1218 - Fix bugs with client proxy target path and proxy host with port #1413 - Fix bugs related to the use of unicode hostnames #1444 - Preserve cookie quoting/escaping #1453 - FileSender will send gzipped response if gzip version available #1426 - Don't override `Content-Length` header in `web.Response` if no body was set #1400 - Introduce `router.post_init()` for solving #1373 - Fix raise error in case of multiple calls of `TimeServive.stop()` - Allow to raise web exceptions on router resolving stage #1460 - Add a warning for session creation outside of coroutine #1468 - Avoid a race when application might start accepting incoming requests but startup signals are not processed yet e98e8c6 - Raise a `RuntimeError` when trying to change the status of the HTTP response after the headers have been sent #1480 - Fix bug with https proxy acquired cleanup #1340 - Use UTF-8 as the default encoding for multipart text parts #1484 aiohttp-1.2.0/README.rst0000664000175000017500000000705613025134363015525 0ustar travistravis00000000000000http client/server for asyncio ============================== .. image:: https://raw.github.com/KeepSafe/aiohttp/master/docs/_static/aiohttp-icon-128x128.png :height: 64px :width: 64px :alt: aiohttp logo .. image:: https://travis-ci.org/KeepSafe/aiohttp.svg?branch=master :target: https://travis-ci.org/KeepSafe/aiohttp :align: right .. image:: https://codecov.io/gh/KeepSafe/aiohttp/branch/master/graph/badge.svg :target: https://codecov.io/gh/KeepSafe/aiohttp .. image:: https://badge.fury.io/py/aiohttp.svg :target: https://badge.fury.io/py/aiohttp Features -------- - Supports both client and server side of HTTP protocol. - Supports both client and server Web-Sockets out-of-the-box. - Web-server has middlewares and pluggable routing. Getting started --------------- Client ^^^^^^ To retrieve something from the web: .. code-block:: python import aiohttp import asyncio async def fetch(session, url): with aiohttp.Timeout(10, loop=session.loop): async with session.get(url) as response: return await response.text() async def main(loop): async with aiohttp.ClientSession(loop=loop) as session: html = await fetch(session, 'http://python.org') print(html) if __name__ == '__main__': loop = asyncio.get_event_loop() loop.run_until_complete(main(loop)) Server ^^^^^^ This is simple usage example: .. code-block:: python from aiohttp import web async def handle(request): name = request.match_info.get('name', "Anonymous") text = "Hello, " + name return web.Response(text=text) async def wshandler(request): ws = web.WebSocketResponse() await ws.prepare(request) async for msg in ws: if msg.type == web.MsgType.text: ws.send_str("Hello, {}".format(msg.data)) elif msg.type == web.MsgType.binary: ws.send_bytes(msg.data) elif msg.type == web.MsgType.close: break return ws app = web.Application() app.router.add_get('/echo', wshandler) app.router.add_get('/', handle) app.router.add_get('/{name}', handle) web.run_app(app) Note: examples are written for Python 3.5+ and utilize PEP-492 aka async/await. If you are using Python 3.4 please replace ``await`` with ``yield from`` and ``async def`` with ``@coroutine`` e.g.:: async def coro(...): ret = await f() should be replaced by:: @asyncio.coroutine def coro(...): ret = yield from f() Documentation ------------- https://aiohttp.readthedocs.io/ Discussion list --------------- *aio-libs* google group: https://groups.google.com/forum/#!forum/aio-libs Requirements ------------ - Python >= 3.4.2 - async-timeout_ - chardet_ - multidict_ - yarl_ Optionally you may install the cChardet_ and aiodns_ libraries (highly recommended for sake of speed). .. _chardet: https://pypi.python.org/pypi/chardet .. _aiodns: https://pypi.python.org/pypi/aiodns .. _multidict: https://pypi.python.org/pypi/multidict .. _yarl: https://pypi.python.org/pypi/yarl .. _async-timeout: https://pypi.python.org/pypi/async_timeout .. _cChardet: https://pypi.python.org/pypi/cchardet License ------- ``aiohttp`` is offered under the Apache 2 license. Source code ------------ The latest developer version is available in a github repository: https://github.com/KeepSafe/aiohttp Benchmarks ---------- If you are interested in by efficiency, AsyncIO community maintains a list of benchmarks on the official wiki: https://github.com/python/asyncio/wiki/Benchmarks aiohttp-1.2.0/aiohttp/0000775000175000017500000000000013025135427015500 5ustar travistravis00000000000000aiohttp-1.2.0/aiohttp/multipart.py0000664000175000017500000007772313025134363020111 0ustar travistravis00000000000000import asyncio import base64 import binascii import io import json import mimetypes import os import re import sys import uuid import warnings import zlib from collections import Mapping, Sequence, deque from pathlib import Path from urllib.parse import parse_qsl, quote, unquote, urlencode from multidict import CIMultiDict from .hdrs import (CONTENT_DISPOSITION, CONTENT_ENCODING, CONTENT_LENGTH, CONTENT_TRANSFER_ENCODING, CONTENT_TYPE) from .helpers import parse_mimetype from .protocol import HttpParser __all__ = ('MultipartReader', 'MultipartWriter', 'BodyPartReader', 'BodyPartWriter', 'BadContentDispositionHeader', 'BadContentDispositionParam', 'parse_content_disposition', 'content_disposition_filename') CHAR = set(chr(i) for i in range(0, 128)) CTL = set(chr(i) for i in range(0, 32)) | {chr(127), } SEPARATORS = {'(', ')', '<', '>', '@', ',', ';', ':', '\\', '"', '/', '[', ']', '?', '=', '{', '}', ' ', chr(9)} TOKEN = CHAR ^ CTL ^ SEPARATORS PY_35 = sys.version_info >= (3, 5) PY_352 = sys.version_info >= (3, 5, 2) class BadContentDispositionHeader(RuntimeWarning): pass class BadContentDispositionParam(RuntimeWarning): pass def parse_content_disposition(header): def is_token(string): return string and TOKEN >= set(string) def is_quoted(string): return string[0] == string[-1] == '"' def is_rfc5987(string): return is_token(string) and string.count("'") == 2 def is_extended_param(string): return string.endswith('*') def is_continuous_param(string): pos = string.find('*') + 1 if not pos: return False substring = string[pos:-1] if string.endswith('*') else string[pos:] return substring.isdigit() def unescape(text, *, chars=''.join(map(re.escape, CHAR))): return re.sub('\\\\([{}])'.format(chars), '\\1', text) if not header: return None, {} disptype, *parts = header.split(';') if not is_token(disptype): warnings.warn(BadContentDispositionHeader(header)) return None, {} params = {} for item in parts: if '=' not in item: warnings.warn(BadContentDispositionHeader(header)) return None, {} key, value = item.split('=', 1) key = key.lower().strip() value = value.lstrip() if key in params: warnings.warn(BadContentDispositionHeader(header)) return None, {} if not is_token(key): warnings.warn(BadContentDispositionParam(item)) continue elif is_continuous_param(key): if is_quoted(value): value = unescape(value[1:-1]) elif not is_token(value): warnings.warn(BadContentDispositionParam(item)) continue elif is_extended_param(key): if is_rfc5987(value): encoding, _, value = value.split("'", 2) encoding = encoding or 'utf-8' else: warnings.warn(BadContentDispositionParam(item)) continue try: value = unquote(value, encoding, 'strict') except UnicodeDecodeError: # pragma: nocover warnings.warn(BadContentDispositionParam(item)) continue else: if is_quoted(value): value = unescape(value[1:-1].lstrip('\\/')) elif not is_token(value): warnings.warn(BadContentDispositionHeader(header)) return None, {} params[key] = value return disptype.lower(), params def content_disposition_filename(params): if not params: return None elif 'filename*' in params: return params['filename*'] elif 'filename' in params: return params['filename'] else: parts = [] fnparams = sorted((key, value) for key, value in params.items() if key.startswith('filename*')) for num, (key, value) in enumerate(fnparams): _, tail = key.split('*', 1) if tail.endswith('*'): tail = tail[:-1] if tail == str(num): parts.append(value) else: break if not parts: return None value = ''.join(parts) if "'" in value: encoding, _, value = value.split("'", 2) encoding = encoding or 'utf-8' return unquote(value, encoding, 'strict') return value class MultipartResponseWrapper(object): """Wrapper around the :class:`MultipartBodyReader` to take care about underlying connection and close it when it needs in.""" def __init__(self, resp, stream): self.resp = resp self.stream = stream if PY_35: def __aiter__(self): return self if not PY_352: # pragma: no cover __aiter__ = asyncio.coroutine(__aiter__) @asyncio.coroutine def __anext__(self): part = yield from self.next() if part is None: raise StopAsyncIteration # NOQA return part def at_eof(self): """Returns ``True`` when all response data had been read. :rtype: bool """ return self.resp.content.at_eof() @asyncio.coroutine def next(self): """Emits next multipart reader object.""" item = yield from self.stream.next() if self.stream.at_eof(): yield from self.release() return item @asyncio.coroutine def release(self): """Releases the connection gracefully, reading all the content to the void.""" yield from self.resp.release() class BodyPartReader(object): """Multipart reader for single body part.""" chunk_size = 8192 def __init__(self, boundary, headers, content): self.headers = headers self._boundary = boundary self._content = content self._at_eof = False length = self.headers.get(CONTENT_LENGTH, None) self._length = int(length) if length is not None else None self._read_bytes = 0 self._unread = deque() self._prev_chunk = None self._content_eof = 0 if PY_35: def __aiter__(self): return self if not PY_352: # pragma: no cover __aiter__ = asyncio.coroutine(__aiter__) @asyncio.coroutine def __anext__(self): part = yield from self.next() if part is None: raise StopAsyncIteration # NOQA return part @asyncio.coroutine def next(self): item = yield from self.read() if not item: return None return item @asyncio.coroutine def read(self, *, decode=False): """Reads body part data. :param bool decode: Decodes data following by encoding method from `Content-Encoding` header. If it missed data remains untouched :rtype: bytearray """ if self._at_eof: return b'' data = bytearray() if self._length is None: while not self._at_eof: data.extend((yield from self.readline())) else: while not self._at_eof: data.extend((yield from self.read_chunk(self.chunk_size))) if decode: return self.decode(data) return data @asyncio.coroutine def read_chunk(self, size=chunk_size): """Reads body part content chunk of the specified size. :param int size: chunk size :rtype: bytearray """ if self._at_eof: return b'' if self._length: chunk = yield from self._read_chunk_from_length(size) else: chunk = yield from self._read_chunk_from_stream(size) self._read_bytes += len(chunk) if self._read_bytes == self._length: self._at_eof = True if self._at_eof: assert b'\r\n' == (yield from self._content.readline()), \ 'reader did not read all the data or it is malformed' return chunk @asyncio.coroutine def _read_chunk_from_length(self, size): """Reads body part content chunk of the specified size. The body part must has `Content-Length` header with proper value. :param int size: chunk size :rtype: bytearray """ assert self._length is not None, \ 'Content-Length required for chunked read' chunk_size = min(size, self._length - self._read_bytes) chunk = yield from self._content.read(chunk_size) return chunk @asyncio.coroutine def _read_chunk_from_stream(self, size): """Reads content chunk of body part with unknown length. The `Content-Length` header for body part is not necessary. :param int size: chunk size :rtype: bytearray """ assert size >= len(self._boundary) + 2, \ 'Chunk size must be greater or equal than boundary length + 2' first_chunk = self._prev_chunk is None if first_chunk: self._prev_chunk = yield from self._content.read(size) chunk = yield from self._content.read(size) self._content_eof += int(self._content.at_eof()) assert self._content_eof < 3, "Reading after EOF" window = self._prev_chunk + chunk sub = b'\r\n' + self._boundary if first_chunk: idx = window.find(sub) else: idx = window.find(sub, max(0, len(self._prev_chunk) - len(sub))) if idx >= 0: # pushing boundary back to content self._content.unread_data(window[idx:]) if size > idx: self._prev_chunk = self._prev_chunk[:idx] chunk = window[len(self._prev_chunk):idx] if not chunk: self._at_eof = True result = self._prev_chunk self._prev_chunk = chunk return result @asyncio.coroutine def readline(self): """Reads body part by line by line. :rtype: bytearray """ if self._at_eof: return b'' if self._unread: line = self._unread.popleft() else: line = yield from self._content.readline() if line.startswith(self._boundary): # the very last boundary may not come with \r\n, # so set single rules for everyone sline = line.rstrip(b'\r\n') boundary = self._boundary last_boundary = self._boundary + b'--' # ensure that we read exactly the boundary, not something alike if sline == boundary or sline == last_boundary: self._at_eof = True self._unread.append(line) return b'' else: next_line = yield from self._content.readline() if next_line.startswith(self._boundary): line = line[:-2] # strip CRLF but only once self._unread.append(next_line) return line @asyncio.coroutine def release(self): """Like :meth:`read`, but reads all the data to the void. :rtype: None """ if self._at_eof: return if self._length is None: while not self._at_eof: yield from self.readline() else: while not self._at_eof: yield from self.read_chunk(self.chunk_size) @asyncio.coroutine def text(self, *, encoding=None): """Like :meth:`read`, but assumes that body part contains text data. :param str encoding: Custom text encoding. Overrides specified in charset param of `Content-Type` header :rtype: str """ data = yield from self.read(decode=True) # see https://www.w3.org/TR/html5/forms.html#multipart/form-data-encoding-algorithm # NOQA # and https://dvcs.w3.org/hg/xhr/raw-file/tip/Overview.html#dom-xmlhttprequest-send # NOQA encoding = encoding or self.get_charset(default='utf-8') return data.decode(encoding) @asyncio.coroutine def json(self, *, encoding=None): """Like :meth:`read`, but assumes that body parts contains JSON data. :param str encoding: Custom JSON encoding. Overrides specified in charset param of `Content-Type` header """ data = yield from self.read(decode=True) if not data: return None encoding = encoding or self.get_charset(default='utf-8') return json.loads(data.decode(encoding)) @asyncio.coroutine def form(self, *, encoding=None): """Like :meth:`read`, but assumes that body parts contains form urlencoded data. :param str encoding: Custom form encoding. Overrides specified in charset param of `Content-Type` header """ data = yield from self.read(decode=True) if not data: return None encoding = encoding or self.get_charset(default='utf-8') return parse_qsl(data.rstrip().decode(encoding), encoding=encoding) def at_eof(self): """Returns ``True`` if the boundary was reached or ``False`` otherwise. :rtype: bool """ return self._at_eof def decode(self, data): """Decodes data according the specified `Content-Encoding` or `Content-Transfer-Encoding` headers value. Supports ``gzip``, ``deflate`` and ``identity`` encodings for `Content-Encoding` header. Supports ``base64``, ``quoted-printable``, ``binary`` encodings for `Content-Transfer-Encoding` header. :param bytearray data: Data to decode. :raises: :exc:`RuntimeError` - if encoding is unknown. :rtype: bytes """ if CONTENT_TRANSFER_ENCODING in self.headers: data = self._decode_content_transfer(data) if CONTENT_ENCODING in self.headers: return self._decode_content(data) return data def _decode_content(self, data): encoding = self.headers[CONTENT_ENCODING].lower() if encoding == 'deflate': return zlib.decompress(data, -zlib.MAX_WBITS) elif encoding == 'gzip': return zlib.decompress(data, 16 + zlib.MAX_WBITS) elif encoding == 'identity': return data else: raise RuntimeError('unknown content encoding: {}'.format(encoding)) def _decode_content_transfer(self, data): encoding = self.headers[CONTENT_TRANSFER_ENCODING].lower() if encoding == 'base64': return base64.b64decode(data) elif encoding == 'quoted-printable': return binascii.a2b_qp(data) elif encoding == 'binary': return data else: raise RuntimeError('unknown content transfer encoding: {}' ''.format(encoding)) def get_charset(self, default=None): """Returns charset parameter from ``Content-Type`` header or default. """ ctype = self.headers.get(CONTENT_TYPE, '') *_, params = parse_mimetype(ctype) return params.get('charset', default) @property def filename(self): """Returns filename specified in Content-Disposition header or ``None`` if missed or header is malformed.""" _, params = parse_content_disposition( self.headers.get(CONTENT_DISPOSITION)) return content_disposition_filename(params) class MultipartReader(object): """Multipart body reader.""" #: Response wrapper, used when multipart readers constructs from response. response_wrapper_cls = MultipartResponseWrapper #: Multipart reader class, used to handle multipart/* body parts. #: None points to type(self) multipart_reader_cls = None #: Body part reader class for non multipart/* content types. part_reader_cls = BodyPartReader def __init__(self, headers, content): self.headers = headers self._boundary = ('--' + self._get_boundary()).encode() self._content = content self._last_part = None self._at_eof = False self._at_bof = True self._unread = [] if PY_35: def __aiter__(self): return self if not PY_352: # pragma: no cover __aiter__ = asyncio.coroutine(__aiter__) @asyncio.coroutine def __anext__(self): part = yield from self.next() if part is None: raise StopAsyncIteration # NOQA return part @classmethod def from_response(cls, response): """Constructs reader instance from HTTP response. :param response: :class:`~aiohttp.client.ClientResponse` instance """ obj = cls.response_wrapper_cls(response, cls(response.headers, response.content)) return obj def at_eof(self): """Returns ``True`` if the final boundary was reached or ``False`` otherwise. :rtype: bool """ return self._at_eof @asyncio.coroutine def next(self): """Emits the next multipart body part.""" # So, if we're at BOF, we need to skip till the boundary. if self._at_eof: return yield from self._maybe_release_last_part() if self._at_bof: yield from self._read_until_first_boundary() self._at_bof = False else: yield from self._read_boundary() if self._at_eof: # we just read the last boundary, nothing to do there return self._last_part = yield from self.fetch_next_part() return self._last_part @asyncio.coroutine def release(self): """Reads all the body parts to the void till the final boundary.""" while not self._at_eof: item = yield from self.next() if item is None: break yield from item.release() @asyncio.coroutine def fetch_next_part(self): """Returns the next body part reader.""" headers = yield from self._read_headers() return self._get_part_reader(headers) def _get_part_reader(self, headers): """Dispatches the response by the `Content-Type` header, returning suitable reader instance. :param dict headers: Response headers """ ctype = headers.get(CONTENT_TYPE, '') mtype, *_ = parse_mimetype(ctype) if mtype == 'multipart': if self.multipart_reader_cls is None: return type(self)(headers, self._content) return self.multipart_reader_cls(headers, self._content) else: return self.part_reader_cls(self._boundary, headers, self._content) def _get_boundary(self): mtype, *_, params = parse_mimetype(self.headers[CONTENT_TYPE]) assert mtype == 'multipart', 'multipart/* content type expected' if 'boundary' not in params: raise ValueError('boundary missed for Content-Type: %s' % self.headers[CONTENT_TYPE]) boundary = params['boundary'] if len(boundary) > 70: raise ValueError('boundary %r is too long (70 chars max)' % boundary) return boundary @asyncio.coroutine def _readline(self): if self._unread: return self._unread.pop() return (yield from self._content.readline()) @asyncio.coroutine def _read_until_first_boundary(self): while True: chunk = yield from self._readline() if chunk == b'': raise ValueError("Could not find starting boundary %r" % (self._boundary)) chunk = chunk.rstrip() if chunk == self._boundary: return elif chunk == self._boundary + b'--': self._at_eof = True return @asyncio.coroutine def _read_boundary(self): chunk = (yield from self._readline()).rstrip() if chunk == self._boundary: pass elif chunk == self._boundary + b'--': self._at_eof = True else: raise ValueError('Invalid boundary %r, expected %r' % (chunk, self._boundary)) @asyncio.coroutine def _read_headers(self): lines = [b''] while True: chunk = yield from self._content.readline() chunk = chunk.strip() lines.append(chunk) if not chunk: break parser = HttpParser() headers, *_ = parser.parse_headers(lines) return headers @asyncio.coroutine def _maybe_release_last_part(self): """Ensures that the last read body part is read completely.""" if self._last_part is not None: if not self._last_part.at_eof(): yield from self._last_part.release() self._unread.extend(self._last_part._unread) self._last_part = None class BodyPartWriter(object): """Multipart writer for single body part.""" def __init__(self, obj, headers=None, *, chunk_size=8192): if headers is None: headers = CIMultiDict() elif not isinstance(headers, CIMultiDict): headers = CIMultiDict(headers) self.obj = obj self.headers = headers self._chunk_size = chunk_size self._fill_headers_with_defaults() self._serialize_map = { bytes: self._serialize_bytes, str: self._serialize_str, io.IOBase: self._serialize_io, MultipartWriter: self._serialize_multipart, ('application', 'json'): self._serialize_json, ('application', 'x-www-form-urlencoded'): self._serialize_form } def _fill_headers_with_defaults(self): if CONTENT_TYPE not in self.headers: content_type = self._guess_content_type(self.obj) if content_type is not None: self.headers[CONTENT_TYPE] = content_type if CONTENT_LENGTH not in self.headers: content_length = self._guess_content_length(self.obj) if content_length is not None: self.headers[CONTENT_LENGTH] = str(content_length) if CONTENT_DISPOSITION not in self.headers: filename = self._guess_filename(self.obj) if filename is not None: self.set_content_disposition('attachment', filename=filename) def _guess_content_length(self, obj): if isinstance(obj, bytes): return len(obj) elif isinstance(obj, str): *_, params = parse_mimetype(self.headers.get(CONTENT_TYPE)) charset = params.get('charset', 'us-ascii') return len(obj.encode(charset)) elif isinstance(obj, io.StringIO): *_, params = parse_mimetype(self.headers.get(CONTENT_TYPE)) charset = params.get('charset', 'us-ascii') return len(obj.getvalue().encode(charset)) - obj.tell() elif isinstance(obj, io.BytesIO): return len(obj.getvalue()) - obj.tell() elif isinstance(obj, io.IOBase): try: return os.fstat(obj.fileno()).st_size - obj.tell() except (AttributeError, OSError): return None else: return None def _guess_content_type(self, obj, default='application/octet-stream'): if hasattr(obj, 'name'): name = getattr(obj, 'name') return mimetypes.guess_type(name)[0] elif isinstance(obj, (str, io.StringIO)): return 'text/plain; charset=utf-8' else: return default def _guess_filename(self, obj): if isinstance(obj, io.IOBase): name = getattr(obj, 'name', None) if name is not None: return Path(name).name def serialize(self): """Yields byte chunks for body part.""" has_encoding = ( CONTENT_ENCODING in self.headers and self.headers[CONTENT_ENCODING] != 'identity' or CONTENT_TRANSFER_ENCODING in self.headers ) if has_encoding: # since we're following streaming approach which doesn't assumes # any intermediate buffers, we cannot calculate real content length # with the specified content encoding scheme. So, instead of lying # about content length and cause reading issues, we have to strip # this information. self.headers.pop(CONTENT_LENGTH, None) if self.headers: yield b'\r\n'.join( b': '.join(map(lambda i: i.encode('latin1'), item)) for item in self.headers.items() ) yield b'\r\n\r\n' yield from self._maybe_encode_stream(self._serialize_obj()) yield b'\r\n' def _serialize_obj(self): obj = self.obj mtype, stype, *_ = parse_mimetype(self.headers.get(CONTENT_TYPE)) serializer = self._serialize_map.get((mtype, stype)) if serializer is not None: return serializer(obj) for key in self._serialize_map: if not isinstance(key, tuple) and isinstance(obj, key): return self._serialize_map[key](obj) return self._serialize_default(obj) def _serialize_bytes(self, obj): yield obj def _serialize_str(self, obj): *_, params = parse_mimetype(self.headers.get(CONTENT_TYPE)) yield obj.encode(params.get('charset', 'us-ascii')) def _serialize_io(self, obj): while True: chunk = obj.read(self._chunk_size) if not chunk: break if isinstance(chunk, str): yield from self._serialize_str(chunk) else: yield from self._serialize_bytes(chunk) def _serialize_multipart(self, obj): yield from obj.serialize() def _serialize_json(self, obj): *_, params = parse_mimetype(self.headers.get(CONTENT_TYPE)) yield json.dumps(obj).encode(params.get('charset', 'utf-8')) def _serialize_form(self, obj): if isinstance(obj, Mapping): obj = list(obj.items()) return self._serialize_str(urlencode(obj, doseq=True)) def _serialize_default(self, obj): raise TypeError('unknown body part type %r' % type(obj)) def _maybe_encode_stream(self, stream): if CONTENT_ENCODING in self.headers: stream = self._apply_content_encoding(stream) if CONTENT_TRANSFER_ENCODING in self.headers: stream = self._apply_content_transfer_encoding(stream) yield from stream def _apply_content_encoding(self, stream): encoding = self.headers[CONTENT_ENCODING].lower() if encoding == 'identity': yield from stream elif encoding in ('deflate', 'gzip'): if encoding == 'gzip': zlib_mode = 16 + zlib.MAX_WBITS else: zlib_mode = -zlib.MAX_WBITS zcomp = zlib.compressobj(wbits=zlib_mode) for chunk in stream: yield zcomp.compress(chunk) else: yield zcomp.flush() else: raise RuntimeError('unknown content encoding: {}' ''.format(encoding)) def _apply_content_transfer_encoding(self, stream): encoding = self.headers[CONTENT_TRANSFER_ENCODING].lower() if encoding == 'base64': buffer = bytearray() while True: if buffer: div, mod = divmod(len(buffer), 3) chunk, buffer = buffer[:div * 3], buffer[div * 3:] if chunk: yield base64.b64encode(chunk) chunk = next(stream, None) if not chunk: if buffer: yield base64.b64encode(buffer[:]) return buffer.extend(chunk) elif encoding == 'quoted-printable': for chunk in stream: yield binascii.b2a_qp(chunk) elif encoding == 'binary': yield from stream else: raise RuntimeError('unknown content transfer encoding: {}' ''.format(encoding)) def set_content_disposition(self, disptype, **params): """Sets ``Content-Disposition`` header. :param str disptype: Disposition type: inline, attachment, form-data. Should be valid extension token (see RFC 2183) :param dict params: Disposition params """ if not disptype or not (TOKEN > set(disptype)): raise ValueError('bad content disposition type {!r}' ''.format(disptype)) value = disptype if params: lparams = [] for key, val in params.items(): if not key or not (TOKEN > set(key)): raise ValueError('bad content disposition parameter' ' {!r}={!r}'.format(key, val)) qval = quote(val, '') lparams.append((key, '"%s"' % qval)) if key == 'filename': lparams.append(('filename*', "utf-8''" + qval)) sparams = '; '.join('='.join(pair) for pair in lparams) value = '; '.join((value, sparams)) self.headers[CONTENT_DISPOSITION] = value @property def filename(self): """Returns filename specified in Content-Disposition header or ``None`` if missed.""" _, params = parse_content_disposition( self.headers.get(CONTENT_DISPOSITION)) return content_disposition_filename(params) class MultipartWriter(object): """Multipart body writer.""" #: Body part reader class for non multipart/* content types. part_writer_cls = BodyPartWriter def __init__(self, subtype='mixed', boundary=None): boundary = boundary if boundary is not None else uuid.uuid4().hex try: boundary.encode('us-ascii') except UnicodeEncodeError: raise ValueError('boundary should contains ASCII only chars') self.headers = CIMultiDict() self.headers[CONTENT_TYPE] = 'multipart/{}; boundary="{}"'.format( subtype, boundary ) self.parts = [] def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): pass def __iter__(self): return iter(self.parts) def __len__(self): return len(self.parts) @property def boundary(self): *_, params = parse_mimetype(self.headers.get(CONTENT_TYPE)) return params['boundary'].encode('us-ascii') def append(self, obj, headers=None): """Adds a new body part to multipart writer.""" if isinstance(obj, self.part_writer_cls): if headers: obj.headers.update(headers) self.parts.append(obj) else: if not headers: headers = CIMultiDict() self.parts.append(self.part_writer_cls(obj, headers)) return self.parts[-1] def append_json(self, obj, headers=None): """Helper to append JSON part.""" if not headers: headers = CIMultiDict() headers[CONTENT_TYPE] = 'application/json' return self.append(obj, headers) def append_form(self, obj, headers=None): """Helper to append form urlencoded part.""" if not headers: headers = CIMultiDict() headers[CONTENT_TYPE] = 'application/x-www-form-urlencoded' assert isinstance(obj, (Sequence, Mapping)) return self.append(obj, headers) def serialize(self): """Yields multipart byte chunks.""" if not self.parts: yield b'' return for part in self.parts: yield b'--' + self.boundary + b'\r\n' yield from part.serialize() else: yield b'--' + self.boundary + b'--\r\n' yield b'' aiohttp-1.2.0/aiohttp/client.py0000664000175000017500000006216413025134363017337 0ustar travistravis00000000000000"""HTTP Client for asyncio.""" import asyncio import base64 import hashlib import os import sys import traceback import warnings from multidict import CIMultiDict, MultiDict, MultiDictProxy, istr from yarl import URL import aiohttp from . import hdrs, helpers from ._ws_impl import WS_KEY, WebSocketParser, WebSocketWriter from .client_reqrep import ClientRequest, ClientResponse from .client_ws import ClientWebSocketResponse from .cookiejar import CookieJar from .errors import WSServerHandshakeError from .helpers import Timeout __all__ = ('ClientSession', 'request', 'get', 'options', 'head', 'delete', 'post', 'put', 'patch', 'ws_connect') PY_35 = sys.version_info >= (3, 5) class ClientSession: """First-class interface for making HTTP requests.""" _source_traceback = None _connector = None def __init__(self, *, connector=None, loop=None, cookies=None, headers=None, skip_auto_headers=None, auth=None, request_class=ClientRequest, response_class=ClientResponse, ws_response_class=ClientWebSocketResponse, version=aiohttp.HttpVersion11, cookie_jar=None): if connector is None: connector = aiohttp.TCPConnector(loop=loop) loop = connector._loop # never None else: if loop is None: loop = connector._loop # never None elif connector._loop is not loop: raise ValueError("loop argument must agree with connector") self._loop = loop if loop.get_debug(): self._source_traceback = traceback.extract_stack(sys._getframe(1)) if not loop.is_running(): warnings.warn("Creating a client session outside of coroutine is " "a very dangerous idea", ResourceWarning, stacklevel=2) context = {'client_session': self, 'message': 'Creating a client session outside ' 'of coroutine'} if self._source_traceback is not None: context['source_traceback'] = self._source_traceback loop.call_exception_handler(context) if cookie_jar is None: cookie_jar = CookieJar(loop=loop) self._cookie_jar = cookie_jar if cookies is not None: self._cookie_jar.update_cookies(cookies) self._connector = connector self._default_auth = auth self._version = version # Convert to list of tuples if headers: headers = CIMultiDict(headers) else: headers = CIMultiDict() self._default_headers = headers if skip_auto_headers is not None: self._skip_auto_headers = frozenset([istr(i) for i in skip_auto_headers]) else: self._skip_auto_headers = frozenset() self._request_class = request_class self._response_class = response_class self._ws_response_class = ws_response_class def __del__(self, _warnings=warnings): if not self.closed: self.close() _warnings.warn("Unclosed client session {!r}".format(self), ResourceWarning) context = {'client_session': self, 'message': 'Unclosed client session'} if self._source_traceback is not None: context['source_traceback'] = self._source_traceback self._loop.call_exception_handler(context) def request(self, method, url, **kwargs): """Perform HTTP request.""" return _RequestContextManager(self._request(method, url, **kwargs)) @asyncio.coroutine def _request(self, method, url, *, params=None, data=None, headers=None, skip_auto_headers=None, auth=None, allow_redirects=True, max_redirects=10, encoding='utf-8', version=None, compress=None, chunked=None, expect100=False, read_until_eof=True, proxy=None, proxy_auth=None, timeout=5*60): if version is not None: warnings.warn("HTTP version should be specified " "by ClientSession constructor", DeprecationWarning) else: version = self._version if self.closed: raise RuntimeError('Session is closed') redirects = 0 history = [] # Merge with default headers and transform to CIMultiDict headers = self._prepare_headers(headers) if auth is None: auth = self._default_auth # It would be confusing if we support explicit Authorization header # with `auth` argument if (headers is not None and auth is not None and hdrs.AUTHORIZATION in headers): raise ValueError("Can't combine `Authorization` header with " "`auth` argument") skip_headers = set(self._skip_auto_headers) if skip_auto_headers is not None: for i in skip_auto_headers: skip_headers.add(istr(i)) if proxy is not None: proxy = URL(proxy) while True: url = URL(url).with_fragment(None) cookies = self._cookie_jar.filter_cookies(url) req = self._request_class( method, url, params=params, headers=headers, skip_auto_headers=skip_headers, data=data, cookies=cookies, encoding=encoding, auth=auth, version=version, compress=compress, chunked=chunked, expect100=expect100, loop=self._loop, response_class=self._response_class, proxy=proxy, proxy_auth=proxy_auth, timeout=timeout) with Timeout(timeout, loop=self._loop): conn = yield from self._connector.connect(req) conn.writer.set_tcp_nodelay(True) try: resp = req.send(conn.writer, conn.reader) try: yield from resp.start(conn, read_until_eof) except: resp.close() conn.close() raise except (aiohttp.HttpProcessingError, aiohttp.ServerDisconnectedError) as exc: raise aiohttp.ClientResponseError() from exc except OSError as exc: raise aiohttp.ClientOSError(*exc.args) from exc self._cookie_jar.update_cookies(resp.cookies, resp.url_obj) # redirects if resp.status in (301, 302, 303, 307) and allow_redirects: redirects += 1 history.append(resp) if max_redirects and redirects >= max_redirects: resp.close() break else: # TODO: close the connection if BODY is large enough # Redirect with big BODY is forbidden by HTTP protocol # but malformed server may send illegal response. # Small BODIES with text like "Not Found" are still # perfectly fine and should be accepted. yield from resp.release() # For 301 and 302, mimic IE behaviour, now changed in RFC. # Details: https://github.com/kennethreitz/requests/pull/269 if (resp.status == 303 and resp.method != hdrs.METH_HEAD) \ or (resp.status in (301, 302) and resp.method == hdrs.METH_POST): method = hdrs.METH_GET data = None if headers.get(hdrs.CONTENT_LENGTH): headers.pop(hdrs.CONTENT_LENGTH) r_url = (resp.headers.get(hdrs.LOCATION) or resp.headers.get(hdrs.URI)) if r_url is None: raise RuntimeError("{0.method} {0.url_obj} returns " "a redirect [{0.status}] status " "but response lacks a Location " "or URI HTTP header".format(resp)) r_url = URL(r_url) scheme = r_url.scheme if scheme not in ('http', 'https', ''): resp.close() raise ValueError('Can redirect only to http or https') elif not scheme: r_url = url.join(r_url) url = r_url params = None yield from resp.release() continue break resp._history = tuple(history) return resp def ws_connect(self, url, *, protocols=(), timeout=10.0, autoclose=True, autoping=True, auth=None, origin=None, headers=None, proxy=None, proxy_auth=None): """Initiate websocket connection.""" return _WSRequestContextManager( self._ws_connect(url, protocols=protocols, timeout=timeout, autoclose=autoclose, autoping=autoping, auth=auth, origin=origin, headers=headers, proxy=proxy, proxy_auth=proxy_auth)) @asyncio.coroutine def _ws_connect(self, url, *, protocols=(), timeout=10.0, autoclose=True, autoping=True, auth=None, origin=None, headers=None, proxy=None, proxy_auth=None): sec_key = base64.b64encode(os.urandom(16)) if headers is None: headers = CIMultiDict() default_headers = { hdrs.UPGRADE: hdrs.WEBSOCKET, hdrs.CONNECTION: hdrs.UPGRADE, hdrs.SEC_WEBSOCKET_VERSION: '13', hdrs.SEC_WEBSOCKET_KEY: sec_key.decode(), } for key, value in default_headers.items(): if key not in headers: headers[key] = value if protocols: headers[hdrs.SEC_WEBSOCKET_PROTOCOL] = ','.join(protocols) if origin is not None: headers[hdrs.ORIGIN] = origin # send request resp = yield from self.get(url, headers=headers, read_until_eof=False, auth=auth, proxy=proxy, proxy_auth=proxy_auth) try: # check handshake if resp.status != 101: raise WSServerHandshakeError( message='Invalid response status', code=resp.status, headers=resp.headers) if resp.headers.get(hdrs.UPGRADE, '').lower() != 'websocket': raise WSServerHandshakeError( message='Invalid upgrade header', code=resp.status, headers=resp.headers) if resp.headers.get(hdrs.CONNECTION, '').lower() != 'upgrade': raise WSServerHandshakeError( message='Invalid connection header', code=resp.status, headers=resp.headers) # key calculation key = resp.headers.get(hdrs.SEC_WEBSOCKET_ACCEPT, '') match = base64.b64encode( hashlib.sha1(sec_key + WS_KEY).digest()).decode() if key != match: raise WSServerHandshakeError( message='Invalid challenge response', code=resp.status, headers=resp.headers) # websocket protocol protocol = None if protocols and hdrs.SEC_WEBSOCKET_PROTOCOL in resp.headers: resp_protocols = [ proto.strip() for proto in resp.headers[hdrs.SEC_WEBSOCKET_PROTOCOL].split(',')] for proto in resp_protocols: if proto in protocols: protocol = proto break reader = resp.connection.reader.set_parser(WebSocketParser) resp.connection.writer.set_tcp_nodelay(True) writer = WebSocketWriter(resp.connection.writer, use_mask=True) except Exception: resp.close() raise else: return self._ws_response_class(reader, writer, protocol, resp, timeout, autoclose, autoping, self._loop) def _prepare_headers(self, headers): """ Add default headers and transform it to CIMultiDict """ # Convert headers to MultiDict result = CIMultiDict(self._default_headers) if headers: if not isinstance(headers, (MultiDictProxy, MultiDict)): headers = CIMultiDict(headers) added_names = set() for key, value in headers.items(): if key in added_names: result.add(key, value) else: result[key] = value added_names.add(key) return result def get(self, url, *, allow_redirects=True, **kwargs): """Perform HTTP GET request.""" return _RequestContextManager( self._request(hdrs.METH_GET, url, allow_redirects=allow_redirects, **kwargs)) def options(self, url, *, allow_redirects=True, **kwargs): """Perform HTTP OPTIONS request.""" return _RequestContextManager( self._request(hdrs.METH_OPTIONS, url, allow_redirects=allow_redirects, **kwargs)) def head(self, url, *, allow_redirects=False, **kwargs): """Perform HTTP HEAD request.""" return _RequestContextManager( self._request(hdrs.METH_HEAD, url, allow_redirects=allow_redirects, **kwargs)) def post(self, url, *, data=None, **kwargs): """Perform HTTP POST request.""" return _RequestContextManager( self._request(hdrs.METH_POST, url, data=data, **kwargs)) def put(self, url, *, data=None, **kwargs): """Perform HTTP PUT request.""" return _RequestContextManager( self._request(hdrs.METH_PUT, url, data=data, **kwargs)) def patch(self, url, *, data=None, **kwargs): """Perform HTTP PATCH request.""" return _RequestContextManager( self._request(hdrs.METH_PATCH, url, data=data, **kwargs)) def delete(self, url, **kwargs): """Perform HTTP DELETE request.""" return _RequestContextManager( self._request(hdrs.METH_DELETE, url, **kwargs)) def close(self): """Close underlying connector. Release all acquired resources. """ if not self.closed: self._connector.close() self._connector = None ret = helpers.create_future(self._loop) ret.set_result(None) return ret @property def closed(self): """Is client session closed. A readonly property. """ return self._connector is None or self._connector.closed @property def connector(self): """Connector instance used for the session.""" return self._connector @property def cookie_jar(self): """The session cookies.""" return self._cookie_jar @property def version(self): """The session HTTP protocol version.""" return self._version @property def loop(self): """Session's loop.""" return self._loop def detach(self): """Detach connector from session without closing the former. Session is switched to closed state anyway. """ self._connector = None def __enter__(self): warnings.warn("Use async with instead", DeprecationWarning) return self def __exit__(self, exc_type, exc_val, exc_tb): self.close() if PY_35: @asyncio.coroutine def __aenter__(self): return self @asyncio.coroutine def __aexit__(self, exc_type, exc_val, exc_tb): yield from self.close() if PY_35: from collections.abc import Coroutine base = Coroutine else: base = object class _BaseRequestContextManager(base): __slots__ = ('_coro', '_resp', 'send', 'throw', 'close') def __init__(self, coro): self._coro = coro self._resp = None self.send = coro.send self.throw = coro.throw self.close = coro.close @property def gi_frame(self): return self._coro.gi_frame @property def gi_running(self): return self._coro.gi_running @property def gi_code(self): return self._coro.gi_code def __next__(self): return self.send(None) @asyncio.coroutine def __iter__(self): resp = yield from self._coro return resp if PY_35: def __await__(self): resp = yield from self._coro return resp @asyncio.coroutine def __aenter__(self): self._resp = yield from self._coro return self._resp if not PY_35: try: from asyncio import coroutines coroutines._COROUTINE_TYPES += (_BaseRequestContextManager,) except: # pragma: no cover pass # Python 3.4.2 and 3.4.3 has no coroutines._COROUTINE_TYPES class _RequestContextManager(_BaseRequestContextManager): if PY_35: @asyncio.coroutine def __aexit__(self, exc_type, exc, tb): if exc_type is not None: self._resp.close() else: yield from self._resp.release() class _WSRequestContextManager(_BaseRequestContextManager): if PY_35: @asyncio.coroutine def __aexit__(self, exc_type, exc, tb): yield from self._resp.close() class _DetachedRequestContextManager(_RequestContextManager): __slots__ = _RequestContextManager.__slots__ + ('_session', ) def __init__(self, coro, session): super().__init__(coro) self._session = session @asyncio.coroutine def __iter__(self): try: return (yield from self._coro) except: yield from self._session.close() raise if PY_35: def __await__(self): try: return (yield from self._coro) except: yield from self._session.close() raise def __del__(self): self._session.detach() class _DetachedWSRequestContextManager(_WSRequestContextManager): __slots__ = _WSRequestContextManager.__slots__ + ('_session', ) def __init__(self, coro, session): super().__init__(coro) self._session = session def __del__(self): self._session.detach() def request(method, url, *, params=None, data=None, headers=None, skip_auto_headers=None, cookies=None, auth=None, allow_redirects=True, max_redirects=10, encoding='utf-8', version=None, compress=None, chunked=None, expect100=False, connector=None, loop=None, read_until_eof=True, request_class=None, response_class=None, proxy=None, proxy_auth=None): """Constructs and sends a request. Returns response object. method - HTTP method url - request url params - (optional) Dictionary or bytes to be sent in the query string of the new request data - (optional) Dictionary, bytes, or file-like object to send in the body of the request headers - (optional) Dictionary of HTTP Headers to send with the request cookies - (optional) Dict object to send with the request auth - (optional) BasicAuth named tuple represent HTTP Basic Auth auth - aiohttp.helpers.BasicAuth allow_redirects - (optional) If set to False, do not follow redirects version - Request HTTP version. compress - Set to True if request has to be compressed with deflate encoding. chunked - Set to chunk size for chunked transfer encoding. expect100 - Expect 100-continue response from server. connector - BaseConnector sub-class instance to support connection pooling. read_until_eof - Read response until eof if response does not have Content-Length header. request_class - (optional) Custom Request class implementation. response_class - (optional) Custom Response class implementation. loop - Optional event loop. Usage:: >>> import aiohttp >>> resp = yield from aiohttp.request('GET', 'http://python.org/') >>> resp >>> data = yield from resp.read() """ warnings.warn("Use ClientSession().request() instead", DeprecationWarning) if connector is None: connector = aiohttp.TCPConnector(loop=loop, force_close=True) kwargs = {} if request_class is not None: kwargs['request_class'] = request_class if response_class is not None: kwargs['response_class'] = response_class session = ClientSession(loop=loop, cookies=cookies, connector=connector, **kwargs) return _DetachedRequestContextManager( session._request(method, url, params=params, data=data, headers=headers, skip_auto_headers=skip_auto_headers, auth=auth, allow_redirects=allow_redirects, max_redirects=max_redirects, encoding=encoding, version=version, compress=compress, chunked=chunked, expect100=expect100, read_until_eof=read_until_eof, proxy=proxy, proxy_auth=proxy_auth,), session=session) def get(url, **kwargs): warnings.warn("Use ClientSession().get() instead", DeprecationWarning) return request(hdrs.METH_GET, url, **kwargs) def options(url, **kwargs): warnings.warn("Use ClientSession().options() instead", DeprecationWarning) return request(hdrs.METH_OPTIONS, url, **kwargs) def head(url, **kwargs): warnings.warn("Use ClientSession().head() instead", DeprecationWarning) return request(hdrs.METH_HEAD, url, **kwargs) def post(url, **kwargs): warnings.warn("Use ClientSession().post() instead", DeprecationWarning) return request(hdrs.METH_POST, url, **kwargs) def put(url, **kwargs): warnings.warn("Use ClientSession().put() instead", DeprecationWarning) return request(hdrs.METH_PUT, url, **kwargs) def patch(url, **kwargs): warnings.warn("Use ClientSession().patch() instead", DeprecationWarning) return request(hdrs.METH_PATCH, url, **kwargs) def delete(url, **kwargs): warnings.warn("Use ClientSession().delete() instead", DeprecationWarning) return request(hdrs.METH_DELETE, url, **kwargs) def ws_connect(url, *, protocols=(), timeout=10.0, connector=None, auth=None, ws_response_class=ClientWebSocketResponse, autoclose=True, autoping=True, loop=None, origin=None, headers=None): warnings.warn("Use ClientSession().ws_connect() instead", DeprecationWarning) if loop is None: loop = asyncio.get_event_loop() if connector is None: connector = aiohttp.TCPConnector(loop=loop, force_close=True) session = aiohttp.ClientSession(loop=loop, connector=connector, auth=auth, ws_response_class=ws_response_class, headers=headers) return _DetachedWSRequestContextManager( session._ws_connect(url, protocols=protocols, timeout=timeout, autoclose=autoclose, autoping=autoping, origin=origin), session=session) aiohttp-1.2.0/aiohttp/__init__.py0000664000175000017500000000255013025134363017611 0ustar travistravis00000000000000__version__ = '1.2.0' # Deprecated, keep it here for a while for backward compatibility. import multidict # noqa # This relies on each of the submodules having an __all__ variable. from multidict import * # noqa from . import hdrs # noqa from .protocol import * # noqa from .connector import * # noqa from .client import * # noqa from .client_reqrep import * # noqa from .errors import * # noqa from .helpers import * # noqa from .parsers import * # noqa from .streams import * # noqa from .multipart import * # noqa from .client_ws import ClientWebSocketResponse # noqa from ._ws_impl import WSMsgType, WSCloseCode, WSMessage, WebSocketError # noqa from .file_sender import FileSender # noqa from .cookiejar import CookieJar # noqa from .resolver import * # noqa MsgType = WSMsgType # backward compatibility __all__ = (client.__all__ + # noqa client_reqrep.__all__ + # noqa errors.__all__ + # noqa helpers.__all__ + # noqa parsers.__all__ + # noqa protocol.__all__ + # noqa connector.__all__ + # noqa streams.__all__ + # noqa multidict.__all__ + # noqa multipart.__all__ + # noqa ('hdrs', 'FileSender', 'WSMsgType', 'MsgType', 'WSCloseCode', 'WebSocketError', 'WSMessage', 'ClientWebSocketResponse', 'CookieJar')) aiohttp-1.2.0/aiohttp/log.py0000664000175000017500000000050513025134363016631 0ustar travistravis00000000000000import logging access_logger = logging.getLogger('aiohttp.access') client_logger = logging.getLogger('aiohttp.client') internal_logger = logging.getLogger('aiohttp.internal') server_logger = logging.getLogger('aiohttp.server') web_logger = logging.getLogger('aiohttp.web') ws_logger = logging.getLogger('aiohttp.websocket') aiohttp-1.2.0/aiohttp/signals.py0000664000175000017500000000345413025134363017516 0ustar travistravis00000000000000import asyncio from itertools import count from aiohttp.helpers import FrozenList class BaseSignal(FrozenList): __slots__ = () @asyncio.coroutine def _send(self, *args, **kwargs): for receiver in self: res = receiver(*args, **kwargs) if asyncio.iscoroutine(res) or isinstance(res, asyncio.Future): yield from res class Signal(BaseSignal): """Coroutine-based signal implementation. To connect a callback to a signal, use any list method. Signals are fired using the :meth:`send` coroutine, which takes named arguments. """ __slots__ = ('_app', '_name', '_pre', '_post') def __init__(self, app): super().__init__() self._app = app klass = self.__class__ self._name = klass.__module__ + ':' + klass.__qualname__ self._pre = app.on_pre_signal self._post = app.on_post_signal @asyncio.coroutine def send(self, *args, **kwargs): """ Sends data to all registered receivers. """ ordinal = None debug = self._app._debug if debug: ordinal = self._pre.ordinal() yield from self._pre.send(ordinal, self._name, *args, **kwargs) yield from self._send(*args, **kwargs) if debug: yield from self._post.send(ordinal, self._name, *args, **kwargs) class DebugSignal(BaseSignal): __slots__ = () @asyncio.coroutine def send(self, ordinal, name, *args, **kwargs): yield from self._send(ordinal, name, *args, **kwargs) class PreSignal(DebugSignal): __slots__ = ('_counter',) def __init__(self): super().__init__() self._counter = count(1) def ordinal(self): return next(self._counter) class PostSignal(DebugSignal): __slots__ = () aiohttp-1.2.0/aiohttp/cookiejar.py0000664000175000017500000002301213025134363020014 0ustar travistravis00000000000000import datetime import pathlib import pickle import re from collections import defaultdict from collections.abc import Mapping from http.cookies import Morsel, SimpleCookie from math import ceil from yarl import URL from .abc import AbstractCookieJar from .helpers import is_ip_address class CookieJar(AbstractCookieJar): """Implements cookie storage adhering to RFC 6265.""" DATE_TOKENS_RE = re.compile( "[\x09\x20-\x2F\x3B-\x40\x5B-\x60\x7B-\x7E]*" "(?P[\x00-\x08\x0A-\x1F\d:a-zA-Z\x7F-\xFF]+)") DATE_HMS_TIME_RE = re.compile("(\d{1,2}):(\d{1,2}):(\d{1,2})") DATE_DAY_OF_MONTH_RE = re.compile("(\d{1,2})") DATE_MONTH_RE = re.compile("(jan)|(feb)|(mar)|(apr)|(may)|(jun)|(jul)|" "(aug)|(sep)|(oct)|(nov)|(dec)", re.I) DATE_YEAR_RE = re.compile("(\d{2,4})") MAX_TIME = 2051215261.0 # so far in future (2035-01-01) def __init__(self, *, unsafe=False, loop=None): super().__init__(loop=loop) self._cookies = defaultdict(SimpleCookie) self._host_only_cookies = set() self._unsafe = unsafe self._next_expiration = ceil(self._loop.time()) self._expirations = {} def save(self, file_path): file_path = pathlib.Path(file_path) with file_path.open(mode='wb') as f: pickle.dump(self._cookies, f, pickle.HIGHEST_PROTOCOL) def load(self, file_path): file_path = pathlib.Path(file_path) with file_path.open(mode='rb') as f: self._cookies = pickle.load(f) def clear(self): self._cookies.clear() self._host_only_cookies.clear() self._next_expiration = ceil(self._loop.time()) self._expirations.clear() def __iter__(self): self._do_expiration() for val in self._cookies.values(): yield from val.values() def __len__(self): return sum(1 for i in self) def _do_expiration(self): now = self._loop.time() if self._next_expiration > now: return if not self._expirations: return next_expiration = self.MAX_TIME to_del = [] cookies = self._cookies expirations = self._expirations for (domain, name), when in expirations.items(): if when < now: cookies[domain].pop(name, None) to_del.append((domain, name)) self._host_only_cookies.discard((domain, name)) else: next_expiration = min(next_expiration, when) for key in to_del: del expirations[key] self._next_expiration = ceil(next_expiration) def _expire_cookie(self, when, domain, name): self._next_expiration = min(self._next_expiration, when) self._expirations[(domain, name)] = when def update_cookies(self, cookies, response_url=URL()): """Update cookies.""" hostname = response_url.raw_host if not self._unsafe and is_ip_address(hostname): # Don't accept cookies from IPs return if isinstance(cookies, Mapping): cookies = cookies.items() for name, cookie in cookies: if not isinstance(cookie, Morsel): tmp = SimpleCookie() tmp[name] = cookie cookie = tmp[name] domain = cookie["domain"] # ignore domains with trailing dots if domain.endswith('.'): domain = "" del cookie["domain"] if not domain and hostname is not None: # Set the cookie's domain to the response hostname # and set its host-only-flag self._host_only_cookies.add((hostname, name)) domain = cookie["domain"] = hostname if domain.startswith("."): # Remove leading dot domain = domain[1:] cookie["domain"] = domain if hostname and not self._is_domain_match(domain, hostname): # Setting cookies for different domains is not allowed continue path = cookie["path"] if not path or not path.startswith("/"): # Set the cookie's path to the response path path = response_url.path if not path.startswith("/"): path = "/" else: # Cut everything from the last slash to the end path = "/" + path[1:path.rfind("/")] cookie["path"] = path max_age = cookie["max-age"] if max_age: try: delta_seconds = int(max_age) self._expire_cookie(self._loop.time() + delta_seconds, domain, name) except ValueError: cookie["max-age"] = "" else: expires = cookie["expires"] if expires: expire_time = self._parse_date(expires) if expire_time: self._expire_cookie(expire_time.timestamp(), domain, name) else: cookie["expires"] = "" # use dict method because SimpleCookie class modifies value # before Python 3.4.3 dict.__setitem__(self._cookies[domain], name, cookie) self._do_expiration() def filter_cookies(self, request_url=URL()): """Returns this jar's cookies filtered by their attributes.""" self._do_expiration() filtered = SimpleCookie() hostname = request_url.raw_host or "" is_not_secure = request_url.scheme not in ("https", "wss") for cookie in self: name = cookie.key domain = cookie["domain"] # Send shared cookies if not domain: filtered[name] = cookie.value continue if not self._unsafe and is_ip_address(hostname): continue if (domain, name) in self._host_only_cookies: if domain != hostname: continue elif not self._is_domain_match(domain, hostname): continue if not self._is_path_match(request_url.path, cookie["path"]): continue if is_not_secure and cookie["secure"]: continue # It's critical we use the Morsel so the coded_value # (based on cookie version) is preserved mrsl_val = cookie.get(cookie.key, Morsel()) mrsl_val.set(cookie.key, cookie.value, cookie.coded_value) filtered[name] = mrsl_val return filtered @staticmethod def _is_domain_match(domain, hostname): """Implements domain matching adhering to RFC 6265.""" if hostname == domain: return True if not hostname.endswith(domain): return False non_matching = hostname[:-len(domain)] if not non_matching.endswith("."): return False return not is_ip_address(hostname) @staticmethod def _is_path_match(req_path, cookie_path): """Implements path matching adhering to RFC 6265.""" if not req_path.startswith("/"): req_path = "/" if req_path == cookie_path: return True if not req_path.startswith(cookie_path): return False if cookie_path.endswith("/"): return True non_matching = req_path[len(cookie_path):] return non_matching.startswith("/") @classmethod def _parse_date(cls, date_str): """Implements date string parsing adhering to RFC 6265.""" if not date_str: return found_time = False found_day = False found_month = False found_year = False hour = minute = second = 0 day = 0 month = 0 year = 0 for token_match in cls.DATE_TOKENS_RE.finditer(date_str): token = token_match.group("token") if not found_time: time_match = cls.DATE_HMS_TIME_RE.match(token) if time_match: found_time = True hour, minute, second = [ int(s) for s in time_match.groups()] continue if not found_day: day_match = cls.DATE_DAY_OF_MONTH_RE.match(token) if day_match: found_day = True day = int(day_match.group()) continue if not found_month: month_match = cls.DATE_MONTH_RE.match(token) if month_match: found_month = True month = month_match.lastindex continue if not found_year: year_match = cls.DATE_YEAR_RE.match(token) if year_match: found_year = True year = int(year_match.group()) if 70 <= year <= 99: year += 1900 elif 0 <= year <= 69: year += 2000 if False in (found_day, found_month, found_year, found_time): return if not 1 <= day <= 31: return if year < 1601 or hour > 23 or minute > 59 or second > 59: return return datetime.datetime(year, month, day, hour, minute, second, tzinfo=datetime.timezone.utc) aiohttp-1.2.0/aiohttp/web_server.py0000664000175000017500000001205613025134363020217 0ustar travistravis00000000000000"""Low level HTTP server.""" import asyncio import traceback from html import escape as html_escape from .helpers import TimeService from .server import ServerHttpProtocol from .web_exceptions import HTTPException, HTTPInternalServerError from .web_reqrep import BaseRequest __all__ = ('RequestHandler', 'Server') class RequestHandler(ServerHttpProtocol): _request = None def __init__(self, manager, **kwargs): super().__init__(**kwargs) self._manager = manager self._request_factory = manager.request_factory self._handler = manager.handler self.time_service = manager.time_service def __repr__(self): if self._request is None: meth = 'none' path = 'none' else: meth = self._request.method path = self._request.rel_url.raw_path return "<{} {}:{} {}>".format( self.__class__.__name__, meth, path, 'connected' if self.transport is not None else 'disconnected') def connection_made(self, transport): super().connection_made(transport) self._manager.connection_made(self, transport) def connection_lost(self, exc): self._manager.connection_lost(self, exc) super().connection_lost(exc) self._request_factory = None self._manager = None self.time_service = None self._handler = None @asyncio.coroutine def handle_request(self, message, payload): self._manager._requests_count += 1 if self.access_log: now = self._loop.time() request = self._request_factory(message, payload, self) self._request = request try: try: resp = yield from self._handler(request) except HTTPException as exc: resp = exc except Exception as exc: msg = "

500 Internal Server Error

" if self.debug: try: tb = traceback.format_exc() tb = html_escape(tb) msg += '

Traceback:

\n
'
                        msg += tb
                        msg += '
' except: # pragma: no cover pass else: msg += "Server got itself in trouble" msg = ("500 Internal Server Error" "" + msg + "") resp = HTTPInternalServerError(text=msg, content_type='text/html') self.logger.exception( "Error handling request", exc_info=exc) yield from resp.prepare(request) yield from resp.write_eof() finally: resp._task = None # notify server about keep-alive # assign to parent class attr self._keepalive = resp._keep_alive # Restore default state. # Should be no-op if server code didn't touch these attributes. self.writer.set_tcp_cork(False) self.writer.set_tcp_nodelay(True) # log access if self.access_log: self.log_access(message, None, resp, self._loop.time() - now) # for repr self._request = None class Server: def __init__(self, handler, *, request_factory=None, loop=None, **kwargs): if loop is None: loop = asyncio.get_event_loop() self._handler = handler self._request_factory = request_factory or self._make_request self._loop = loop self._connections = {} self._kwargs = kwargs self._requests_count = 0 self._time_service = TimeService(self._loop) @property def requests_count(self): """Number of processed requests.""" return self._requests_count @property def handler(self): return self._handler @property def request_factory(self): return self._request_factory @property def time_service(self): return self._time_service @property def connections(self): return list(self._connections.keys()) def connection_made(self, handler, transport): self._connections[handler] = transport def connection_lost(self, handler, exc=None): if handler in self._connections: del self._connections[handler] def _make_request(self, message, payload, protocol): return BaseRequest( message, payload, protocol.transport, protocol.reader, protocol.writer, protocol.time_service, protocol._request_handler) @asyncio.coroutine def shutdown(self, timeout=None): coros = [conn.shutdown(timeout) for conn in self._connections] yield from asyncio.gather(*coros, loop=self._loop) self._connections.clear() self._time_service.stop() finish_connections = shutdown def __call__(self): return RequestHandler( self, loop=self._loop, **self._kwargs) aiohttp-1.2.0/aiohttp/worker.py0000664000175000017500000002033413025134363017363 0ustar travistravis00000000000000"""Async gunicorn worker for aiohttp.web""" import asyncio import logging import os import re import signal import socket import ssl import sys import gunicorn.workers.base as base from gunicorn.config import AccessLogFormat as GunicornAccessLogFormat from aiohttp.helpers import AccessLogger, ensure_future from aiohttp.web_server import Server from aiohttp.wsgi import WSGIServerHttpProtocol __all__ = ('GunicornWebWorker', 'GunicornUVLoopWebWorker') class GunicornWebWorker(base.Worker): DEFAULT_AIOHTTP_LOG_FORMAT = AccessLogger.LOG_FORMAT DEFAULT_GUNICORN_LOG_FORMAT = GunicornAccessLogFormat.default def __init__(self, *args, **kw): # pragma: no cover super().__init__(*args, **kw) self.servers = {} self.exit_code = 0 self._notify_waiter = None def init_process(self): # create new event_loop after fork asyncio.get_event_loop().close() self.loop = asyncio.new_event_loop() asyncio.set_event_loop(self.loop) super().init_process() def run(self): if hasattr(self.wsgi, 'startup'): self.loop.run_until_complete(self.wsgi.startup()) self._runner = ensure_future(self._run(), loop=self.loop) try: self.loop.run_until_complete(self._runner) finally: self.loop.close() sys.exit(self.exit_code) def make_handler(self, app): if hasattr(self.wsgi, 'make_handler'): return app.make_handler( logger=self.log, slow_request_timeout=self.cfg.timeout, keepalive_timeout=self.cfg.keepalive, access_log=self.log.access_log, access_log_format=self._get_valid_log_format( self.cfg.access_log_format)) else: return WSGIServer(self.wsgi, self) @asyncio.coroutine def close(self): if self.servers: servers = self.servers self.servers = None # stop accepting connections for server, handler in servers.items(): self.log.info("Stopping server: %s, connections: %s", self.pid, len(handler.connections)) server.close() yield from server.wait_closed() # send on_shutdown event if hasattr(self.wsgi, 'shutdown'): yield from self.wsgi.shutdown() # stop alive connections tasks = [ handler.shutdown( timeout=self.cfg.graceful_timeout / 100 * 95) for handler in servers.values()] yield from asyncio.gather(*tasks, loop=self.loop) # cleanup application if hasattr(self.wsgi, 'cleanup'): yield from self.wsgi.cleanup() @asyncio.coroutine def _run(self): ctx = self._create_ssl_context(self.cfg) if self.cfg.is_ssl else None for sock in self.sockets: handler = self.make_handler(self.wsgi) if hasattr(socket, 'AF_UNIX') and sock.family == socket.AF_UNIX: srv = yield from self.loop.create_unix_server( handler, sock=sock.sock, ssl=ctx) else: srv = yield from self.loop.create_server( handler, sock=sock.sock, ssl=ctx) self.servers[srv] = handler # If our parent changed then we shut down. pid = os.getpid() try: while self.alive: self.notify() cnt = sum(handler.requests_count for handler in self.servers.values()) if self.cfg.max_requests and cnt > self.cfg.max_requests: self.alive = False self.log.info("Max requests, shutting down: %s", self) elif pid == os.getpid() and self.ppid != os.getppid(): self.alive = False self.log.info("Parent changed, shutting down: %s", self) else: yield from self._wait_next_notify() except BaseException: pass yield from self.close() def _wait_next_notify(self): self._notify_waiter_done() self._notify_waiter = waiter = asyncio.Future(loop=self.loop) self.loop.call_later(1.0, self._notify_waiter_done) return waiter def _notify_waiter_done(self): waiter = self._notify_waiter if waiter is not None and not waiter.done(): waiter.set_result(True) self._notify_waiter = None def init_signals(self): # Set up signals through the event loop API. self.loop.add_signal_handler(signal.SIGQUIT, self.handle_quit, signal.SIGQUIT, None) self.loop.add_signal_handler(signal.SIGTERM, self.handle_exit, signal.SIGTERM, None) self.loop.add_signal_handler(signal.SIGINT, self.handle_quit, signal.SIGINT, None) self.loop.add_signal_handler(signal.SIGWINCH, self.handle_winch, signal.SIGWINCH, None) self.loop.add_signal_handler(signal.SIGUSR1, self.handle_usr1, signal.SIGUSR1, None) self.loop.add_signal_handler(signal.SIGABRT, self.handle_abort, signal.SIGABRT, None) # Don't let SIGTERM and SIGUSR1 disturb active requests # by interrupting system calls signal.siginterrupt(signal.SIGTERM, False) signal.siginterrupt(signal.SIGUSR1, False) def handle_quit(self, sig, frame): self.alive = False # worker_int callback self.cfg.worker_int(self) # init closing process self._closing = ensure_future(self.close(), loop=self.loop) # close loop self.loop.call_later(0.1, self._notify_waiter_done) def handle_abort(self, sig, frame): self.alive = False self.exit_code = 1 self.cfg.worker_abort(self) sys.exit(1) @staticmethod def _create_ssl_context(cfg): """ Creates SSLContext instance for usage in asyncio.create_server. See ssl.SSLSocket.__init__ for more details. """ ctx = ssl.SSLContext(cfg.ssl_version) ctx.load_cert_chain(cfg.certfile, cfg.keyfile) ctx.verify_mode = cfg.cert_reqs if cfg.ca_certs: ctx.load_verify_locations(cfg.ca_certs) if cfg.ciphers: ctx.set_ciphers(cfg.ciphers) return ctx def _get_valid_log_format(self, source_format): if source_format == self.DEFAULT_GUNICORN_LOG_FORMAT: return self.DEFAULT_AIOHTTP_LOG_FORMAT elif re.search(r'%\([^\)]+\)', source_format): raise ValueError( "Gunicorn's style options in form of `%(name)s` are not " "supported for the log formatting. Please use aiohttp's " "format specification to configure access log formatting: " "http://aiohttp.readthedocs.io/en/stable/logging.html" "#format-specification" ) else: return source_format class WSGIServer(Server): def __init__(self, app, worker): super().__init__(app, loop=worker.loop) self.worker = worker self.access_log_format = worker._get_valid_log_format( worker.cfg.access_log_format) def __call__(self): return WSGIServerHttpProtocol( self.handler, readpayload=True, loop=self._loop, logger=self.worker.log, debug=self.worker.log.loglevel == logging.DEBUG, keep_alive=self.worker.cfg.keepalive, access_log=self.worker.log.access_log, access_log_format=self.access_log_format) class GunicornUVLoopWebWorker(GunicornWebWorker): def init_process(self): import uvloop # Close any existing event loop before setting a # new policy. asyncio.get_event_loop().close() # Setup uvloop policy, so that every # asyncio.get_event_loop() will create an instance # of uvloop event loop. asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) super().init_process() aiohttp-1.2.0/aiohttp/_ws_impl.py0000664000175000017500000003477413025134363017700 0ustar travistravis00000000000000"""WebSocket protocol versions 13 and 8.""" import base64 import binascii import collections import hashlib import json import os import random import sys from enum import IntEnum from struct import Struct from aiohttp import errors, hdrs from aiohttp.log import ws_logger __all__ = ('WebSocketParser', 'WebSocketWriter', 'do_handshake', 'WSMessage', 'WebSocketError', 'WSMsgType', 'WSCloseCode') class WSCloseCode(IntEnum): OK = 1000 GOING_AWAY = 1001 PROTOCOL_ERROR = 1002 UNSUPPORTED_DATA = 1003 INVALID_TEXT = 1007 POLICY_VIOLATION = 1008 MESSAGE_TOO_BIG = 1009 MANDATORY_EXTENSION = 1010 INTERNAL_ERROR = 1011 SERVICE_RESTART = 1012 TRY_AGAIN_LATER = 1013 ALLOWED_CLOSE_CODES = {int(i) for i in WSCloseCode} class WSMsgType(IntEnum): CONTINUATION = 0x0 TEXT = 0x1 BINARY = 0x2 PING = 0x9 PONG = 0xa CLOSE = 0x8 CLOSED = 0x101 ERROR = 0x102 text = TEXT binary = BINARY ping = PING pong = PONG close = CLOSE closed = CLOSED error = ERROR WS_KEY = b'258EAFA5-E914-47DA-95CA-C5AB0DC85B11' UNPACK_LEN2 = Struct('!H').unpack_from UNPACK_LEN3 = Struct('!Q').unpack_from UNPACK_CLOSE_CODE = Struct('!H').unpack PACK_LEN1 = Struct('!BB').pack PACK_LEN2 = Struct('!BBH').pack PACK_LEN3 = Struct('!BBQ').pack PACK_CLOSE_CODE = Struct('!H').pack MSG_SIZE = 2 ** 14 _WSMessageBase = collections.namedtuple('_WSMessageBase', ['type', 'data', 'extra']) class WSMessage(_WSMessageBase): def json(self, *, loads=json.loads): """Return parsed JSON data. .. versionadded:: 0.22 """ return loads(self.data) @property def tp(self): return self.type CLOSED_MESSAGE = WSMessage(WSMsgType.CLOSED, None, None) class WebSocketError(Exception): """WebSocket protocol parser error.""" def __init__(self, code, message): self.code = code super().__init__(message) def WebSocketParser(out, buf): while True: fin, opcode, payload = yield from parse_frame(buf) if opcode == WSMsgType.CLOSE: if len(payload) >= 2: close_code = UNPACK_CLOSE_CODE(payload[:2])[0] if close_code < 3000 and close_code not in ALLOWED_CLOSE_CODES: raise WebSocketError( WSCloseCode.PROTOCOL_ERROR, 'Invalid close code: {}'.format(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 = WSMessage(WSMsgType.CLOSE, close_code, close_message) elif payload: raise WebSocketError( WSCloseCode.PROTOCOL_ERROR, 'Invalid close frame: {} {} {!r}'.format( fin, opcode, payload)) else: msg = WSMessage(WSMsgType.CLOSE, 0, '') out.feed_data(msg, 0) elif opcode == WSMsgType.PING: out.feed_data(WSMessage(WSMsgType.PING, payload, ''), len(payload)) elif opcode == WSMsgType.PONG: out.feed_data(WSMessage(WSMsgType.PONG, payload, ''), len(payload)) elif opcode not in (WSMsgType.TEXT, WSMsgType.BINARY): raise WebSocketError( WSCloseCode.PROTOCOL_ERROR, "Unexpected opcode={!r}".format(opcode)) else: # load text/binary data = [payload] while not fin: fin, _opcode, payload = yield from parse_frame(buf, True) # We can receive ping/close in the middle of # text message, Case 5.* if _opcode == WSMsgType.PING: out.feed_data( WSMessage(WSMsgType.PING, payload, ''), len(payload)) fin, _opcode, payload = yield from parse_frame(buf, True) elif _opcode == WSMsgType.CLOSE: if len(payload) >= 2: close_code = UNPACK_CLOSE_CODE(payload[:2])[0] if (close_code not in ALLOWED_CLOSE_CODES and close_code < 3000): raise WebSocketError( WSCloseCode.PROTOCOL_ERROR, 'Invalid close code: {}'.format(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 = WSMessage(WSMsgType.CLOSE, close_code, close_message) elif payload: raise WebSocketError( WSCloseCode.PROTOCOL_ERROR, 'Invalid close frame: {} {} {!r}'.format( fin, opcode, payload)) else: msg = WSMessage(WSMsgType.CLOSE, 0, '') out.feed_data(msg, 0) fin, _opcode, payload = yield from parse_frame(buf, True) if _opcode != WSMsgType.CONTINUATION: raise WebSocketError( WSCloseCode.PROTOCOL_ERROR, 'The opcode in non-fin frame is expected ' 'to be zero, got {!r}'.format(_opcode)) else: data.append(payload) if opcode == WSMsgType.TEXT: try: text = b''.join(data).decode('utf-8') out.feed_data(WSMessage(WSMsgType.TEXT, text, ''), len(text)) except UnicodeDecodeError as exc: raise WebSocketError( WSCloseCode.INVALID_TEXT, 'Invalid UTF-8 text message') from exc else: data = b''.join(data) out.feed_data( WSMessage(WSMsgType.BINARY, data, ''), len(data)) native_byteorder = sys.byteorder def _websocket_mask_python(mask, data): """Websocket masking function. `mask` is a `bytes` object of length 4; `data` is a `bytes` object of any length. Returns a `bytes` object of the same length as `data` with the mask applied as specified in section 5.3 of RFC 6455. This pure-python implementation may be replaced by an optimized version when available. """ assert isinstance(data, bytearray), data assert len(mask) == 4, mask datalen = len(data) if datalen == 0: # everything work without this, but may be changed later in Python. return bytearray() data = int.from_bytes(data, native_byteorder) mask = int.from_bytes(mask * (datalen // 4) + mask[: datalen % 4], native_byteorder) return (data ^ mask).to_bytes(datalen, native_byteorder) if bool(os.environ.get('AIOHTTP_NO_EXTENSIONS')): _websocket_mask = _websocket_mask_python else: try: from ._websocket import _websocket_mask_cython _websocket_mask = _websocket_mask_cython except ImportError: # pragma: no cover _websocket_mask = _websocket_mask_python def parse_frame(buf, continuation=False): """Return the next frame from the socket.""" # read header data = yield from buf.read(2) first_byte, second_byte = data 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 if rsv1 or rsv2 or rsv3: raise WebSocketError( WSCloseCode.PROTOCOL_ERROR, 'Received frame with non-zero reserved bits') if opcode > 0x7 and fin == 0: raise WebSocketError( WSCloseCode.PROTOCOL_ERROR, 'Received fragmented control frame') if fin == 0 and opcode == WSMsgType.CONTINUATION and not continuation: raise WebSocketError( WSCloseCode.PROTOCOL_ERROR, 'Received new fragment frame with non-zero ' 'opcode {!r}'.format(opcode)) 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") # read payload if length == 126: data = yield from buf.read(2) length = UNPACK_LEN2(data)[0] elif length > 126: data = yield from buf.read(8) length = UNPACK_LEN3(data)[0] if has_mask: mask = yield from buf.read(4) if length: payload = yield from buf.read(length) else: payload = bytearray() if has_mask: payload = _websocket_mask(bytes(mask), payload) return fin, opcode, payload class WebSocketWriter: def __init__(self, writer, *, use_mask=False, random=random.Random()): self.writer = writer self.use_mask = use_mask self.randrange = random.randrange def _send_frame(self, message, opcode): """Send a frame over the websocket with message as its payload.""" msg_length = len(message) use_mask = self.use_mask if use_mask: mask_bit = 0x80 else: mask_bit = 0 if msg_length < 126: header = PACK_LEN1(0x80 | opcode, msg_length | mask_bit) elif msg_length < (1 << 16): header = PACK_LEN2(0x80 | opcode, 126 | mask_bit, msg_length) else: header = PACK_LEN3(0x80 | opcode, 127 | mask_bit, msg_length) if use_mask: mask = self.randrange(0, 0xffffffff) mask = mask.to_bytes(4, 'big') message = _websocket_mask(mask, bytearray(message)) self.writer.write(header + mask + message) else: if len(message) > MSG_SIZE: self.writer.write(header) self.writer.write(message) else: self.writer.write(header + message) def pong(self, message=b''): """Send pong message.""" if isinstance(message, str): message = message.encode('utf-8') self._send_frame(message, WSMsgType.PONG) def ping(self, message=b''): """Send ping message.""" if isinstance(message, str): message = message.encode('utf-8') self._send_frame(message, WSMsgType.PING) def send(self, message, binary=False): """Send a frame over the websocket with message as its payload.""" if isinstance(message, str): message = message.encode('utf-8') if binary: self._send_frame(message, WSMsgType.BINARY) else: self._send_frame(message, WSMsgType.TEXT) def close(self, code=1000, message=b''): """Close the websocket, sending the specified code and message.""" if isinstance(message, str): message = message.encode('utf-8') self._send_frame( PACK_CLOSE_CODE(code) + message, opcode=WSMsgType.CLOSE) def do_handshake(method, headers, transport, protocols=()): """Prepare WebSocket handshake. It return HTTP response code, response headers, websocket parser, websocket writer. It does not perform any IO. `protocols` is a sequence of known protocols. On successful handshake, the returned response headers contain the first protocol in this list which the server also knows. """ # WebSocket accepts only GET if method.upper() != hdrs.METH_GET: raise errors.HttpProcessingError( code=405, headers=((hdrs.ALLOW, hdrs.METH_GET),)) if 'websocket' != headers.get(hdrs.UPGRADE, '').lower().strip(): raise errors.HttpBadRequest( message='No WebSocket UPGRADE hdr: {}\n Can ' '"Upgrade" only to "WebSocket".'.format(headers.get(hdrs.UPGRADE))) if 'upgrade' not in headers.get(hdrs.CONNECTION, '').lower(): raise errors.HttpBadRequest( message='No CONNECTION upgrade hdr: {}'.format( headers.get(hdrs.CONNECTION))) # find common sub-protocol between client and server protocol = None if hdrs.SEC_WEBSOCKET_PROTOCOL in headers: req_protocols = [str(proto.strip()) for proto in headers[hdrs.SEC_WEBSOCKET_PROTOCOL].split(',')] for proto in req_protocols: if proto in protocols: protocol = proto break else: # No overlap found: Return no protocol as per spec ws_logger.warning( 'Client protocols %r don’t overlap server-known ones %r', req_protocols, protocols) # check supported version version = headers.get(hdrs.SEC_WEBSOCKET_VERSION, '') if version not in ('13', '8', '7'): raise errors.HttpBadRequest( message='Unsupported version: {}'.format(version), headers=((hdrs.SEC_WEBSOCKET_VERSION, '13'),)) # check client handshake for validity key = headers.get(hdrs.SEC_WEBSOCKET_KEY) try: if not key or len(base64.b64decode(key)) != 16: raise errors.HttpBadRequest( message='Handshake error: {!r}'.format(key)) except binascii.Error: raise errors.HttpBadRequest( message='Handshake error: {!r}'.format(key)) from None response_headers = [ (hdrs.UPGRADE, 'websocket'), (hdrs.CONNECTION, 'upgrade'), (hdrs.TRANSFER_ENCODING, 'chunked'), (hdrs.SEC_WEBSOCKET_ACCEPT, base64.b64encode( hashlib.sha1(key.encode() + WS_KEY).digest()).decode())] if protocol: response_headers.append((hdrs.SEC_WEBSOCKET_PROTOCOL, protocol)) # response code, headers, parser, writer, protocol return (101, response_headers, WebSocketParser, WebSocketWriter(transport), protocol) aiohttp-1.2.0/aiohttp/web_exceptions.py0000664000175000017500000002012413025134363021065 0ustar travistravis00000000000000from .web_reqrep import Response __all__ = ( 'HTTPException', 'HTTPError', 'HTTPRedirection', 'HTTPSuccessful', 'HTTPOk', 'HTTPCreated', 'HTTPAccepted', 'HTTPNonAuthoritativeInformation', 'HTTPNoContent', 'HTTPResetContent', 'HTTPPartialContent', 'HTTPMultipleChoices', 'HTTPMovedPermanently', 'HTTPFound', 'HTTPSeeOther', 'HTTPNotModified', 'HTTPUseProxy', 'HTTPTemporaryRedirect', 'HTTPPermanentRedirect', 'HTTPClientError', 'HTTPBadRequest', 'HTTPUnauthorized', 'HTTPPaymentRequired', 'HTTPForbidden', 'HTTPNotFound', 'HTTPMethodNotAllowed', 'HTTPNotAcceptable', 'HTTPProxyAuthenticationRequired', 'HTTPRequestTimeout', 'HTTPConflict', 'HTTPGone', 'HTTPLengthRequired', 'HTTPPreconditionFailed', 'HTTPRequestEntityTooLarge', 'HTTPRequestURITooLong', 'HTTPUnsupportedMediaType', 'HTTPRequestRangeNotSatisfiable', 'HTTPExpectationFailed', 'HTTPMisdirectedRequest', 'HTTPUpgradeRequired', 'HTTPPreconditionRequired', 'HTTPTooManyRequests', 'HTTPRequestHeaderFieldsTooLarge', 'HTTPUnavailableForLegalReasons', 'HTTPServerError', 'HTTPInternalServerError', 'HTTPNotImplemented', 'HTTPBadGateway', 'HTTPServiceUnavailable', 'HTTPGatewayTimeout', 'HTTPVersionNotSupported', 'HTTPVariantAlsoNegotiates', 'HTTPNotExtended', 'HTTPNetworkAuthenticationRequired', ) ############################################################ # HTTP Exceptions ############################################################ class HTTPException(Response, Exception): # You should set in subclasses: # status = 200 status_code = None empty_body = False def __init__(self, *, headers=None, reason=None, body=None, text=None, content_type=None): Response.__init__(self, status=self.status_code, headers=headers, reason=reason, body=body, text=text, content_type=content_type) Exception.__init__(self, self.reason) if self.body is None and not self.empty_body: self.text = "{}: {}".format(self.status, self.reason) class HTTPError(HTTPException): """Base class for exceptions with status codes in the 400s and 500s.""" class HTTPRedirection(HTTPException): """Base class for exceptions with status codes in the 300s.""" class HTTPSuccessful(HTTPException): """Base class for exceptions with status codes in the 200s.""" class HTTPOk(HTTPSuccessful): status_code = 200 class HTTPCreated(HTTPSuccessful): status_code = 201 class HTTPAccepted(HTTPSuccessful): status_code = 202 class HTTPNonAuthoritativeInformation(HTTPSuccessful): status_code = 203 class HTTPNoContent(HTTPSuccessful): status_code = 204 empty_body = True class HTTPResetContent(HTTPSuccessful): status_code = 205 empty_body = True class HTTPPartialContent(HTTPSuccessful): status_code = 206 ############################################################ # 3xx redirection ############################################################ class _HTTPMove(HTTPRedirection): def __init__(self, location, *, headers=None, reason=None, body=None, text=None, content_type=None): if not location: raise ValueError("HTTP redirects need a location to redirect to.") super().__init__(headers=headers, reason=reason, body=body, text=text, content_type=content_type) self.headers['Location'] = str(location) self.location = location class HTTPMultipleChoices(_HTTPMove): status_code = 300 class HTTPMovedPermanently(_HTTPMove): status_code = 301 class HTTPFound(_HTTPMove): status_code = 302 # This one is safe after a POST (the redirected location will be # retrieved with GET): class HTTPSeeOther(_HTTPMove): status_code = 303 class HTTPNotModified(HTTPRedirection): # FIXME: this should include a date or etag header status_code = 304 empty_body = True class HTTPUseProxy(_HTTPMove): # Not a move, but looks a little like one status_code = 305 class HTTPTemporaryRedirect(_HTTPMove): status_code = 307 class HTTPPermanentRedirect(_HTTPMove): status_code = 308 ############################################################ # 4xx client error ############################################################ class HTTPClientError(HTTPError): pass class HTTPBadRequest(HTTPClientError): status_code = 400 class HTTPUnauthorized(HTTPClientError): status_code = 401 class HTTPPaymentRequired(HTTPClientError): status_code = 402 class HTTPForbidden(HTTPClientError): status_code = 403 class HTTPNotFound(HTTPClientError): status_code = 404 class HTTPMethodNotAllowed(HTTPClientError): status_code = 405 def __init__(self, method, allowed_methods, *, headers=None, reason=None, body=None, text=None, content_type=None): allow = ','.join(sorted(allowed_methods)) super().__init__(headers=headers, reason=reason, body=body, text=text, content_type=content_type) self.headers['Allow'] = allow self.allowed_methods = allowed_methods self.method = method.upper() class HTTPNotAcceptable(HTTPClientError): status_code = 406 class HTTPProxyAuthenticationRequired(HTTPClientError): status_code = 407 class HTTPRequestTimeout(HTTPClientError): status_code = 408 class HTTPConflict(HTTPClientError): status_code = 409 class HTTPGone(HTTPClientError): status_code = 410 class HTTPLengthRequired(HTTPClientError): status_code = 411 class HTTPPreconditionFailed(HTTPClientError): status_code = 412 class HTTPRequestEntityTooLarge(HTTPClientError): status_code = 413 class HTTPRequestURITooLong(HTTPClientError): status_code = 414 class HTTPUnsupportedMediaType(HTTPClientError): status_code = 415 class HTTPRequestRangeNotSatisfiable(HTTPClientError): status_code = 416 class HTTPExpectationFailed(HTTPClientError): status_code = 417 class HTTPMisdirectedRequest(HTTPClientError): status_code = 421 class HTTPUpgradeRequired(HTTPClientError): status_code = 426 class HTTPPreconditionRequired(HTTPClientError): status_code = 428 class HTTPTooManyRequests(HTTPClientError): status_code = 429 class HTTPRequestHeaderFieldsTooLarge(HTTPClientError): status_code = 431 class HTTPUnavailableForLegalReasons(HTTPClientError): status_code = 451 def __init__(self, link, *, headers=None, reason=None, body=None, text=None, content_type=None): super().__init__(headers=headers, reason=reason, body=body, text=text, content_type=content_type) self.headers['Link'] = '<%s>; rel="blocked-by"' % link self.link = link ############################################################ # 5xx Server Error ############################################################ # Response status codes beginning with the digit "5" indicate cases in # which the server is aware that it has erred or is incapable of # performing the request. Except when responding to a HEAD request, the # server SHOULD include an entity containing an explanation of the error # situation, and whether it is a temporary or permanent condition. User # agents SHOULD display any included entity to the user. These response # codes are applicable to any request method. class HTTPServerError(HTTPError): pass class HTTPInternalServerError(HTTPServerError): status_code = 500 class HTTPNotImplemented(HTTPServerError): status_code = 501 class HTTPBadGateway(HTTPServerError): status_code = 502 class HTTPServiceUnavailable(HTTPServerError): status_code = 503 class HTTPGatewayTimeout(HTTPServerError): status_code = 504 class HTTPVersionNotSupported(HTTPServerError): status_code = 505 class HTTPVariantAlsoNegotiates(HTTPServerError): status_code = 506 class HTTPNotExtended(HTTPServerError): status_code = 510 class HTTPNetworkAuthenticationRequired(HTTPServerError): status_code = 511 aiohttp-1.2.0/aiohttp/web_urldispatcher.py0000664000175000017500000007044313025134363021566 0ustar travistravis00000000000000import abc import asyncio import collections import inspect import keyword import os import re import sys import warnings from collections.abc import Container, Iterable, Sized from pathlib import Path from types import MappingProxyType from yarl import URL, quote, unquote from . import hdrs from .abc import AbstractMatchInfo, AbstractRouter, AbstractView from .file_sender import FileSender from .protocol import HttpVersion11 from .web_exceptions import (HTTPExpectationFailed, HTTPForbidden, HTTPMethodNotAllowed, HTTPNotFound) from .web_reqrep import Response, StreamResponse __all__ = ('UrlDispatcher', 'UrlMappingMatchInfo', 'AbstractResource', 'Resource', 'PlainResource', 'DynamicResource', 'AbstractRoute', 'ResourceRoute', 'StaticResource', 'View') PY_35 = sys.version_info >= (3, 5) HTTP_METHOD_RE = re.compile(r"^[0-9A-Za-z!#\$%&'\*\+\-\.\^_`\|~]+$") class AbstractResource(Sized, Iterable): def __init__(self, *, name=None): self._name = name @property def name(self): return self._name @abc.abstractmethod # pragma: no branch def url(self, **kwargs): """Construct url for resource with additional params. Deprecated, use url_for() instead. """ warnings.warn(".url(...) is deprecated, use .url_for instead", DeprecationWarning, stacklevel=3) @abc.abstractmethod # pragma: no branch def url_for(self, **kwargs): """Construct url for resource with additional params.""" @asyncio.coroutine @abc.abstractmethod # pragma: no branch def resolve(self, request): """Resolve resource Return (UrlMappingMatchInfo, allowed_methods) pair.""" @abc.abstractmethod def add_prefix(self, prefix): """Add a prefix to processed URLs. Required for subapplications support. """ @abc.abstractmethod def get_info(self): """Return a dict with additional info useful for introspection""" def freeze(self): pass class AbstractRoute(abc.ABC): def __init__(self, method, handler, *, expect_handler=None, resource=None): if expect_handler is None: expect_handler = _defaultExpectHandler assert asyncio.iscoroutinefunction(expect_handler), \ 'Coroutine is expected, got {!r}'.format(expect_handler) method = method.upper() if not HTTP_METHOD_RE.match(method): raise ValueError("{} is not allowed HTTP method".format(method)) assert callable(handler), handler if asyncio.iscoroutinefunction(handler): pass elif inspect.isgeneratorfunction(handler): warnings.warn("Bare generators are deprecated, " "use @coroutine wrapper", DeprecationWarning) elif (isinstance(handler, type) and issubclass(handler, AbstractView)): pass else: @asyncio.coroutine def handler_wrapper(*args, **kwargs): result = old_handler(*args, **kwargs) if asyncio.iscoroutine(result): result = yield from result return result old_handler = handler handler = handler_wrapper self._method = method self._handler = handler self._expect_handler = expect_handler self._resource = resource @property def method(self): return self._method @property def handler(self): return self._handler @property @abc.abstractmethod def name(self): """Optional route's name, always equals to resource's name.""" @property def resource(self): return self._resource @abc.abstractmethod def get_info(self): """Return a dict with additional info useful for introspection""" @abc.abstractmethod # pragma: no branch def url_for(self, *args, **kwargs): """Construct url for route with additional params.""" @abc.abstractmethod # pragma: no branch def url(self, **kwargs): """Construct url for resource with additional params. Deprecated, use url_for() instead. """ warnings.warn(".url(...) is deprecated, use .url_for instead", DeprecationWarning, stacklevel=3) @asyncio.coroutine def handle_expect_header(self, request): return (yield from self._expect_handler(request)) class UrlMappingMatchInfo(dict, AbstractMatchInfo): def __init__(self, match_dict, route): super().__init__(match_dict) self._route = route self._apps = [] self._frozen = False @property def handler(self): return self._route.handler @property def route(self): return self._route @property def expect_handler(self): return self._route.handle_expect_header @property def http_exception(self): return None def get_info(self): return self._route.get_info() @property def apps(self): return tuple(self._apps) def add_app(self, app): if self._frozen: raise RuntimeError("Cannot change apps stack after .freeze() call") self._apps.insert(0, app) def freeze(self): self._frozen = True def __repr__(self): return "".format(super().__repr__(), self._route) class MatchInfoError(UrlMappingMatchInfo): def __init__(self, http_exception): self._exception = http_exception super().__init__({}, SystemRoute(self._exception)) @property def http_exception(self): return self._exception def __repr__(self): return "".format(self._exception.status, self._exception.reason) @asyncio.coroutine def _defaultExpectHandler(request): """Default handler for Expect header. Just send "100 Continue" to client. raise HTTPExpectationFailed if value of header is not "100-continue" """ expect = request.headers.get(hdrs.EXPECT) if request.version == HttpVersion11: if expect.lower() == "100-continue": request.transport.write(b"HTTP/1.1 100 Continue\r\n\r\n") else: raise HTTPExpectationFailed(text="Unknown Expect: %s" % expect) class Resource(AbstractResource): def __init__(self, *, name=None): super().__init__(name=name) self._routes = [] def add_route(self, method, handler, *, expect_handler=None): for route in self._routes: if route.method == method or route.method == hdrs.METH_ANY: raise RuntimeError("Added route will never be executed, " "method {route.method} is " "already registered".format(route=route)) route = ResourceRoute(method, handler, self, expect_handler=expect_handler) self.register_route(route) return route def register_route(self, route): assert isinstance(route, ResourceRoute), \ 'Instance of Route class is required, got {!r}'.format(route) self._routes.append(route) @asyncio.coroutine def resolve(self, request): allowed_methods = set() match_dict = self._match(request.rel_url.raw_path) if match_dict is None: return None, allowed_methods for route in self._routes: route_method = route.method allowed_methods.add(route_method) if route_method == request.method or route_method == hdrs.METH_ANY: return UrlMappingMatchInfo(match_dict, route), allowed_methods else: return None, allowed_methods yield # pragma: no cover def __len__(self): return len(self._routes) def __iter__(self): return iter(self._routes) class PlainResource(Resource): def __init__(self, path, *, name=None): super().__init__(name=name) assert not path or path.startswith('/') self._path = path def freeze(self): if not self._path: self._path = '/' def add_prefix(self, prefix): assert prefix.startswith('/') assert not prefix.endswith('/') assert len(prefix) > 1 self._path = prefix + self._path def _match(self, path): # string comparison is about 10 times faster than regexp matching if self._path == path: return {} else: return None def get_info(self): return {'path': self._path} def url(self, *, query=None): super().url() return str(self.url_for().with_query(query)) def url_for(self): return URL(self._path) def __repr__(self): name = "'" + self.name + "' " if self.name is not None else "" return " 1 self._pattern = re.compile(re.escape(prefix)+self._pattern.pattern) self._formatter = prefix + self._formatter def _match(self, path): match = self._pattern.fullmatch(path) if match is None: return None else: return {key: unquote(value) for key, value in match.groupdict().items()} def get_info(self): return {'formatter': self._formatter, 'pattern': self._pattern} def url_for(self, **parts): url = self._formatter.format_map(parts) return URL(url) def url(self, *, parts, query=None): super().url(**parts) return str(self.url_for(**parts).with_query(query)) def __repr__(self): name = "'" + self.name + "' " if self.name is not None else "" return (" 1 self._prefix = prefix + self._prefix class StaticResource(PrefixResource): def __init__(self, prefix, directory, *, name=None, expect_handler=None, chunk_size=256*1024, response_factory=StreamResponse, show_index=False, follow_symlinks=False): super().__init__(prefix, name=name) try: directory = Path(directory) if str(directory).startswith('~'): directory = Path(os.path.expanduser(str(directory))) directory = directory.resolve() if not directory.is_dir(): raise ValueError('Not a directory') except (FileNotFoundError, ValueError) as error: raise ValueError( "No directory exists at '{}'".format(directory)) from error self._directory = directory self._file_sender = FileSender(resp_factory=response_factory, chunk_size=chunk_size) self._show_index = show_index self._follow_symlinks = follow_symlinks self._expect_handler = expect_handler self._routes = {'GET': ResourceRoute('GET', self._handle, self, expect_handler=expect_handler), 'HEAD': ResourceRoute('HEAD', self._handle, self, expect_handler=expect_handler)} def url(self, *, filename, query=None): return str(self.url_for(filename=filename).with_query(query)) def url_for(self, *, filename): if isinstance(filename, Path): filename = str(filename) while filename.startswith('/'): filename = filename[1:] filename = '/' + filename url = self._prefix + quote(filename, safe='/') return URL(url) def get_info(self): return {'directory': self._directory, 'prefix': self._prefix} def set_options_route(self, handler): if 'OPTIONS' in self._routes: raise RuntimeError('OPTIONS route was set already') self._routes['OPTIONS'] = ResourceRoute( 'OPTIONS', handler, self, expect_handler=self._expect_handler) @asyncio.coroutine def resolve(self, request): path = request.rel_url.raw_path method = request.method allowed_methods = set(self._routes) if not path.startswith(self._prefix): return None, set() if method not in allowed_methods: return None, allowed_methods match_dict = {'filename': unquote(path[len(self._prefix)+1:])} return (UrlMappingMatchInfo(match_dict, self._routes[method]), allowed_methods) yield # pragma: no cover def __len__(self): return len(self._routes) def __iter__(self): return iter(self._routes.values()) @asyncio.coroutine def _handle(self, request): filename = unquote(request.match_info['filename']) try: filepath = self._directory.joinpath(filename).resolve() if not self._follow_symlinks: filepath.relative_to(self._directory) except (ValueError, FileNotFoundError) as error: # relatively safe raise HTTPNotFound() from error except Exception as error: # perm error or other kind! request.app.logger.exception(error) raise HTTPNotFound() from error # on opening a dir, load it's contents if allowed if filepath.is_dir(): if self._show_index: try: ret = Response(text=self._directory_as_html(filepath), content_type="text/html") except PermissionError: raise HTTPForbidden() else: raise HTTPForbidden() elif filepath.is_file(): ret = yield from self._file_sender.send(request, filepath) else: raise HTTPNotFound return ret def _directory_as_html(self, filepath): "returns directory's index as html" # sanity check assert filepath.is_dir() posix_dir_len = len(self._directory.as_posix()) # remove the beginning of posix path, so it would be relative # to our added static path relative_path_to_dir = filepath.as_posix()[posix_dir_len:] index_of = "Index of /{}".format(relative_path_to_dir) head = "\n{}\n".format(index_of) h1 = "

{}

".format(index_of) index_list = [] dir_index = filepath.iterdir() for _file in sorted(dir_index): # show file url as relative to static path file_url = _file.as_posix()[posix_dir_len:] # if file is a directory, add '/' to the end of the name if _file.is_dir(): file_name = "{}/".format(_file.name) else: file_name = _file.name index_list.append( ''.format(url=file_url, name=file_name) ) ul = "
    \n{}\n
".format('\n'.join(index_list)) body = "\n{}\n{}\n".format(h1, ul) html = "\n{}\n{}\n".format(head, body) return html def __repr__(self): name = "'" + self.name + "'" if self.name is not None else "" return " {directory!r}".format( name=name, path=self._prefix, directory=self._directory) class PrefixedSubAppResource(PrefixResource): def __init__(self, prefix, app): super().__init__(prefix) self._app = app for resource in app.router.resources(): resource.add_prefix(prefix) def add_prefix(self, prefix): super().add_prefix(prefix) for resource in self._app.router.resources(): resource.add_prefix(prefix) def url_for(self, *args, **kwargs): raise RuntimeError(".url_for() is not supported " "by sub-application root") def url(self, **kwargs): """Construct url for route with additional params.""" raise RuntimeError(".url() is not supported " "by sub-application root") def get_info(self): return {'app': self._app, 'prefix': self._prefix} @asyncio.coroutine def resolve(self, request): if not request.url.raw_path.startswith(self._prefix): return None, set() match_info = yield from self._app.router.resolve(request) match_info.add_app(self._app) if isinstance(match_info.http_exception, HTTPMethodNotAllowed): methods = match_info.http_exception.allowed_methods else: methods = set() return (match_info, methods) def __len__(self): return len(self._app.router.routes()) def __iter__(self): return iter(self._app.router.routes()) def __repr__(self): return " {app!r}>".format( prefix=self._prefix, app=self._app) class ResourceRoute(AbstractRoute): """A route with resource""" def __init__(self, method, handler, resource, *, expect_handler=None): super().__init__(method, handler, expect_handler=expect_handler, resource=resource) def __repr__(self): return " {handler!r}".format( method=self.method, resource=self._resource, handler=self.handler) @property def name(self): return self._resource.name def url_for(self, *args, **kwargs): """Construct url for route with additional params.""" return self._resource.url_for(*args, **kwargs) def url(self, **kwargs): """Construct url for route with additional params.""" super().url(**kwargs) return self._resource.url(**kwargs) def get_info(self): return self._resource.get_info() class SystemRoute(AbstractRoute): def __init__(self, http_exception): super().__init__(hdrs.METH_ANY, self._handler) self._http_exception = http_exception def url_for(self, *args, **kwargs): raise RuntimeError(".url_for() is not allowed for SystemRoute") def url(self, *args, **kwargs): raise RuntimeError(".url() is not allowed for SystemRoute") @property def name(self): return None def get_info(self): return {'http_exception': self._http_exception} @asyncio.coroutine def _handler(self, request): raise self._http_exception @property def status(self): return self._http_exception.status @property def reason(self): return self._http_exception.reason def __repr__(self): return "".format(self=self) class View(AbstractView): @asyncio.coroutine def __iter__(self): if self.request.method not in hdrs.METH_ALL: self._raise_allowed_methods() method = getattr(self, self.request.method.lower(), None) if method is None: self._raise_allowed_methods() resp = yield from method() return resp if PY_35: def __await__(self): return (yield from self.__iter__()) def _raise_allowed_methods(self): allowed_methods = { m for m in hdrs.METH_ALL if hasattr(self, m.lower())} raise HTTPMethodNotAllowed(self.request.method, allowed_methods) class ResourcesView(Sized, Iterable, Container): def __init__(self, resources): self._resources = resources def __len__(self): return len(self._resources) def __iter__(self): yield from self._resources def __contains__(self, resource): return resource in self._resources class RoutesView(Sized, Iterable, Container): def __init__(self, resources): self._routes = [] for resource in resources: for route in resource: self._routes.append(route) def __len__(self): return len(self._routes) def __iter__(self): yield from self._routes def __contains__(self, route): return route in self._routes class UrlDispatcher(AbstractRouter, collections.abc.Mapping): DYN = re.compile(r'\{(?P[_a-zA-Z][_a-zA-Z0-9]*)\}') DYN_WITH_RE = re.compile( r'\{(?P[_a-zA-Z][_a-zA-Z0-9]*):(?P.+)\}') GOOD = r'[^{}/]+' ROUTE_RE = re.compile(r'(\{[_a-zA-Z][^{}]*(?:\{[^{}]*\}[^{}]*)*\})') NAME_SPLIT_RE = re.compile(r'[.:-]') def __init__(self): super().__init__() self._resources = [] self._named_resources = {} self._app = None def post_init(self, app): assert app is not None self._app = app @asyncio.coroutine def resolve(self, request): method = request.method allowed_methods = set() for resource in self._resources: match_dict, allowed = yield from resource.resolve(request) if match_dict is not None: return match_dict else: allowed_methods |= allowed else: if allowed_methods: return MatchInfoError(HTTPMethodNotAllowed(method, allowed_methods)) else: return MatchInfoError(HTTPNotFound()) def __iter__(self): return iter(self._named_resources) def __len__(self): return len(self._named_resources) def __contains__(self, name): return name in self._named_resources def __getitem__(self, name): return self._named_resources[name] def resources(self): return ResourcesView(self._resources) def routes(self): return RoutesView(self._resources) def named_resources(self): return MappingProxyType(self._named_resources) def _reg_resource(self, resource): assert isinstance(resource, AbstractResource), \ 'Instance of AbstractResource class is required, got {!r}'.format( resource) if self._app is None: raise RuntimeError(".post_init() should be called before " "first resource registering") if self.frozen: raise RuntimeError("Cannot register a resource into " "frozen router.") name = resource.name if name is not None: parts = self.NAME_SPLIT_RE.split(name) for part in parts: if not part.isidentifier() or keyword.iskeyword(part): raise ValueError('Incorrect route name {!r}, ' 'the name should be a sequence of ' 'python identifiers separated ' 'by dash, dot or column'.format(name)) if name in self._named_resources: raise ValueError('Duplicate {!r}, ' 'already handled by {!r}' .format(name, self._named_resources[name])) self._named_resources[name] = resource self._resources.append(resource) def add_resource(self, path, *, name=None): if path and not path.startswith('/'): raise ValueError("path should be started with / or be empty") if not ('{' in path or '}' in path or self.ROUTE_RE.search(path)): resource = PlainResource(quote(path, safe='/'), name=name) self._reg_resource(resource) return resource pattern = '' formatter = '' for part in self.ROUTE_RE.split(path): match = self.DYN.fullmatch(part) if match: pattern += '(?P<{}>{})'.format(match.group('var'), self.GOOD) formatter += '{' + match.group('var') + '}' continue match = self.DYN_WITH_RE.fullmatch(part) if match: pattern += '(?P<{var}>{re})'.format(**match.groupdict()) formatter += '{' + match.group('var') + '}' continue if '{' in part or '}' in part: raise ValueError("Invalid path '{}'['{}']".format(path, part)) part = quote(part, safe='/') formatter += part pattern += re.escape(part) try: compiled = re.compile(pattern) except re.error as exc: raise ValueError( "Bad pattern '{}': {}".format(pattern, exc)) from None resource = DynamicResource(compiled, formatter, name=name) self._reg_resource(resource) return resource def add_route(self, method, path, handler, *, name=None, expect_handler=None): resource = self.add_resource(path, name=name) return resource.add_route(method, handler, expect_handler=expect_handler) def add_static(self, prefix, path, *, name=None, expect_handler=None, chunk_size=256*1024, response_factory=StreamResponse, show_index=False, follow_symlinks=False): """Add static files view. prefix - url prefix path - folder with files """ # TODO: implement via PrefixedResource, not ResourceAdapter assert prefix.startswith('/') if prefix.endswith('/'): prefix = prefix[:-1] resource = StaticResource(prefix, path, name=name, expect_handler=expect_handler, chunk_size=chunk_size, response_factory=response_factory, show_index=show_index, follow_symlinks=follow_symlinks) self._reg_resource(resource) return resource def add_head(self, *args, **kwargs): """ Shortcut for add_route with method HEAD """ return self.add_route(hdrs.METH_HEAD, *args, **kwargs) def add_get(self, *args, **kwargs): """ Shortcut for add_route with method GET """ return self.add_route(hdrs.METH_GET, *args, **kwargs) def add_post(self, *args, **kwargs): """ Shortcut for add_route with method POST """ return self.add_route(hdrs.METH_POST, *args, **kwargs) def add_put(self, *args, **kwargs): """ Shortcut for add_route with method PUT """ return self.add_route(hdrs.METH_PUT, *args, **kwargs) def add_patch(self, *args, **kwargs): """ Shortcut for add_route with method PATCH """ return self.add_route(hdrs.METH_PATCH, *args, **kwargs) def add_delete(self, *args, **kwargs): """ Shortcut for add_route with method DELETE """ return self.add_route(hdrs.METH_DELETE, *args, **kwargs) def add_subapp(self, prefix, subapp): if subapp.frozen: raise RuntimeError("Cannod add frozen application") if prefix.endswith('/'): prefix = prefix[:-1] if prefix in ('', '/'): raise ValueError("Prefix cannot be empty") resource = PrefixedSubAppResource(prefix, subapp) self._reg_resource(resource) self._app._reg_subapp_signals(subapp) subapp.freeze() return resource def freeze(self): super().freeze() for resource in self._resources: resource.freeze() aiohttp-1.2.0/aiohttp/pytest_plugin.py0000664000175000017500000000725513025134363020767 0ustar travistravis00000000000000import asyncio import contextlib import pytest from aiohttp.web import Application from .test_utils import unused_port as _unused_port from .test_utils import (RawTestServer, TestClient, TestServer, loop_context, setup_test_loop, teardown_test_loop) @contextlib.contextmanager def _passthrough_loop_context(loop): if loop: # loop already exists, pass it straight through yield loop else: # this shadows loop_context's standard behavior loop = setup_test_loop() yield loop teardown_test_loop(loop) def pytest_pycollect_makeitem(collector, name, obj): """ Fix pytest collecting for coroutines. """ if collector.funcnamefilter(name) and asyncio.iscoroutinefunction(obj): return list(collector._genfunctions(name, obj)) def pytest_pyfunc_call(pyfuncitem): """ Run coroutines in an event loop instead of a normal function call. """ if asyncio.iscoroutinefunction(pyfuncitem.function): existing_loop = pyfuncitem.funcargs.get('loop', None) with _passthrough_loop_context(existing_loop) as _loop: testargs = {arg: pyfuncitem.funcargs[arg] for arg in pyfuncitem._fixtureinfo.argnames} task = _loop.create_task(pyfuncitem.obj(**testargs)) _loop.run_until_complete(task) return True @pytest.yield_fixture def loop(): with loop_context() as _loop: yield _loop @pytest.fixture def unused_port(): return _unused_port @pytest.yield_fixture def test_server(loop): servers = [] @asyncio.coroutine def go(app, **kwargs): assert app.loop is loop, \ "Application is attached to other event loop" server = TestServer(app) yield from server.start_server(**kwargs) servers.append(server) return server yield go @asyncio.coroutine def finalize(): while servers: yield from servers.pop().close() loop.run_until_complete(finalize()) @pytest.yield_fixture def raw_test_server(loop): servers = [] @asyncio.coroutine def go(handler, **kwargs): server = RawTestServer(handler, loop=loop) yield from server.start_server(**kwargs) servers.append(server) return server yield go @asyncio.coroutine def finalize(): while servers: yield from servers.pop().close() loop.run_until_complete(finalize()) @pytest.yield_fixture def test_client(loop): clients = [] @asyncio.coroutine def go(__param, *args, **kwargs): if isinstance(__param, Application): assert not args, "args should be empty" assert __param.loop is loop, \ "Application is attached to other event loop" client = TestClient(__param, **kwargs) elif isinstance(__param, TestServer): assert not args, "args should be empty" assert __param.app.loop is loop, \ "TestServer is attached to other event loop" client = TestClient(__param, **kwargs) elif isinstance(__param, RawTestServer): assert not args, "args should be empty" assert __param._loop is loop, \ "TestServer is attached to other event loop" client = TestClient(__param, **kwargs) else: __param = __param(loop, *args, **kwargs) client = TestClient(__param) yield from client.start_server() clients.append(client) return client yield go @asyncio.coroutine def finalize(): while clients: yield from clients.pop().close() loop.run_until_complete(finalize()) aiohttp-1.2.0/aiohttp/protocol.py0000664000175000017500000007104713025134363017722 0ustar travistravis00000000000000"""Http related parsers and protocol.""" import collections import functools import http.server import re import string import sys import zlib from abc import ABC, abstractmethod from wsgiref.handlers import format_date_time from multidict import CIMultiDict, istr import aiohttp from . import errors, hdrs from .log import internal_logger __all__ = ('HttpMessage', 'Request', 'Response', 'HttpVersion', 'HttpVersion10', 'HttpVersion11', 'RawRequestMessage', 'RawResponseMessage', 'HttpPrefixParser', 'HttpRequestParser', 'HttpResponseParser', 'HttpPayloadParser') ASCIISET = set(string.printable) METHRE = re.compile('[A-Z0-9$-_.]+') VERSRE = re.compile('HTTP/(\d+).(\d+)') HDRRE = re.compile(b'[\x00-\x1F\x7F()<>@,;:\[\]={} \t\\\\\"]') EOF_MARKER = object() EOL_MARKER = object() STATUS_LINE_READY = object() RESPONSES = http.server.BaseHTTPRequestHandler.responses HttpVersion = collections.namedtuple( 'HttpVersion', ['major', 'minor']) HttpVersion10 = HttpVersion(1, 0) HttpVersion11 = HttpVersion(1, 1) RawStatusLineMessage = collections.namedtuple( 'RawStatusLineMessage', ['method', 'path', 'version']) RawRequestMessage = collections.namedtuple( 'RawRequestMessage', ['method', 'path', 'version', 'headers', 'raw_headers', 'should_close', 'compression']) RawResponseMessage = collections.namedtuple( 'RawResponseMessage', ['version', 'code', 'reason', 'headers', 'raw_headers', 'should_close', 'compression']) class HttpParser: def __init__(self, max_line_size=8190, max_headers=32768, max_field_size=8190): self.max_line_size = max_line_size self.max_headers = max_headers self.max_field_size = max_field_size def parse_headers(self, lines): """Parses RFC 5322 headers from a stream. Line continuations are supported. Returns list of header name and value pairs. Header name is in upper case. """ close_conn = None encoding = None headers = CIMultiDict() raw_headers = [] lines_idx = 1 line = lines[1] while line: header_length = len(line) # Parse initial header name : value pair. try: bname, bvalue = line.split(b':', 1) except ValueError: raise errors.InvalidHeader(line) from None bname = bname.strip(b' \t').upper() if HDRRE.search(bname): raise errors.InvalidHeader(bname) # next line lines_idx += 1 line = lines[lines_idx] # consume continuation lines continuation = line and line[0] in (32, 9) # (' ', '\t') if continuation: bvalue = [bvalue] while continuation: header_length += len(line) if header_length > self.max_field_size: raise errors.LineTooLong( 'request header field {}'.format( bname.decode("utf8", "xmlcharrefreplace")), self.max_field_size) bvalue.append(line) # next line lines_idx += 1 line = lines[lines_idx] continuation = line[0] in (32, 9) # (' ', '\t') bvalue = b'\r\n'.join(bvalue) else: if header_length > self.max_field_size: raise errors.LineTooLong( 'request header field {}'.format( bname.decode("utf8", "xmlcharrefreplace")), self.max_field_size) bvalue = bvalue.strip() name = istr(bname.decode('utf-8', 'surrogateescape')) value = bvalue.decode('utf-8', 'surrogateescape') # keep-alive and encoding if name == hdrs.CONNECTION: v = value.lower() if v == 'close': close_conn = True elif v == 'keep-alive': close_conn = False elif name == hdrs.CONTENT_ENCODING: enc = value.lower() if enc in ('gzip', 'deflate'): encoding = enc headers.add(name, value) raw_headers.append((bname, bvalue)) return headers, raw_headers, close_conn, encoding class HttpPrefixParser: """Waits for 'HTTP' prefix (non destructive)""" def __init__(self, allowed_methods=()): self.allowed_methods = [m.upper() for m in allowed_methods] def __call__(self, out, buf): raw_data = yield from buf.waituntil(b' ', 12) method = raw_data.decode('ascii', 'surrogateescape').strip() # method method = method.upper() if not METHRE.match(method): raise errors.BadStatusLine(method) # allowed method if self.allowed_methods and method not in self.allowed_methods: raise errors.HttpMethodNotAllowed(message=method) out.feed_data(method, len(method)) out.feed_eof() class HttpRequestParser(HttpParser): """Read request status line. Exception errors.BadStatusLine could be raised in case of any errors in status line. Returns RawRequestMessage. """ def __call__(self, out, buf): # read HTTP message (request line + headers) try: raw_data = yield from buf.readuntil( b'\r\n\r\n', self.max_headers) except errors.LineLimitExceededParserError as exc: raise errors.LineTooLong('request header', exc.limit) from None lines = raw_data.split(b'\r\n') # request line line = lines[0].decode('utf-8', 'surrogateescape') try: method, path, version = line.split(None, 2) except ValueError: raise errors.BadStatusLine(line) from None # method method = method.upper() if not METHRE.match(method): raise errors.BadStatusLine(method) # version try: if version.startswith('HTTP/'): n1, n2 = version[5:].split('.', 1) version = HttpVersion(int(n1), int(n2)) else: raise errors.BadStatusLine(version) except: raise errors.BadStatusLine(version) # read headers headers, raw_headers, close, compression = self.parse_headers(lines) if close is None: # then the headers weren't set in the request if version <= HttpVersion10: # HTTP 1.0 must asks to not close close = True else: # HTTP 1.1 must ask to close. close = False out.feed_data( RawRequestMessage( method, path, version, headers, raw_headers, close, compression), len(raw_data)) out.feed_eof() class HttpResponseParser(HttpParser): """Read response status line and headers. BadStatusLine could be raised in case of any errors in status line. Returns RawResponseMessage""" def __call__(self, out, buf): # read HTTP message (response line + headers) try: raw_data = yield from buf.readuntil( b'\r\n\r\n', self.max_line_size + self.max_headers) except errors.LineLimitExceededParserError as exc: raise errors.LineTooLong('response header', exc.limit) from None lines = raw_data.split(b'\r\n') line = lines[0].decode('utf-8', 'surrogateescape') try: version, status = line.split(None, 1) except ValueError: raise errors.BadStatusLine(line) from None else: try: status, reason = status.split(None, 1) except ValueError: reason = '' # version match = VERSRE.match(version) if match is None: raise errors.BadStatusLine(line) version = HttpVersion(int(match.group(1)), int(match.group(2))) # The status code is a three-digit number try: status = int(status) except ValueError: raise errors.BadStatusLine(line) from None if status < 100 or status > 999: raise errors.BadStatusLine(line) # read headers headers, raw_headers, close, compression = self.parse_headers(lines) if close is None: close = version <= HttpVersion10 out.feed_data( RawResponseMessage( version, status, reason.strip(), headers, raw_headers, close, compression), len(raw_data)) out.feed_eof() class HttpPayloadParser: def __init__(self, message, length=None, compression=True, readall=False, response_with_body=True): self.message = message self.length = length self.compression = compression self.readall = readall self.response_with_body = response_with_body def __call__(self, out, buf): # payload params length = self.message.headers.get(hdrs.CONTENT_LENGTH, self.length) if hdrs.SEC_WEBSOCKET_KEY1 in self.message.headers: length = 8 # payload decompression wrapper if (self.response_with_body and self.compression and self.message.compression): out = DeflateBuffer(out, self.message.compression) # payload parser if not self.response_with_body: # don't parse payload if it's not expected to be received pass elif 'chunked' in self.message.headers.get( hdrs.TRANSFER_ENCODING, ''): yield from self.parse_chunked_payload(out, buf) elif length is not None: try: length = int(length) except ValueError: raise errors.InvalidHeader(hdrs.CONTENT_LENGTH) from None if length < 0: raise errors.InvalidHeader(hdrs.CONTENT_LENGTH) elif length > 0: yield from self.parse_length_payload(out, buf, length) else: if self.readall and getattr(self.message, 'code', 0) != 204: yield from self.parse_eof_payload(out, buf) elif getattr(self.message, 'method', None) in ('PUT', 'POST'): internal_logger.warning( # pragma: no cover 'Content-Length or Transfer-Encoding header is required') out.feed_eof() def parse_chunked_payload(self, out, buf): """Chunked transfer encoding parser.""" while True: # read next chunk size line = yield from buf.readuntil(b'\r\n', 8192) i = line.find(b';') if i >= 0: line = line[:i] # strip chunk-extensions else: line = line.strip() try: size = int(line, 16) except ValueError: raise errors.TransferEncodingError(line) from None if size == 0: # eof marker break # read chunk and feed buffer while size: chunk = yield from buf.readsome(size) out.feed_data(chunk, len(chunk)) size = size - len(chunk) # toss the CRLF at the end of the chunk yield from buf.skip(2) # read and discard trailer up to the CRLF terminator yield from buf.skipuntil(b'\r\n') def parse_length_payload(self, out, buf, length=0): """Read specified amount of bytes.""" required = length while required: chunk = yield from buf.readsome(required) out.feed_data(chunk, len(chunk)) required -= len(chunk) def parse_eof_payload(self, out, buf): """Read all bytes until eof.""" try: while True: chunk = yield from buf.readsome() out.feed_data(chunk, len(chunk)) except aiohttp.EofStream: pass class DeflateBuffer: """DeflateStream decompress stream and feed data into specified stream.""" def __init__(self, out, encoding): self.out = out zlib_mode = (16 + zlib.MAX_WBITS if encoding == 'gzip' else -zlib.MAX_WBITS) self.zlib = zlib.decompressobj(wbits=zlib_mode) def feed_data(self, chunk, size): try: chunk = self.zlib.decompress(chunk) except Exception: raise errors.ContentEncodingError('deflate') if chunk: self.out.feed_data(chunk, len(chunk)) def feed_eof(self): chunk = self.zlib.flush() self.out.feed_data(chunk, len(chunk)) if not self.zlib.eof: raise errors.ContentEncodingError('deflate') self.out.feed_eof() def wrap_payload_filter(func): """Wraps payload filter and piped filters. Filter is a generator that accepts arbitrary chunks of data, modify data and emit new stream of data. For example we have stream of chunks: ['1', '2', '3', '4', '5'], we can apply chunking filter to this stream: ['1', '2', '3', '4', '5'] | response.add_chunking_filter(2) | ['12', '34', '5'] It is possible to use different filters at the same time. For a example to compress incoming stream with 'deflate' encoding and then split data and emit chunks of 8192 bytes size chunks: >>> response.add_compression_filter('deflate') >>> response.add_chunking_filter(8192) Filters do not alter transfer encoding. Filter can receive types types of data, bytes object or EOF_MARKER. 1. If filter receives bytes object, it should process data and yield processed data then yield EOL_MARKER object. 2. If Filter received EOF_MARKER, it should yield remaining data (buffered) and then yield EOF_MARKER. """ @functools.wraps(func) def wrapper(self, *args, **kw): new_filter = func(self, *args, **kw) filter = self.filter if filter is not None: next(new_filter) self.filter = filter_pipe(filter, new_filter) else: self.filter = new_filter next(self.filter) return wrapper def filter_pipe(filter, filter2, *, EOF_MARKER=EOF_MARKER, EOL_MARKER=EOL_MARKER): """Creates pipe between two filters. filter_pipe() feeds first filter with incoming data and then send yielded from first filter data into filter2, results of filter2 are being emitted. 1. If filter_pipe receives bytes object, it sends it to the first filter. 2. Reads yielded values from the first filter until it receives EOF_MARKER or EOL_MARKER. 3. Each of this values is being send to second filter. 4. Reads yielded values from second filter until it receives EOF_MARKER or EOL_MARKER. Each of this values yields to writer. """ chunk = yield while True: eof = chunk is EOF_MARKER chunk = filter.send(chunk) while chunk is not EOL_MARKER: chunk = filter2.send(chunk) while chunk not in (EOF_MARKER, EOL_MARKER): yield chunk chunk = next(filter2) if chunk is not EOF_MARKER: if eof: chunk = EOF_MARKER else: chunk = next(filter) else: break chunk = yield EOL_MARKER class HttpMessage(ABC): """HttpMessage allows to write headers and payload to a stream. For example, lets say we want to read file then compress it with deflate compression and then send it with chunked transfer encoding, code may look like this: >>> response = aiohttp.Response(transport, 200) We have to use deflate compression first: >>> response.add_compression_filter('deflate') Then we want to split output stream into chunks of 1024 bytes size: >>> response.add_chunking_filter(1024) We can add headers to response with add_headers() method. add_headers() does not send data to transport, send_headers() sends request/response line and then sends headers: >>> response.add_headers( ... ('Content-Disposition', 'attachment; filename="..."')) >>> response.send_headers() Now we can use chunked writer to write stream to a network stream. First call to write() method sends response status line and headers, add_header() and add_headers() method unavailable at this stage: >>> with open('...', 'rb') as f: ... chunk = fp.read(8192) ... while chunk: ... response.write(chunk) ... chunk = fp.read(8192) >>> response.write_eof() """ writer = None # 'filter' is being used for altering write() behaviour, # add_chunking_filter adds deflate/gzip compression and # add_compression_filter splits incoming data into a chunks. filter = None HOP_HEADERS = None # Must be set by subclass. SERVER_SOFTWARE = 'Python/{0[0]}.{0[1]} aiohttp/{1}'.format( sys.version_info, aiohttp.__version__) upgrade = False # Connection: UPGRADE websocket = False # Upgrade: WEBSOCKET has_chunked_hdr = False # Transfer-encoding: chunked # subclass can enable auto sending headers with write() call, # this is useful for wsgi's start_response implementation. _send_headers = False def __init__(self, transport, version, close): self.transport = transport self._version = version self.closing = close self.keepalive = None self.chunked = False self.length = None self.headers = CIMultiDict() self.headers_sent = False self.output_length = 0 self.headers_length = 0 self._output_size = 0 self._cache = {} @property @abstractmethod def status_line(self): return b'' @abstractmethod def autochunked(self): return False @property def version(self): return self._version @property def body_length(self): return self.output_length - self.headers_length def force_close(self): self.closing = True self.keepalive = False def enable_chunked_encoding(self): self.chunked = True def keep_alive(self): if self.keepalive is None: if self.version < HttpVersion10: # keep alive not supported at all return False if self.version == HttpVersion10: if self.headers.get(hdrs.CONNECTION) == 'keep-alive': return True else: # no headers means we close for Http 1.0 return False else: return not self.closing else: return self.keepalive def is_headers_sent(self): return self.headers_sent def add_header(self, name, value): """Analyze headers. Calculate content length, removes hop headers, etc.""" assert not self.headers_sent, 'headers have been sent already' assert isinstance(name, str), \ 'Header name should be a string, got {!r}'.format(name) assert set(name).issubset(ASCIISET), \ 'Header name should contain ASCII chars, got {!r}'.format(name) assert isinstance(value, str), \ 'Header {!r} should have string value, got {!r}'.format( name, value) name = istr(name) value = value.strip() if name == hdrs.CONTENT_LENGTH: self.length = int(value) if name == hdrs.TRANSFER_ENCODING: self.has_chunked_hdr = value.lower().strip() == 'chunked' if name == hdrs.CONNECTION: val = value.lower() # handle websocket if 'upgrade' in val: self.upgrade = True # connection keep-alive elif 'close' in val: self.keepalive = False elif 'keep-alive' in val: self.keepalive = True elif name == hdrs.UPGRADE: if 'websocket' in value.lower(): self.websocket = True self.headers[name] = value elif name not in self.HOP_HEADERS: # ignore hop-by-hop headers self.headers.add(name, value) def add_headers(self, *headers): """Adds headers to a HTTP message.""" for name, value in headers: self.add_header(name, value) def send_headers(self, _sep=': ', _end='\r\n'): """Writes headers to a stream. Constructs payload writer.""" # Chunked response is only for HTTP/1.1 clients or newer # and there is no Content-Length header is set. # Do not use chunked responses when the response is guaranteed to # not have a response body (304, 204). assert not self.headers_sent, 'headers have been sent already' self.headers_sent = True if self.chunked or self.autochunked(): self.writer = self._write_chunked_payload() self.headers[hdrs.TRANSFER_ENCODING] = 'chunked' elif self.length is not None: self.writer = self._write_length_payload(self.length) else: self.writer = self._write_eof_payload() next(self.writer) self._add_default_headers() # status + headers headers = self.status_line + ''.join( [k + _sep + v + _end for k, v in self.headers.items()]) headers = headers.encode('utf-8') + b'\r\n' self.output_length += len(headers) self.headers_length = len(headers) self.transport.write(headers) def _add_default_headers(self): # set the connection header connection = None if self.upgrade: connection = 'upgrade' elif not self.closing if self.keepalive is None else self.keepalive: if self.version == HttpVersion10: connection = 'keep-alive' else: if self.version == HttpVersion11: connection = 'close' if connection is not None: self.headers[hdrs.CONNECTION] = connection def write(self, chunk, *, drain=False, EOF_MARKER=EOF_MARKER, EOL_MARKER=EOL_MARKER): """Writes chunk of data to a stream by using different writers. writer uses filter to modify chunk of data. write_eof() indicates end of stream. writer can't be used after write_eof() method being called. write() return drain future. """ assert (isinstance(chunk, (bytes, bytearray)) or chunk is EOF_MARKER), chunk size = self.output_length if self._send_headers and not self.headers_sent: self.send_headers() if self.filter: chunk = self.filter.send(chunk) while chunk not in (EOF_MARKER, EOL_MARKER): if chunk: self.writer.send(chunk) chunk = next(self.filter) else: if chunk is not EOF_MARKER: self.writer.send(chunk) self._output_size += self.output_length - size if self._output_size > 64 * 1024: if drain: self._output_size = 0 return self.transport.drain() return () def write_eof(self): self.write(EOF_MARKER) try: self.writer.throw(aiohttp.EofStream()) except StopIteration: pass return self.transport.drain() def _write_chunked_payload(self): """Write data in chunked transfer encoding.""" while True: try: chunk = yield except aiohttp.EofStream: self.transport.write(b'0\r\n\r\n') self.output_length += 5 break chunk = bytes(chunk) chunk_len = '{:x}\r\n'.format(len(chunk)).encode('ascii') self.transport.write(chunk_len + chunk + b'\r\n') self.output_length += len(chunk_len) + len(chunk) + 2 def _write_length_payload(self, length): """Write specified number of bytes to a stream.""" while True: try: chunk = yield except aiohttp.EofStream: break if length: l = len(chunk) if length >= l: self.transport.write(chunk) self.output_length += l length = length-l else: self.transport.write(chunk[:length]) self.output_length += length length = 0 def _write_eof_payload(self): while True: try: chunk = yield except aiohttp.EofStream: break self.transport.write(chunk) self.output_length += len(chunk) @wrap_payload_filter def add_chunking_filter(self, chunk_size=16*1024, *, EOF_MARKER=EOF_MARKER, EOL_MARKER=EOL_MARKER): """Split incoming stream into chunks.""" buf = bytearray() chunk = yield while True: if chunk is EOF_MARKER: if buf: yield buf yield EOF_MARKER else: buf.extend(chunk) while len(buf) >= chunk_size: chunk = bytes(buf[:chunk_size]) del buf[:chunk_size] yield chunk chunk = yield EOL_MARKER @wrap_payload_filter def add_compression_filter(self, encoding='deflate', *, EOF_MARKER=EOF_MARKER, EOL_MARKER=EOL_MARKER): """Compress incoming stream with deflate or gzip encoding.""" zlib_mode = (16 + zlib.MAX_WBITS if encoding == 'gzip' else -zlib.MAX_WBITS) zcomp = zlib.compressobj(wbits=zlib_mode) chunk = yield while True: if chunk is EOF_MARKER: yield zcomp.flush() chunk = yield EOF_MARKER else: yield zcomp.compress(chunk) chunk = yield EOL_MARKER class Response(HttpMessage): """Create HTTP response message. Transport is a socket stream transport. status is a response status code, status has to be integer value. http_version is a tuple that represents HTTP version, (1, 0) stands for HTTP/1.0 and (1, 1) is for HTTP/1.1 """ HOP_HEADERS = () @staticmethod def calc_reason(status, *, _RESPONSES=RESPONSES): record = _RESPONSES.get(status) if record is not None: reason = record[0] else: reason = str(status) return reason def __init__(self, transport, status, http_version=HttpVersion11, close=False, reason=None): super().__init__(transport, http_version, close) self._status = status if reason is None: reason = self.calc_reason(status) self._reason = reason @property def status(self): return self._status @property def reason(self): return self._reason @property def status_line(self): version = self.version return 'HTTP/{}.{} {} {}\r\n'.format( version[0], version[1], self.status, self.reason) def autochunked(self): return (self.length is None and self._version >= HttpVersion11) def _add_default_headers(self): super()._add_default_headers() if hdrs.DATE not in self.headers: # format_date_time(None) is quite expensive self.headers.setdefault(hdrs.DATE, format_date_time(None)) self.headers.setdefault(hdrs.SERVER, self.SERVER_SOFTWARE) class WebResponse(Response): """For usage in aiohttp.web only""" def _add_default_headers(self): pass class Request(HttpMessage): HOP_HEADERS = () def __init__(self, transport, method, path, http_version=HttpVersion11, close=False): # set the default for HTTP 0.9 to be different # will only be overwritten with keep-alive header if http_version < HttpVersion10: close = True super().__init__(transport, http_version, close) self._method = method self._path = path @property def method(self): return self._method @property def path(self): return self._path @property def status_line(self): return '{0} {1} HTTP/{2[0]}.{2[1]}\r\n'.format( self.method, self.path, self.version) def autochunked(self): return (self.length is None and self._version >= HttpVersion11 and self.status not in (304, 204)) aiohttp-1.2.0/aiohttp/wsgi.py0000664000175000017500000001667613025134363017041 0ustar travistravis00000000000000"""wsgi server. TODO: * proxy protocol * x-forward security * wsgi file support (os.sendfile) """ import asyncio import inspect import io import os import socket import sys from urllib.parse import urlsplit import aiohttp from aiohttp import hdrs, server __all__ = ('WSGIServerHttpProtocol',) class WSGIServerHttpProtocol(server.ServerHttpProtocol): """HTTP Server that implements the Python WSGI protocol. It uses 'wsgi.async' of 'True'. 'wsgi.input' can behave differently depends on 'readpayload' constructor parameter. If readpayload is set to True, wsgi server reads all incoming data into BytesIO object and sends it as 'wsgi.input' environ var. If readpayload is set to false 'wsgi.input' is a StreamReader and application should read incoming data with "yield from environ['wsgi.input'].read()". It defaults to False. """ SCRIPT_NAME = os.environ.get('SCRIPT_NAME', '') def __init__(self, app, readpayload=False, is_ssl=False, *args, **kw): super().__init__(*args, **kw) self.wsgi = app self.is_ssl = is_ssl self.readpayload = readpayload def create_wsgi_response(self, message): return WsgiResponse(self.writer, message) def create_wsgi_environ(self, message, payload): uri_parts = urlsplit(message.path) environ = { 'wsgi.input': payload, 'wsgi.errors': sys.stderr, 'wsgi.version': (1, 0), 'wsgi.async': True, 'wsgi.multithread': False, 'wsgi.multiprocess': False, 'wsgi.run_once': False, 'wsgi.file_wrapper': FileWrapper, 'SERVER_SOFTWARE': aiohttp.HttpMessage.SERVER_SOFTWARE, 'REQUEST_METHOD': message.method, 'QUERY_STRING': uri_parts.query or '', 'RAW_URI': message.path, 'SERVER_PROTOCOL': 'HTTP/%s.%s' % message.version } script_name = self.SCRIPT_NAME for hdr_name, hdr_value in message.headers.items(): hdr_name = hdr_name.upper() if hdr_name == 'SCRIPT_NAME': script_name = hdr_value elif hdr_name == 'CONTENT-TYPE': environ['CONTENT_TYPE'] = hdr_value continue elif hdr_name == 'CONTENT-LENGTH': environ['CONTENT_LENGTH'] = hdr_value continue key = 'HTTP_%s' % hdr_name.replace('-', '_') if key in environ: hdr_value = '%s,%s' % (environ[key], hdr_value) environ[key] = hdr_value url_scheme = environ.get('HTTP_X_FORWARDED_PROTO') if url_scheme is None: url_scheme = 'https' if self.is_ssl else 'http' environ['wsgi.url_scheme'] = url_scheme # authors should be aware that REMOTE_HOST and REMOTE_ADDR # may not qualify the remote addr # also SERVER_PORT variable MUST be set to the TCP/IP port number on # which this request is received from the client. # http://www.ietf.org/rfc/rfc3875 family = self.transport.get_extra_info('socket').family if family in (socket.AF_INET, socket.AF_INET6): peername = self.transport.get_extra_info('peername') environ['REMOTE_ADDR'] = peername[0] environ['REMOTE_PORT'] = str(peername[1]) http_host = message.headers.get("HOST", None) if http_host: hostport = http_host.split(":") environ['SERVER_NAME'] = hostport[0] if len(hostport) > 1: environ['SERVER_PORT'] = str(hostport[1]) else: environ['SERVER_PORT'] = '80' else: # SERVER_NAME should be set to value of Host header, but this # header is not required. In this case we shoud set it to local # address of socket sockname = self.transport.get_extra_info('sockname') environ['SERVER_NAME'] = sockname[0] environ['SERVER_PORT'] = str(sockname[1]) else: # We are behind reverse proxy, so get all vars from headers for header in ('REMOTE_ADDR', 'REMOTE_PORT', 'SERVER_NAME', 'SERVER_PORT'): environ[header] = message.headers.get(header, '') path_info = uri_parts.path if script_name: path_info = path_info.split(script_name, 1)[-1] environ['PATH_INFO'] = path_info environ['SCRIPT_NAME'] = script_name environ['async.reader'] = self.reader environ['async.writer'] = self.writer return environ @asyncio.coroutine def handle_request(self, message, payload): """Handle a single HTTP request""" now = self._loop.time() if self.readpayload: wsgiinput = io.BytesIO() wsgiinput.write((yield from payload.read())) wsgiinput.seek(0) payload = wsgiinput environ = self.create_wsgi_environ(message, payload) response = self.create_wsgi_response(message) riter = self.wsgi(environ, response.start_response) if isinstance(riter, asyncio.Future) or inspect.isgenerator(riter): riter = yield from riter resp = response.response try: for item in riter: if isinstance(item, asyncio.Future): item = yield from item yield from resp.write(item) yield from resp.write_eof() finally: if hasattr(riter, 'close'): riter.close() if resp.keep_alive(): self.keep_alive(True) self.log_access( message, environ, response.response, self._loop.time() - now) class FileWrapper: """Custom file wrapper.""" def __init__(self, fobj, chunk_size=8192): self.fobj = fobj self.chunk_size = chunk_size if hasattr(fobj, 'close'): self.close = fobj.close def __iter__(self): return self def __next__(self): data = self.fobj.read(self.chunk_size) if data: return data raise StopIteration class WsgiResponse: """Implementation of start_response() callable as specified by PEP 3333""" status = None HOP_HEADERS = { hdrs.CONNECTION, hdrs.KEEP_ALIVE, hdrs.PROXY_AUTHENTICATE, hdrs.PROXY_AUTHORIZATION, hdrs.TE, hdrs.TRAILER, hdrs.TRANSFER_ENCODING, hdrs.UPGRADE, } def __init__(self, writer, message): self.writer = writer self.message = message def start_response(self, status, headers, exc_info=None): if exc_info: try: if self.status: raise exc_info[1] finally: exc_info = None status_code = int(status.split(' ', 1)[0]) self.status = status resp = self.response = aiohttp.Response( self.writer, status_code, self.message.version, self.message.should_close) resp.HOP_HEADERS = self.HOP_HEADERS for name, value in headers: resp.add_header(name, value) if resp.has_chunked_hdr: resp.enable_chunked_encoding() # send headers immediately for websocket connection if status_code == 101 and resp.upgrade and resp.websocket: resp.send_headers() else: resp._send_headers = True return self.response.write aiohttp-1.2.0/aiohttp/abc.py0000664000175000017500000000576313025134363016610 0ustar travistravis00000000000000import asyncio import sys from abc import ABC, abstractmethod from collections.abc import Iterable, Sized PY_35 = sys.version_info >= (3, 5) class AbstractRouter(ABC): def __init__(self): self._frozen = False def post_init(self, app): """Post init stage. It's not an abstract method for sake of backward compatibility but if router wans to be aware about application it should override it. """ @property def frozen(self): return self._frozen def freeze(self): """Freeze router.""" self._frozen = True @asyncio.coroutine # pragma: no branch @abstractmethod def resolve(self, request): """Return MATCH_INFO for given request""" class AbstractMatchInfo(ABC): @asyncio.coroutine # pragma: no branch @abstractmethod def handler(self, request): """Execute matched request handler""" @asyncio.coroutine # pragma: no branch @abstractmethod def expect_handler(self, request): """Expect handler for 100-continue processing""" @property # pragma: no branch @abstractmethod def http_exception(self): """HTTPException instance raised on router's resolving, or None""" @abstractmethod # pragma: no branch def get_info(self): """Return a dict with additional info useful for introspection""" @property # pragma: no branch @abstractmethod def apps(self): """Stack of nested applications. Top level application is left-most element. """ @abstractmethod def add_app(self, app): """Add application to the nested apps stack.""" @abstractmethod def freeze(self): """Freeze the match info. The method is called after route resolution. After the call .add_app() is forbidden. """ class AbstractView(ABC): def __init__(self, request): self._request = request @property def request(self): return self._request @asyncio.coroutine # pragma: no branch @abstractmethod def __iter__(self): while False: # pragma: no cover yield None if PY_35: # pragma: no branch @abstractmethod def __await__(self): return # pragma: no cover class AbstractResolver(ABC): @asyncio.coroutine # pragma: no branch @abstractmethod def resolve(self, hostname): """Return IP address for given hostname""" @asyncio.coroutine # pragma: no branch @abstractmethod def close(self): """Release resolver""" class AbstractCookieJar(Sized, Iterable): def __init__(self, *, loop=None): self._loop = loop or asyncio.get_event_loop() @abstractmethod def clear(self): """Clear all cookies.""" @abstractmethod def update_cookies(self, cookies, response_url=None): """Update cookies.""" @abstractmethod def filter_cookies(self, request_url): """Return the jar's cookies filtered by their attributes.""" aiohttp-1.2.0/aiohttp/parsers.py0000664000175000017500000003466113025134363017541 0ustar travistravis00000000000000"""Parser is a generator function (NOT coroutine). Parser receives data with generator's send() method and sends data to destination DataQueue. Parser receives ParserBuffer and DataQueue objects as a parameters of the parser call, all subsequent send() calls should send bytes objects. Parser sends parsed `term` to destination buffer with DataQueue.feed_data() method. DataQueue object should implement two methods. feed_data() - parser uses this method to send parsed protocol data. feed_eof() - parser uses this method for indication of end of parsing stream. To indicate end of incoming data stream EofStream exception should be sent into parser. Parser could throw exceptions. There are three stages: * Data flow chain: 1. Application creates StreamParser object for storing incoming data. 2. StreamParser creates ParserBuffer as internal data buffer. 3. Application create parser and set it into stream buffer: parser = HttpRequestParser() data_queue = stream.set_parser(parser) 3. At this stage StreamParser creates DataQueue object and passes it and internal buffer into parser as an arguments. def set_parser(self, parser): output = DataQueue() self.p = parser(output, self._input) return output 4. Application waits data on output.read() while True: msg = yield from output.read() ... * Data flow: 1. asyncio's transport reads data from socket and sends data to protocol with data_received() call. 2. Protocol sends data to StreamParser with feed_data() call. 3. StreamParser sends data into parser with generator's send() method. 4. Parser processes incoming data and sends parsed data to DataQueue with feed_data() 5. Application received parsed data from DataQueue.read() * Eof: 1. StreamParser receives eof with feed_eof() call. 2. StreamParser throws EofStream exception into parser. 3. Then it unsets parser. _SocketSocketTransport -> -> "protocol" -> StreamParser -> "parser" -> DataQueue <- "application" """ import asyncio import asyncio.streams import socket from . import errors from .streams import EofStream, FlowControlDataQueue __all__ = ('EofStream', 'StreamParser', 'StreamProtocol', 'ParserBuffer', 'StreamWriter') DEFAULT_LIMIT = 2 ** 16 if hasattr(socket, 'TCP_CORK'): # pragma: no cover CORK = socket.TCP_CORK elif hasattr(socket, 'TCP_NOPUSH'): # pragma: no cover CORK = socket.TCP_NOPUSH else: # pragma: no cover CORK = None class StreamParser: """StreamParser manages incoming bytes stream and protocol parsers. StreamParser uses ParserBuffer as internal buffer. set_parser() sets current parser, it creates DataQueue object and sends ParserBuffer and DataQueue into parser generator. unset_parser() sends EofStream into parser and then removes it. """ def __init__(self, *, loop=None, buf=None, limit=DEFAULT_LIMIT, eof_exc_class=RuntimeError): self._loop = loop self._eof = False self._exception = None self._parser = None self._output = None self._limit = limit self._eof_exc_class = eof_exc_class self._buffer = buf if buf is not None else ParserBuffer() self.paused = False self.transport = None @property def output(self): return self._output def set_transport(self, transport): assert transport is None or self.transport is None, \ 'Transport already set' self.transport = transport def at_eof(self): return self._eof def exception(self): return self._exception def set_exception(self, exc): if isinstance(exc, ConnectionError): exc, old_exc = self._eof_exc_class(), exc exc.__cause__ = old_exc exc.__context__ = old_exc self._exception = exc if self._output is not None: self._output.set_exception(exc) self._output = None self._parser = None def feed_data(self, data): """send data to current parser or store in buffer.""" if data is None: return if self._parser: try: self._parser.send(data) except StopIteration: self._output.feed_eof() self._output = None self._parser = None except Exception as exc: self._output.set_exception(exc) self._output = None self._parser = None else: self._buffer.feed_data(data) def feed_eof(self): """send eof to all parsers, recursively.""" if self._parser: try: if self._buffer: self._parser.send(b'') self._parser.throw(EofStream()) except StopIteration: self._output.feed_eof() except EofStream: self._output.set_exception(self._eof_exc_class()) except Exception as exc: self._output.set_exception(exc) self._parser = None self._output = None self._eof = True def set_parser(self, parser, output=None): """set parser to stream. return parser's DataQueue.""" if self._parser: self.unset_parser() if output is None: output = FlowControlDataQueue( self, limit=self._limit, loop=self._loop) if self._exception: output.set_exception(self._exception) return output # init parser p = parser(output, self._buffer) try: # initialize parser with data and parser buffers next(p) except StopIteration: pass except Exception as exc: output.set_exception(exc) else: # parser still require more data self._parser = p self._output = output if self._eof: self.unset_parser() return output def unset_parser(self): """unset parser, send eof to the parser and then remove it.""" if self._parser is None: return # TODO: write test if self._loop.is_closed(): # TODO: log something return try: self._parser.throw(EofStream()) except StopIteration: self._output.feed_eof() except EofStream: self._output.set_exception(self._eof_exc_class()) except Exception as exc: self._output.set_exception(exc) finally: self._output = None self._parser = None class StreamWriter(asyncio.streams.StreamWriter): def __init__(self, transport, protocol, reader, loop): self._transport = transport self._protocol = protocol self._reader = reader self._loop = loop self._tcp_nodelay = False self._tcp_cork = False self._socket = transport.get_extra_info('socket') @property def tcp_nodelay(self): return self._tcp_nodelay def set_tcp_nodelay(self, value): value = bool(value) if self._tcp_nodelay == value: return self._tcp_nodelay = value if self._socket is None: return if self._socket.family not in (socket.AF_INET, socket.AF_INET6): return if self._tcp_cork: self._tcp_cork = False if CORK is not None: # pragma: no branch self._socket.setsockopt(socket.IPPROTO_TCP, CORK, False) self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, value) @property def tcp_cork(self): return self._tcp_cork def set_tcp_cork(self, value): value = bool(value) if self._tcp_cork == value: return self._tcp_cork = value if self._socket is None: return if self._socket.family not in (socket.AF_INET, socket.AF_INET6): return if self._tcp_nodelay: self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, False) self._tcp_nodelay = False if CORK is not None: # pragma: no branch self._socket.setsockopt(socket.IPPROTO_TCP, CORK, value) class StreamProtocol(asyncio.streams.FlowControlMixin, asyncio.Protocol): """Helper class to adapt between Protocol and StreamReader.""" def __init__(self, *, loop=None, disconnect_error=RuntimeError, **kwargs): super().__init__(loop=loop) self.transport = None self.writer = None self.reader = StreamParser( loop=loop, eof_exc_class=disconnect_error, **kwargs) def is_connected(self): return self.transport is not None def connection_made(self, transport): self.transport = transport self.reader.set_transport(transport) self.writer = StreamWriter(transport, self, self.reader, self._loop) def connection_lost(self, exc): self.transport = self.writer = None self.reader.set_transport(None) if exc is None: self.reader.feed_eof() else: self.reader.set_exception(exc) super().connection_lost(exc) def data_received(self, data): self.reader.feed_data(data) def eof_received(self): self.reader.feed_eof() class _ParserBufferHelper: __slots__ = ('exception', 'data') def __init__(self, exception, data): self.exception = exception self.data = data class ParserBuffer: """ParserBuffer is NOT a bytearray extension anymore. ParserBuffer provides helper methods for parsers. """ __slots__ = ('_helper', '_writer', '_data') def __init__(self, *args): self._data = bytearray(*args) self._helper = _ParserBufferHelper(None, self._data) self._writer = self._feed_data(self._helper) next(self._writer) def exception(self): return self._helper.exception def set_exception(self, exc): self._helper.exception = exc @staticmethod def _feed_data(helper): while True: chunk = yield if chunk: helper.data.extend(chunk) if helper.exception: raise helper.exception def feed_data(self, data): if not self._helper.exception: self._writer.send(data) def read(self, size): """read() reads specified amount of bytes.""" while True: if self._helper.exception: raise self._helper.exception if len(self._data) >= size: data = self._data[:size] del self._data[:size] return data self._writer.send((yield)) def readsome(self, size=None): """reads size of less amount of bytes.""" while True: if self._helper.exception: raise self._helper.exception length = len(self._data) if length > 0: if size is None or length < size: size = length data = self._data[:size] del self._data[:size] return data self._writer.send((yield)) def readuntil(self, stop, limit=None): assert isinstance(stop, bytes) and stop, \ 'bytes is required: {!r}'.format(stop) stop_len = len(stop) while True: if self._helper.exception: raise self._helper.exception pos = self._data.find(stop) if pos >= 0: end = pos + stop_len size = end if limit is not None and size > limit: raise errors.LineLimitExceededParserError( 'Line is too long.', limit) data = self._data[:size] del self._data[:size] return data else: if limit is not None and len(self._data) > limit: raise errors.LineLimitExceededParserError( 'Line is too long.', limit) self._writer.send((yield)) def wait(self, size): """wait() waits for specified amount of bytes then returns data without changing internal buffer.""" while True: if self._helper.exception: raise self._helper.exception if len(self._data) >= size: return self._data[:size] self._writer.send((yield)) def waituntil(self, stop, limit=None): """waituntil() reads until `stop` bytes sequence.""" assert isinstance(stop, bytes) and stop, \ 'bytes is required: {!r}'.format(stop) stop_len = len(stop) while True: if self._helper.exception: raise self._helper.exception pos = self._data.find(stop) if pos >= 0: size = pos + stop_len if limit is not None and size > limit: raise errors.LineLimitExceededParserError( 'Line is too long. %s' % bytes(self._data), limit) return self._data[:size] else: if limit is not None and len(self._data) > limit: raise errors.LineLimitExceededParserError( 'Line is too long. %s' % bytes(self._data), limit) self._writer.send((yield)) def skip(self, size): """skip() skips specified amount of bytes.""" while len(self._data) < size: if self._helper.exception: raise self._helper.exception self._writer.send((yield)) del self._data[:size] def skipuntil(self, stop): """skipuntil() reads until `stop` bytes sequence.""" assert isinstance(stop, bytes) and stop, \ 'bytes is required: {!r}'.format(stop) stop_len = len(stop) while True: if self._helper.exception: raise self._helper.exception stop_line = self._data.find(stop) if stop_line >= 0: size = stop_line + stop_len del self._data[:size] return self._writer.send((yield)) def extend(self, data): self._data.extend(data) def __len__(self): return len(self._data) def __bytes__(self): return bytes(self._data) aiohttp-1.2.0/aiohttp/helpers.py0000664000175000017500000005201713025134363017517 0ustar travistravis00000000000000"""Various helper functions""" import asyncio import base64 import binascii import cgi import datetime import functools import io import os import re import warnings from collections import MutableSequence, namedtuple from functools import total_ordering from pathlib import Path from time import gmtime, time from urllib.parse import urlencode from async_timeout import timeout from multidict import MultiDict, MultiDictProxy from . import hdrs try: from asyncio import ensure_future except ImportError: ensure_future = asyncio.async __all__ = ('BasicAuth', 'create_future', 'FormData', 'parse_mimetype', 'Timeout', 'ensure_future') sentinel = object() Timeout = timeout class BasicAuth(namedtuple('BasicAuth', ['login', 'password', 'encoding'])): """Http basic authentication helper. :param str login: Login :param str password: Password :param str encoding: (optional) encoding ('latin1' by default) """ def __new__(cls, login, password='', encoding='latin1'): if login is None: raise ValueError('None is not allowed as login value') if password is None: raise ValueError('None is not allowed as password value') if ':' in login: raise ValueError( 'A ":" is not allowed in login (RFC 1945#section-11.1)') return super().__new__(cls, login, password, encoding) @classmethod def decode(cls, auth_header, encoding='latin1'): """Create a :class:`BasicAuth` object from an ``Authorization`` HTTP header.""" split = auth_header.strip().split(' ') if len(split) == 2: if split[0].strip().lower() != 'basic': raise ValueError('Unknown authorization method %s' % split[0]) to_decode = split[1] else: raise ValueError('Could not parse authorization header.') try: username, _, password = base64.b64decode( to_decode.encode('ascii') ).decode(encoding).partition(':') except binascii.Error: raise ValueError('Invalid base64 encoding.') return cls(username, password, encoding=encoding) def encode(self): """Encode credentials.""" creds = ('%s:%s' % (self.login, self.password)).encode(self.encoding) return 'Basic %s' % base64.b64encode(creds).decode(self.encoding) def create_future(loop): """Compatibility wrapper for the loop.create_future() call introduced in 3.5.2.""" if hasattr(loop, 'create_future'): return loop.create_future() else: return asyncio.Future(loop=loop) class FormData: """Helper class for multipart/form-data and application/x-www-form-urlencoded body generation.""" def __init__(self, fields=()): from . import multipart self._writer = multipart.MultipartWriter('form-data') self._fields = [] self._is_multipart = False if isinstance(fields, dict): fields = list(fields.items()) elif not isinstance(fields, (list, tuple)): fields = (fields,) self.add_fields(*fields) @property def is_multipart(self): return self._is_multipart @property def content_type(self): if self._is_multipart: return self._writer.headers[hdrs.CONTENT_TYPE] else: return 'application/x-www-form-urlencoded' def add_field(self, name, value, *, content_type=None, filename=None, content_transfer_encoding=None): if isinstance(value, io.IOBase): self._is_multipart = True elif isinstance(value, (bytes, bytearray, memoryview)): if filename is None and content_transfer_encoding is None: filename = name type_options = MultiDict({'name': name}) if filename is not None and not isinstance(filename, str): raise TypeError('filename must be an instance of str. ' 'Got: %s' % filename) if filename is None and isinstance(value, io.IOBase): filename = guess_filename(value, name) if filename is not None: type_options['filename'] = filename self._is_multipart = True headers = {} if content_type is not None: if not isinstance(content_type, str): raise TypeError('content_type must be an instance of str. ' 'Got: %s' % content_type) headers[hdrs.CONTENT_TYPE] = content_type self._is_multipart = True if content_transfer_encoding is not None: if not isinstance(content_transfer_encoding, str): raise TypeError('content_transfer_encoding must be an instance' ' of str. Got: %s' % content_transfer_encoding) headers[hdrs.CONTENT_TRANSFER_ENCODING] = content_transfer_encoding self._is_multipart = True self._fields.append((type_options, headers, value)) def add_fields(self, *fields): to_add = list(fields) while to_add: rec = to_add.pop(0) if isinstance(rec, io.IOBase): k = guess_filename(rec, 'unknown') self.add_field(k, rec) elif isinstance(rec, (MultiDictProxy, MultiDict)): to_add.extend(rec.items()) elif isinstance(rec, (list, tuple)) and len(rec) == 2: k, fp = rec self.add_field(k, fp) else: raise TypeError('Only io.IOBase, multidict and (name, file) ' 'pairs allowed, use .add_field() for passing ' 'more complex parameters, got {!r}' .format(rec)) def _gen_form_urlencoded(self, encoding): # form data (x-www-form-urlencoded) data = [] for type_options, _, value in self._fields: data.append((type_options['name'], value)) data = urlencode(data, doseq=True) return data.encode(encoding) def _gen_form_data(self, *args, **kwargs): """Encode a list of fields using the multipart/form-data MIME format""" for dispparams, headers, value in self._fields: part = self._writer.append(value, headers) if dispparams: part.set_content_disposition('form-data', **dispparams) # FIXME cgi.FieldStorage doesn't likes body parts with # Content-Length which were sent via chunked transfer encoding part.headers.pop(hdrs.CONTENT_LENGTH, None) yield from self._writer.serialize() def __call__(self, encoding): if self._is_multipart: return self._gen_form_data(encoding) else: return self._gen_form_urlencoded(encoding) def parse_mimetype(mimetype): """Parses a MIME type into its components. :param str mimetype: MIME type :returns: 4 element tuple for MIME type, subtype, suffix and parameters :rtype: tuple Example: >>> parse_mimetype('text/html; charset=utf-8') ('text', 'html', '', {'charset': 'utf-8'}) """ if not mimetype: return '', '', '', {} parts = mimetype.split(';') params = [] for item in parts[1:]: if not item: continue key, value = item.split('=', 1) if '=' in item else (item, '') params.append((key.lower().strip(), value.strip(' "'))) params = dict(params) fulltype = parts[0].strip().lower() if fulltype == '*': fulltype = '*/*' mtype, stype = fulltype.split('/', 1) \ if '/' in fulltype else (fulltype, '') stype, suffix = stype.split('+', 1) if '+' in stype else (stype, '') return mtype, stype, suffix, params def guess_filename(obj, default=None): name = getattr(obj, 'name', None) if name and name[0] != '<' and name[-1] != '>': return Path(name).name return default class AccessLogger: """Helper object to log access. Usage: log = logging.getLogger("spam") log_format = "%a %{User-Agent}i" access_logger = AccessLogger(log, log_format) access_logger.log(message, environ, response, transport, time) Format: %% The percent sign %a Remote IP-address (IP-address of proxy if using reverse proxy) %t Time when the request was started to process %P The process ID of the child that serviced the request %r First line of request %s Response status code %b Size of response in bytes, excluding HTTP headers %O Bytes sent, including headers %T Time taken to serve the request, in seconds %Tf Time taken to serve the request, in seconds with floating fraction in .06f format %D Time taken to serve the request, in microseconds %{FOO}i request.headers['FOO'] %{FOO}o response.headers['FOO'] %{FOO}e os.environ['FOO'] """ LOG_FORMAT_MAP = { 'a': 'remote_address', 't': 'request_time', 'P': 'process_id', 'r': 'first_request_line', 's': 'response_status', 'b': 'response_size', 'O': 'bytes_sent', 'T': 'request_time', 'Tf': 'request_time_frac', 'D': 'request_time_micro', 'i': 'request_header', 'o': 'response_header', 'e': 'environ' } LOG_FORMAT = '%a %l %u %t "%r" %s %b "%{Referrer}i" "%{User-Agent}i"' FORMAT_RE = re.compile(r'%(\{([A-Za-z0-9\-_]+)\}([ioe])|[atPrsbOD]|Tf?)') CLEANUP_RE = re.compile(r'(%[^s])') _FORMAT_CACHE = {} KeyMethod = namedtuple('KeyMethod', 'key method') def __init__(self, logger, log_format=LOG_FORMAT): """Initialise the logger. :param logger: logger object to be used for logging :param log_format: apache compatible log format """ self.logger = logger _compiled_format = AccessLogger._FORMAT_CACHE.get(log_format) if not _compiled_format: _compiled_format = self.compile_format(log_format) AccessLogger._FORMAT_CACHE[log_format] = _compiled_format self._log_format, self._methods = _compiled_format def compile_format(self, log_format): """Translate log_format into form usable by modulo formatting All known atoms will be replaced with %s Also methods for formatting of those atoms will be added to _methods in apropriate order For example we have log_format = "%a %t" This format will be translated to "%s %s" Also contents of _methods will be [self._format_a, self._format_t] These method will be called and results will be passed to translated string format. Each _format_* method receive 'args' which is list of arguments given to self.log Exceptions are _format_e, _format_i and _format_o methods which also receive key name (by functools.partial) """ log_format = log_format.replace("%l", "-") log_format = log_format.replace("%u", "-") # list of (key, method) tuples, we don't use an OrderedDict as users # can repeat the same key more than once methods = list() for atom in self.FORMAT_RE.findall(log_format): if atom[1] == '': format_key = self.LOG_FORMAT_MAP[atom[0]] m = getattr(AccessLogger, '_format_%s' % atom[0]) else: format_key = (self.LOG_FORMAT_MAP[atom[2]], atom[1]) m = getattr(AccessLogger, '_format_%s' % atom[2]) m = functools.partial(m, atom[1]) methods.append(self.KeyMethod(format_key, m)) log_format = self.FORMAT_RE.sub(r'%s', log_format) log_format = self.CLEANUP_RE.sub(r'%\1', log_format) return log_format, methods @staticmethod def _format_e(key, args): return (args[1] or {}).get(key, '-') @staticmethod def _format_i(key, args): if not args[0]: return '(no headers)' # suboptimal, make istr(key) once return args[0].headers.get(key, '-') @staticmethod def _format_o(key, args): # suboptimal, make istr(key) once return args[2].headers.get(key, '-') @staticmethod def _format_a(args): if args[3] is None: return '-' peername = args[3].get_extra_info('peername') if isinstance(peername, (list, tuple)): return peername[0] else: return peername @staticmethod def _format_t(args): return datetime.datetime.utcnow().strftime('[%d/%b/%Y:%H:%M:%S +0000]') @staticmethod def _format_P(args): return "<%s>" % os.getpid() @staticmethod def _format_r(args): msg = args[0] if not msg: return '-' return '%s %s HTTP/%s.%s' % tuple((msg.method, msg.path) + msg.version) @staticmethod def _format_s(args): return args[2].status @staticmethod def _format_b(args): return args[2].body_length @staticmethod def _format_O(args): return args[2].output_length @staticmethod def _format_T(args): return round(args[4]) @staticmethod def _format_Tf(args): return '%06f' % args[4] @staticmethod def _format_D(args): return round(args[4] * 1000000) def _format_line(self, args): return ((key, method(args)) for key, method in self._methods) def log(self, message, environ, response, transport, time): """Log access. :param message: Request object. May be None. :param environ: Environment dict. May be None. :param response: Response object. :param transport: Tansport object. May be None :param float time: Time taken to serve the request. """ try: fmt_info = self._format_line( [message, environ, response, transport, time]) values = list() extra = dict() for key, value in fmt_info: values.append(value) if key.__class__ is str: extra[key] = value else: extra[key[0]] = {key[1]: value} self.logger.info(self._log_format % tuple(values), extra=extra) except Exception: self.logger.exception("Error in logging") class reify: """Use as a class method decorator. It operates almost exactly like the Python `@property` decorator, but it puts the result of the method it decorates into the instance dict after the first call, effectively replacing the function it decorates with an instance variable. It is, in Python parlance, a data descriptor. """ def __init__(self, wrapped): self.wrapped = wrapped try: self.__doc__ = wrapped.__doc__ except: # pragma: no cover self.__doc__ = "" self.name = wrapped.__name__ def __get__(self, inst, owner, _sentinel=sentinel): if inst is None: return self val = inst._cache.get(self.name, _sentinel) if val is not _sentinel: return val val = self.wrapped(inst) inst._cache[self.name] = val return val def __set__(self, inst, value): raise AttributeError("reified property is read-only") _ipv4_pattern = ('^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}' '(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$') _ipv6_pattern = ( '^(?:(?:(?:[A-F0-9]{1,4}:){6}|(?=(?:[A-F0-9]{0,4}:){0,6}' '(?:[0-9]{1,3}\.){3}[0-9]{1,3}$)(([0-9A-F]{1,4}:){0,5}|:)' '((:[0-9A-F]{1,4}){1,5}:|:)|::(?:[A-F0-9]{1,4}:){5})' '(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.){3}' '(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])|(?:[A-F0-9]{1,4}:){7}' '[A-F0-9]{1,4}|(?=(?:[A-F0-9]{0,4}:){0,7}[A-F0-9]{0,4}$)' '(([0-9A-F]{1,4}:){1,7}|:)((:[0-9A-F]{1,4}){1,7}|:)|(?:[A-F0-9]{1,4}:){7}' ':|:(:[A-F0-9]{1,4}){7})$') _ipv4_regex = re.compile(_ipv4_pattern) _ipv6_regex = re.compile(_ipv6_pattern, flags=re.IGNORECASE) _ipv4_regexb = re.compile(_ipv4_pattern.encode('ascii')) _ipv6_regexb = re.compile(_ipv6_pattern.encode('ascii'), flags=re.IGNORECASE) def is_ip_address(host): if host is None: return False if isinstance(host, str): if _ipv4_regex.match(host) or _ipv6_regex.match(host): return True else: return False elif isinstance(host, (bytes, bytearray, memoryview)): if _ipv4_regexb.match(host) or _ipv6_regexb.match(host): return True else: return False else: raise TypeError("{} [{}] is not a str or bytes" .format(host, type(host))) def _get_kwarg(kwargs, old, new, value): val = kwargs.pop(old, sentinel) if val is not sentinel: warnings.warn("{} is deprecated, use {} instead".format(old, new), DeprecationWarning, stacklevel=3) return val else: return value @total_ordering class FrozenList(MutableSequence): __slots__ = ('_frozen', '_items') def __init__(self, items=None): self._frozen = False if items is not None: items = list(items) else: items = [] self._items = items def freeze(self): self._frozen = True def __getitem__(self, index): return self._items[index] def __setitem__(self, index, value): if self._frozen: raise RuntimeError("Cannot modify frozen list.") self._items[index] = value def __delitem__(self, index): if self._frozen: raise RuntimeError("Cannot modify frozen list.") del self._items[index] def __len__(self): return self._items.__len__() def __iter__(self): return self._items.__iter__() def __reversed__(self): return self._items.__reversed__() def __eq__(self, other): return list(self) == other def __le__(self, other): return list(self) <= other def insert(self, pos, item): if self._frozen: raise RuntimeError("Cannot modify frozen list.") self._items.insert(pos, item) class TimeService: def __init__(self, loop): self._loop = loop self._time = time() self._strtime = None self._count = 0 self._cb = loop.call_later(1, self._on_cb) def stop(self): if self._cb: self._cb.cancel() self._cb = None self._loop = None def _on_cb(self): self._count += 1 if self._count >= 10*60: # reset timer every 10 minutes self._count = 0 self._time = time() else: self._time += 1 self._strtime = None self._cb = self._loop.call_later(1, self._on_cb) def _format_date_time(self): # Weekday and month names for HTTP date/time formatting; # always English! # Tuples are contants stored in codeobject! _weekdayname = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun") _monthname = (None, # Dummy so we can use 1-based month numbers "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec") year, month, day, hh, mm, ss, wd, y, z = gmtime(self._time) return "%s, %02d %3s %4d %02d:%02d:%02d GMT" % ( _weekdayname[wd], day, _monthname[month], year, hh, mm, ss ) def time(self): return self._time def strtime(self): s = self._strtime if s is None: self._strtime = s = self._format_date_time() return self._strtime class HeadersMixin: _content_type = None _content_dict = None _stored_content_type = sentinel def _parse_content_type(self, raw): self._stored_content_type = raw if raw is None: # default value according to RFC 2616 self._content_type = 'application/octet-stream' self._content_dict = {} else: self._content_type, self._content_dict = cgi.parse_header(raw) @property def content_type(self, *, _CONTENT_TYPE=hdrs.CONTENT_TYPE): """The value of content part for Content-Type HTTP header.""" raw = self.headers.get(_CONTENT_TYPE) if self._stored_content_type != raw: self._parse_content_type(raw) return self._content_type @property def charset(self, *, _CONTENT_TYPE=hdrs.CONTENT_TYPE): """The value of charset part for Content-Type HTTP header.""" raw = self.headers.get(_CONTENT_TYPE) if self._stored_content_type != raw: self._parse_content_type(raw) return self._content_dict.get('charset') @property def content_length(self, *, _CONTENT_LENGTH=hdrs.CONTENT_LENGTH): """The value of Content-Length HTTP header.""" l = self.headers.get(_CONTENT_LENGTH) if l is None: return None else: return int(l) def check_loop(loop): if loop is None: loop = asyncio.get_event_loop() aiohttp-1.2.0/aiohttp/_websocket.c0000664000175000017500000030022013025135427017766 0ustar travistravis00000000000000/* Generated by Cython 0.25.2 */ /* BEGIN: Cython Metadata { "distutils": { "depends": [] }, "module_name": "aiohttp._websocket" } END: Cython Metadata */ #define PY_SSIZE_T_CLEAN #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) #error Cython requires Python 2.6+ or Python 3.2+. #else #define CYTHON_ABI "0_25_2" #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x03030000 || (PY_MAJOR_VERSION == 2 && PY_VERSION_HEX >= 0x02070000) #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" #undef SHIFT #undef BASE #undef MASK #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t PyInt_AsLong #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if defined(WIN32) || defined(MS_WINDOWS) #define _USE_MATH_DEFINES #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_ERR(f_index, lineno, Ln_error) \ { \ __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ } #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__aiohttp___websocket #define __PYX_HAVE_API__aiohttp___websocket #include #include #include "pythread.h" #include #ifdef _OPENMP #include #endif /* _OPENMP */ #ifdef PYREX_WITHOUT_ASSERTIONS #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) && defined (_M_X64) #define __Pyx_sst_abs(value) _abs64(value) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) #if PY_MAJOR_VERSION < 3 static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #else #define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen #endif #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) #define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static PyObject *__pyx_m; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; static const char *__pyx_f[] = { "aiohttp/_websocket.pyx", "type.pxd", "bool.pxd", "complex.pxd", }; /*--- Type declarations ---*/ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* ArgTypeTest.proto */ static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, const char *name, int exact); /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* PyIdentifierFromString.proto */ #if !defined(__Pyx_PyIdentifier_FromString) #if PY_MAJOR_VERSION < 3 #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s) #else #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s) #endif #endif /* ModuleImport.proto */ static PyObject *__Pyx_ImportModule(const char *name); /* TypeImport.proto */ static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* Module declarations from 'cpython.version' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.type' */ static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; /* Module declarations from 'libc.string' */ /* Module declarations from 'libc.stdio' */ /* Module declarations from 'cpython.object' */ /* Module declarations from 'cpython.ref' */ /* Module declarations from 'cpython.exc' */ /* Module declarations from 'cpython.module' */ /* Module declarations from 'cpython.mem' */ /* Module declarations from 'cpython.tuple' */ /* Module declarations from 'cpython.list' */ /* Module declarations from 'cpython.sequence' */ /* Module declarations from 'cpython.mapping' */ /* Module declarations from 'cpython.iterator' */ /* Module declarations from 'cpython.number' */ /* Module declarations from 'cpython.int' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.bool' */ static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0; /* Module declarations from 'cpython.long' */ /* Module declarations from 'cpython.float' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.complex' */ static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0; /* Module declarations from 'cpython.string' */ /* Module declarations from 'cpython.unicode' */ /* Module declarations from 'cpython.dict' */ /* Module declarations from 'cpython.instance' */ /* Module declarations from 'cpython.function' */ /* Module declarations from 'cpython.method' */ /* Module declarations from 'cpython.weakref' */ /* Module declarations from 'cpython.getargs' */ /* Module declarations from 'cpython.pythread' */ /* Module declarations from 'cpython.pystate' */ /* Module declarations from 'cpython.cobject' */ /* Module declarations from 'cpython.oldbuffer' */ /* Module declarations from 'cpython.set' */ /* Module declarations from 'cpython.buffer' */ /* Module declarations from 'cpython.bytes' */ /* Module declarations from 'cpython.pycapsule' */ /* Module declarations from 'cpython' */ /* Module declarations from 'libc.stdint' */ /* Module declarations from 'aiohttp._websocket' */ #define __Pyx_MODULE_NAME "aiohttp._websocket" int __pyx_module_is_main_aiohttp___websocket = 0; /* Implementation of 'aiohttp._websocket' */ static PyObject *__pyx_builtin_range; static const char __pyx_k_i[] = "i"; static const char __pyx_k_data[] = "data"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_mask[] = "mask"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_in_buf[] = "in_buf"; static const char __pyx_k_data_len[] = "data_len"; static const char __pyx_k_mask_buf[] = "mask_buf"; static const char __pyx_k_uint32_msk[] = "uint32_msk"; static const char __pyx_k_uint64_msk[] = "uint64_msk"; static const char __pyx_k_aiohttp__websocket[] = "aiohttp._websocket"; static const char __pyx_k_websocket_mask_cython[] = "_websocket_mask_cython"; static const char __pyx_k_home_travis_build_KeepSafe_aioh[] = "/home/travis/build/KeepSafe/aiohttp/aiohttp/_websocket.pyx"; static PyObject *__pyx_n_s_aiohttp__websocket; static PyObject *__pyx_n_s_data; static PyObject *__pyx_n_s_data_len; static PyObject *__pyx_kp_s_home_travis_build_KeepSafe_aioh; static PyObject *__pyx_n_s_i; static PyObject *__pyx_n_s_in_buf; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_mask; static PyObject *__pyx_n_s_mask_buf; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_uint32_msk; static PyObject *__pyx_n_s_uint64_msk; static PyObject *__pyx_n_s_websocket_mask_cython; static PyObject *__pyx_pf_7aiohttp_10_websocket__websocket_mask_cython(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_mask, PyObject *__pyx_v_data); /* proto */ static PyObject *__pyx_tuple_; static PyObject *__pyx_codeobj__2; /* "aiohttp/_websocket.pyx":9 * from libc.stdint cimport uint32_t, uint64_t, uintmax_t * * def _websocket_mask_cython(bytes mask, bytearray data): # <<<<<<<<<<<<<< * """Note, this function mutates it's `data` argument * """ */ /* Python wrapper */ static PyObject *__pyx_pw_7aiohttp_10_websocket_1_websocket_mask_cython(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7aiohttp_10_websocket__websocket_mask_cython[] = "Note, this function mutates it's `data` argument\n "; static PyMethodDef __pyx_mdef_7aiohttp_10_websocket_1_websocket_mask_cython = {"_websocket_mask_cython", (PyCFunction)__pyx_pw_7aiohttp_10_websocket_1_websocket_mask_cython, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7aiohttp_10_websocket__websocket_mask_cython}; static PyObject *__pyx_pw_7aiohttp_10_websocket_1_websocket_mask_cython(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_mask = 0; PyObject *__pyx_v_data = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_websocket_mask_cython (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_mask,&__pyx_n_s_data,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mask)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_data)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_websocket_mask_cython", 1, 2, 2, 1); __PYX_ERR(0, 9, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_websocket_mask_cython") < 0)) __PYX_ERR(0, 9, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_mask = ((PyObject*)values[0]); __pyx_v_data = ((PyObject*)values[1]); } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_websocket_mask_cython", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 9, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("aiohttp._websocket._websocket_mask_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_mask), (&PyBytes_Type), 1, "mask", 1))) __PYX_ERR(0, 9, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_data), (&PyByteArray_Type), 1, "data", 1))) __PYX_ERR(0, 9, __pyx_L1_error) __pyx_r = __pyx_pf_7aiohttp_10_websocket__websocket_mask_cython(__pyx_self, __pyx_v_mask, __pyx_v_data); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7aiohttp_10_websocket__websocket_mask_cython(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_mask, PyObject *__pyx_v_data) { Py_ssize_t __pyx_v_data_len; Py_ssize_t __pyx_v_i; unsigned char *__pyx_v_in_buf; unsigned char const *__pyx_v_mask_buf; uint32_t __pyx_v_uint32_msk; uint64_t __pyx_v_uint64_msk; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; char *__pyx_t_2; int __pyx_t_3; uint64_t *__pyx_t_4; long __pyx_t_5; uint32_t *__pyx_t_6; Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; __Pyx_RefNannySetupContext("_websocket_mask_cython", 0); /* "aiohttp/_websocket.pyx":20 * uint64_t uint64_msk * * assert len(mask) == 4 # <<<<<<<<<<<<<< * * data_len = len(data) */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(__pyx_v_mask == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 20, __pyx_L1_error) } __pyx_t_1 = PyBytes_GET_SIZE(__pyx_v_mask); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 20, __pyx_L1_error) if (unlikely(!((__pyx_t_1 == 4) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 20, __pyx_L1_error) } } #endif /* "aiohttp/_websocket.pyx":22 * assert len(mask) == 4 * * data_len = len(data) # <<<<<<<<<<<<<< * in_buf = PyByteArray_AsString(data) * mask_buf = PyBytes_AsString(mask) */ __pyx_t_1 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 22, __pyx_L1_error) __pyx_v_data_len = __pyx_t_1; /* "aiohttp/_websocket.pyx":23 * * data_len = len(data) * in_buf = PyByteArray_AsString(data) # <<<<<<<<<<<<<< * mask_buf = PyBytes_AsString(mask) * uint32_msk = (mask_buf)[0] */ __pyx_t_2 = PyByteArray_AsString(__pyx_v_data); if (unlikely(__pyx_t_2 == NULL)) __PYX_ERR(0, 23, __pyx_L1_error) __pyx_v_in_buf = ((unsigned char *)__pyx_t_2); /* "aiohttp/_websocket.pyx":24 * data_len = len(data) * in_buf = PyByteArray_AsString(data) * mask_buf = PyBytes_AsString(mask) # <<<<<<<<<<<<<< * uint32_msk = (mask_buf)[0] * */ __pyx_t_2 = PyBytes_AsString(__pyx_v_mask); if (unlikely(__pyx_t_2 == NULL)) __PYX_ERR(0, 24, __pyx_L1_error) __pyx_v_mask_buf = ((unsigned char const *)__pyx_t_2); /* "aiohttp/_websocket.pyx":25 * in_buf = PyByteArray_AsString(data) * mask_buf = PyBytes_AsString(mask) * uint32_msk = (mask_buf)[0] # <<<<<<<<<<<<<< * * # TODO: align in_data ptr to achieve even faster speeds */ __pyx_v_uint32_msk = (((uint32_t *)__pyx_v_mask_buf)[0]); /* "aiohttp/_websocket.pyx":30 * # does it need in python ?! malloc() always aligns to sizeof(long) bytes * * if sizeof(size_t) >= 8: # <<<<<<<<<<<<<< * uint64_msk = uint32_msk * uint64_msk = (uint64_msk << 32) | uint32_msk */ __pyx_t_3 = (((sizeof(size_t)) >= 8) != 0); if (__pyx_t_3) { /* "aiohttp/_websocket.pyx":31 * * if sizeof(size_t) >= 8: * uint64_msk = uint32_msk # <<<<<<<<<<<<<< * uint64_msk = (uint64_msk << 32) | uint32_msk * */ __pyx_v_uint64_msk = __pyx_v_uint32_msk; /* "aiohttp/_websocket.pyx":32 * if sizeof(size_t) >= 8: * uint64_msk = uint32_msk * uint64_msk = (uint64_msk << 32) | uint32_msk # <<<<<<<<<<<<<< * * while data_len >= 8: */ __pyx_v_uint64_msk = ((__pyx_v_uint64_msk << 32) | __pyx_v_uint32_msk); /* "aiohttp/_websocket.pyx":34 * uint64_msk = (uint64_msk << 32) | uint32_msk * * while data_len >= 8: # <<<<<<<<<<<<<< * (in_buf)[0] ^= uint64_msk * in_buf += 8 */ while (1) { __pyx_t_3 = ((__pyx_v_data_len >= 8) != 0); if (!__pyx_t_3) break; /* "aiohttp/_websocket.pyx":35 * * while data_len >= 8: * (in_buf)[0] ^= uint64_msk # <<<<<<<<<<<<<< * in_buf += 8 * data_len -= 8 */ __pyx_t_4 = ((uint64_t *)__pyx_v_in_buf); __pyx_t_5 = 0; (__pyx_t_4[__pyx_t_5]) = ((__pyx_t_4[__pyx_t_5]) ^ __pyx_v_uint64_msk); /* "aiohttp/_websocket.pyx":36 * while data_len >= 8: * (in_buf)[0] ^= uint64_msk * in_buf += 8 # <<<<<<<<<<<<<< * data_len -= 8 * */ __pyx_v_in_buf = (__pyx_v_in_buf + 8); /* "aiohttp/_websocket.pyx":37 * (in_buf)[0] ^= uint64_msk * in_buf += 8 * data_len -= 8 # <<<<<<<<<<<<<< * * */ __pyx_v_data_len = (__pyx_v_data_len - 8); } /* "aiohttp/_websocket.pyx":30 * # does it need in python ?! malloc() always aligns to sizeof(long) bytes * * if sizeof(size_t) >= 8: # <<<<<<<<<<<<<< * uint64_msk = uint32_msk * uint64_msk = (uint64_msk << 32) | uint32_msk */ } /* "aiohttp/_websocket.pyx":40 * * * while data_len >= 4: # <<<<<<<<<<<<<< * (in_buf)[0] ^= uint32_msk * in_buf += 4 */ while (1) { __pyx_t_3 = ((__pyx_v_data_len >= 4) != 0); if (!__pyx_t_3) break; /* "aiohttp/_websocket.pyx":41 * * while data_len >= 4: * (in_buf)[0] ^= uint32_msk # <<<<<<<<<<<<<< * in_buf += 4 * data_len -= 4 */ __pyx_t_6 = ((uint32_t *)__pyx_v_in_buf); __pyx_t_5 = 0; (__pyx_t_6[__pyx_t_5]) = ((__pyx_t_6[__pyx_t_5]) ^ __pyx_v_uint32_msk); /* "aiohttp/_websocket.pyx":42 * while data_len >= 4: * (in_buf)[0] ^= uint32_msk * in_buf += 4 # <<<<<<<<<<<<<< * data_len -= 4 * */ __pyx_v_in_buf = (__pyx_v_in_buf + 4); /* "aiohttp/_websocket.pyx":43 * (in_buf)[0] ^= uint32_msk * in_buf += 4 * data_len -= 4 # <<<<<<<<<<<<<< * * for i in range(0, data_len): */ __pyx_v_data_len = (__pyx_v_data_len - 4); } /* "aiohttp/_websocket.pyx":45 * data_len -= 4 * * for i in range(0, data_len): # <<<<<<<<<<<<<< * in_buf[i] ^= mask_buf[i] * */ __pyx_t_1 = __pyx_v_data_len; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_1; __pyx_t_7+=1) { __pyx_v_i = __pyx_t_7; /* "aiohttp/_websocket.pyx":46 * * for i in range(0, data_len): * in_buf[i] ^= mask_buf[i] # <<<<<<<<<<<<<< * * return data */ __pyx_t_8 = __pyx_v_i; (__pyx_v_in_buf[__pyx_t_8]) = ((__pyx_v_in_buf[__pyx_t_8]) ^ (__pyx_v_mask_buf[__pyx_v_i])); } /* "aiohttp/_websocket.pyx":48 * in_buf[i] ^= mask_buf[i] * * return data # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_data); __pyx_r = __pyx_v_data; goto __pyx_L0; /* "aiohttp/_websocket.pyx":9 * from libc.stdint cimport uint32_t, uint64_t, uintmax_t * * def _websocket_mask_cython(bytes mask, bytearray data): # <<<<<<<<<<<<<< * """Note, this function mutates it's `data` argument * """ */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("aiohttp._websocket._websocket_mask_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 static struct PyModuleDef __pyx_moduledef = { #if PY_VERSION_HEX < 0x03020000 { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, #else PyModuleDef_HEAD_INIT, #endif "_websocket", 0, /* m_doc */ -1, /* m_size */ __pyx_methods /* m_methods */, NULL, /* m_reload */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_aiohttp__websocket, __pyx_k_aiohttp__websocket, sizeof(__pyx_k_aiohttp__websocket), 0, 0, 1, 1}, {&__pyx_n_s_data, __pyx_k_data, sizeof(__pyx_k_data), 0, 0, 1, 1}, {&__pyx_n_s_data_len, __pyx_k_data_len, sizeof(__pyx_k_data_len), 0, 0, 1, 1}, {&__pyx_kp_s_home_travis_build_KeepSafe_aioh, __pyx_k_home_travis_build_KeepSafe_aioh, sizeof(__pyx_k_home_travis_build_KeepSafe_aioh), 0, 0, 1, 0}, {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, {&__pyx_n_s_in_buf, __pyx_k_in_buf, sizeof(__pyx_k_in_buf), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_mask, __pyx_k_mask, sizeof(__pyx_k_mask), 0, 0, 1, 1}, {&__pyx_n_s_mask_buf, __pyx_k_mask_buf, sizeof(__pyx_k_mask_buf), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_uint32_msk, __pyx_k_uint32_msk, sizeof(__pyx_k_uint32_msk), 0, 0, 1, 1}, {&__pyx_n_s_uint64_msk, __pyx_k_uint64_msk, sizeof(__pyx_k_uint64_msk), 0, 0, 1, 1}, {&__pyx_n_s_websocket_mask_cython, __pyx_k_websocket_mask_cython, sizeof(__pyx_k_websocket_mask_cython), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 45, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "aiohttp/_websocket.pyx":9 * from libc.stdint cimport uint32_t, uint64_t, uintmax_t * * def _websocket_mask_cython(bytes mask, bytearray data): # <<<<<<<<<<<<<< * """Note, this function mutates it's `data` argument * """ */ __pyx_tuple_ = PyTuple_Pack(8, __pyx_n_s_mask, __pyx_n_s_data, __pyx_n_s_data_len, __pyx_n_s_i, __pyx_n_s_in_buf, __pyx_n_s_mask_buf, __pyx_n_s_uint32_msk, __pyx_n_s_uint64_msk); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_travis_build_KeepSafe_aioh, __pyx_n_s_websocket_mask_cython, 9, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); return 0; __pyx_L1_error:; return -1; } #if PY_MAJOR_VERSION < 3 PyMODINIT_FUNC init_websocket(void); /*proto*/ PyMODINIT_FUNC init_websocket(void) #else PyMODINIT_FUNC PyInit__websocket(void); /*proto*/ PyMODINIT_FUNC PyInit__websocket(void) #endif { PyObject *__pyx_t_1 = NULL; __Pyx_RefNannyDeclarations #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit__websocket(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("_websocket", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) #if CYTHON_COMPILING_IN_PYPY Py_INCREF(__pyx_b); #endif if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_aiohttp___websocket) { if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "aiohttp._websocket")) { if (unlikely(PyDict_SetItemString(modules, "aiohttp._websocket", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global init code ---*/ /*--- Variable export code ---*/ /*--- Function export code ---*/ /*--- Type init code ---*/ /*--- Type import code ---*/ __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", #if CYTHON_COMPILING_IN_PYPY sizeof(PyTypeObject), #else sizeof(PyHeapTypeObject), #endif 0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) __PYX_ERR(1, 9, __pyx_L1_error) __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), 0); if (unlikely(!__pyx_ptype_7cpython_4bool_bool)) __PYX_ERR(2, 8, __pyx_L1_error) __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), 0); if (unlikely(!__pyx_ptype_7cpython_7complex_complex)) __PYX_ERR(3, 15, __pyx_L1_error) /*--- Variable import code ---*/ /*--- Function import code ---*/ /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "aiohttp/_websocket.pyx":9 * from libc.stdint cimport uint32_t, uint64_t, uintmax_t * * def _websocket_mask_cython(bytes mask, bytearray data): # <<<<<<<<<<<<<< * """Note, this function mutates it's `data` argument * """ */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7aiohttp_10_websocket_1_websocket_mask_cython, NULL, __pyx_n_s_aiohttp__websocket); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_websocket_mask_cython, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "aiohttp/_websocket.pyx":1 * from cpython cimport PyBytes_AsString # <<<<<<<<<<<<<< * * #from cpython cimport PyByteArray_AsString # cython still not exports that */ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init aiohttp._websocket", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_DECREF(__pyx_m); __pyx_m = 0; } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init aiohttp._websocket"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if PY_MAJOR_VERSION < 3 return; #else return __pyx_m; #endif } /* --- 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((char *)modname); if (!m) goto end; p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* 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); } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } 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; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* ArgTypeTest */ static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) { PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", name, type->tp_name, Py_TYPE(obj)->tp_name); } static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, const char *name, int exact) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (none_allowed && obj == Py_None) return 1; else if (exact) { if (likely(Py_TYPE(obj) == type)) return 1; #if PY_MAJOR_VERSION == 2 else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; #endif } else { if (likely(PyObject_TypeCheck(obj, type))) return 1; } __Pyx_RaiseArgumentTypeInvalid(name, obj, type); return 0; } /* CodeObjectCache */ 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 PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_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(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyObject *py_srcfile = 0; PyObject *py_funcname = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(filename); #else py_srcfile = PyUnicode_FromString(filename); #endif if (!py_srcfile) goto bad; if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); Py_DECREF(py_funcname); return py_code; bad: Py_XDECREF(py_srcfile); 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; py_code = __pyx_find_code_object(c_line ? c_line : py_line); if (!py_code) { py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) goto bad; __pyx_insert_code_object(c_line ? c_line : py_line, py_code); } py_frame = PyFrame_New( PyThreadState_GET(), /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __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); } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) -1, const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } 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 PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* 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;\ } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) -1, const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (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])); } } break; case 3: if (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])); } } break; case 4: if (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])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON 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)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (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) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(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)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (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) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(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)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (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) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) -1, const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (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])); } } break; case 3: if (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])); } } break; case 4: if (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])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON 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)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (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) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(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)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (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) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(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)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (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) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* CheckBinaryVersion */ static int __Pyx_check_binary_version(void) { char ctversion[4], rtversion[4]; PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { char message[200]; PyOS_snprintf(message, sizeof(message), "compiletime version %s of module '%.100s' " "does not match runtime version %s", ctversion, __Pyx_MODULE_NAME, rtversion); return PyErr_WarnEx(NULL, message, 1); } return 0; } /* ModuleImport */ #ifndef __PYX_HAVE_RT_ImportModule #define __PYX_HAVE_RT_ImportModule static PyObject *__Pyx_ImportModule(const char *name) { PyObject *py_name = 0; PyObject *py_module = 0; py_name = __Pyx_PyIdentifier_FromString(name); if (!py_name) goto bad; py_module = PyImport_Import(py_name); Py_DECREF(py_name); return py_module; bad: Py_XDECREF(py_name); return 0; } #endif /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict) { PyObject *py_module = 0; PyObject *result = 0; PyObject *py_name = 0; char warning[200]; Py_ssize_t basicsize; #ifdef Py_LIMITED_API PyObject *py_basicsize; #endif py_module = __Pyx_ImportModule(module_name); if (!py_module) goto bad; py_name = __Pyx_PyIdentifier_FromString(class_name); if (!py_name) goto bad; result = PyObject_GetAttr(py_module, py_name); Py_DECREF(py_name); py_name = 0; Py_DECREF(py_module); py_module = 0; if (!result) goto bad; if (!PyType_Check(result)) { PyErr_Format(PyExc_TypeError, "%.200s.%.200s is not a type object", module_name, class_name); goto bad; } #ifndef Py_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; #endif if (!strict && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. Expected %zd, got %zd", module_name, class_name, basicsize, size); if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; } else if ((size_t)basicsize != size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s has the wrong size, try recompiling. Expected %zd, got %zd", module_name, class_name, basicsize, size); goto bad; } return (PyTypeObject *)result; bad: Py_XDECREF(py_module); Py_XDECREF(result); return NULL; } #endif /* InitStrings */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { #if PY_VERSION_HEX < 0x03030000 char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; #else if (__Pyx_PyUnicode_READY(o) == -1) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (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 } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { 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 PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (PyInt_Check(x) || PyLong_Check(x)) #else if (PyLong_Check(x)) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = PyNumber_Int(x); } else if (m && m->nb_long) { name = "long"; res = PyNumber_Long(x); } #else if (m && m->nb_int) { name = "int"; res = PyNumber_Long(x); } #endif #else res = PyNumber_Int(x); #endif if (res) { #if PY_MAJOR_VERSION < 3 if (!PyInt_Check(res) && !PyLong_Check(res)) { #else if (!PyLong_Check(res)) { #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", name, name, Py_TYPE(res)->tp_name); Py_DECREF(res); return NULL; } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(x); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (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])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(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])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ aiohttp-1.2.0/aiohttp/hdrs.py0000664000175000017500000000610013025134363017005 0ustar travistravis00000000000000"""HTTP Headers constants.""" from multidict import istr METH_ANY = '*' METH_CONNECT = 'CONNECT' METH_HEAD = 'HEAD' METH_GET = 'GET' METH_DELETE = 'DELETE' METH_OPTIONS = 'OPTIONS' METH_PATCH = 'PATCH' METH_POST = 'POST' METH_PUT = 'PUT' METH_TRACE = 'TRACE' METH_ALL = {METH_CONNECT, METH_HEAD, METH_GET, METH_DELETE, METH_OPTIONS, METH_PATCH, METH_POST, METH_PUT, METH_TRACE} ACCEPT = istr('ACCEPT') ACCEPT_CHARSET = istr('ACCEPT-CHARSET') ACCEPT_ENCODING = istr('ACCEPT-ENCODING') ACCEPT_LANGUAGE = istr('ACCEPT-LANGUAGE') ACCEPT_RANGES = istr('ACCEPT-RANGES') ACCESS_CONTROL_MAX_AGE = istr('ACCESS-CONTROL-MAX-AGE') ACCESS_CONTROL_ALLOW_CREDENTIALS = istr('ACCESS-CONTROL-ALLOW-CREDENTIALS') ACCESS_CONTROL_ALLOW_HEADERS = istr('ACCESS-CONTROL-ALLOW-HEADERS') ACCESS_CONTROL_ALLOW_METHODS = istr('ACCESS-CONTROL-ALLOW-METHODS') ACCESS_CONTROL_ALLOW_ORIGIN = istr('ACCESS-CONTROL-ALLOW-ORIGIN') ACCESS_CONTROL_EXPOSE_HEADERS = istr('ACCESS-CONTROL-EXPOSE-HEADERS') ACCESS_CONTROL_REQUEST_HEADERS = istr('ACCESS-CONTROL-REQUEST-HEADERS') ACCESS_CONTROL_REQUEST_METHOD = istr('ACCESS-CONTROL-REQUEST-METHOD') AGE = istr('AGE') ALLOW = istr('ALLOW') AUTHORIZATION = istr('AUTHORIZATION') CACHE_CONTROL = istr('CACHE-CONTROL') CONNECTION = istr('CONNECTION') CONTENT_DISPOSITION = istr('CONTENT-DISPOSITION') CONTENT_ENCODING = istr('CONTENT-ENCODING') CONTENT_LANGUAGE = istr('CONTENT-LANGUAGE') CONTENT_LENGTH = istr('CONTENT-LENGTH') CONTENT_LOCATION = istr('CONTENT-LOCATION') CONTENT_MD5 = istr('CONTENT-MD5') CONTENT_RANGE = istr('CONTENT-RANGE') CONTENT_TRANSFER_ENCODING = istr('CONTENT-TRANSFER-ENCODING') CONTENT_TYPE = istr('CONTENT-TYPE') COOKIE = istr('COOKIE') DATE = istr('DATE') DESTINATION = istr('DESTINATION') DIGEST = istr('DIGEST') ETAG = istr('ETAG') EXPECT = istr('EXPECT') EXPIRES = istr('EXPIRES') FROM = istr('FROM') HOST = istr('HOST') IF_MATCH = istr('IF-MATCH') IF_MODIFIED_SINCE = istr('IF-MODIFIED-SINCE') IF_NONE_MATCH = istr('IF-NONE-MATCH') IF_RANGE = istr('IF-RANGE') IF_UNMODIFIED_SINCE = istr('IF-UNMODIFIED-SINCE') KEEP_ALIVE = istr('KEEP-ALIVE') LAST_EVENT_ID = istr('LAST-EVENT-ID') LAST_MODIFIED = istr('LAST-MODIFIED') LINK = istr('LINK') LOCATION = istr('LOCATION') MAX_FORWARDS = istr('MAX-FORWARDS') ORIGIN = istr('ORIGIN') PRAGMA = istr('PRAGMA') PROXY_AUTHENTICATE = istr('PROXY_AUTHENTICATE') PROXY_AUTHORIZATION = istr('PROXY-AUTHORIZATION') RANGE = istr('RANGE') REFERER = istr('REFERER') RETRY_AFTER = istr('RETRY-AFTER') SEC_WEBSOCKET_ACCEPT = istr('SEC-WEBSOCKET-ACCEPT') SEC_WEBSOCKET_VERSION = istr('SEC-WEBSOCKET-VERSION') SEC_WEBSOCKET_PROTOCOL = istr('SEC-WEBSOCKET-PROTOCOL') SEC_WEBSOCKET_KEY = istr('SEC-WEBSOCKET-KEY') SEC_WEBSOCKET_KEY1 = istr('SEC-WEBSOCKET-KEY1') SERVER = istr('SERVER') SET_COOKIE = istr('SET-COOKIE') TE = istr('TE') TRAILER = istr('TRAILER') TRANSFER_ENCODING = istr('TRANSFER-ENCODING') UPGRADE = istr('UPGRADE') WEBSOCKET = istr('WEBSOCKET') URI = istr('URI') USER_AGENT = istr('USER-AGENT') VARY = istr('VARY') VIA = istr('VIA') WANT_DIGEST = istr('WANT-DIGEST') WARNING = istr('WARNING') WWW_AUTHENTICATE = istr('WWW-AUTHENTICATE') aiohttp-1.2.0/aiohttp/web_ws.py0000664000175000017500000002524613025134363017347 0ustar travistravis00000000000000import asyncio import json import sys import warnings from collections import namedtuple from . import Timeout, hdrs from ._ws_impl import (CLOSED_MESSAGE, WebSocketError, WSMessage, WSMsgType, do_handshake) from .errors import ClientDisconnectedError, HttpProcessingError from .web_exceptions import (HTTPBadRequest, HTTPInternalServerError, HTTPMethodNotAllowed) from .web_reqrep import StreamResponse __all__ = ('WebSocketResponse', 'WebSocketReady', 'MsgType', 'WSMsgType',) PY_35 = sys.version_info >= (3, 5) PY_352 = sys.version_info >= (3, 5, 2) THRESHOLD_CONNLOST_ACCESS = 5 # deprecated since 1.0 MsgType = WSMsgType class WebSocketReady(namedtuple('WebSocketReady', 'ok protocol')): def __bool__(self): return self.ok class WebSocketResponse(StreamResponse): def __init__(self, *, timeout=10.0, autoclose=True, autoping=True, protocols=()): super().__init__(status=101) self._protocols = protocols self._protocol = None self._writer = None self._reader = None self._closed = False self._closing = False self._conn_lost = 0 self._close_code = None self._loop = None self._waiting = False self._exception = None self._timeout = timeout self._autoclose = autoclose self._autoping = autoping @asyncio.coroutine def prepare(self, request): # make pre-check to don't hide it by do_handshake() exceptions resp_impl = self._start_pre_check(request) if resp_impl is not None: return resp_impl parser, protocol, writer = self._pre_start(request) resp_impl = yield from super().prepare(request) self._post_start(request, parser, protocol, writer) return resp_impl def _pre_start(self, request): try: status, headers, parser, writer, protocol = do_handshake( request.method, request.headers, request.transport, self._protocols) except HttpProcessingError as err: if err.code == 405: raise HTTPMethodNotAllowed( request.method, [hdrs.METH_GET], body=b'') elif err.code == 400: raise HTTPBadRequest(text=err.message, headers=err.headers) else: # pragma: no cover raise HTTPInternalServerError() from err if self.status != status: self.set_status(status) for k, v in headers: self.headers[k] = v self.force_close() return parser, protocol, writer def _post_start(self, request, parser, protocol, writer): self._reader = request._reader.set_parser(parser) self._writer = writer self._protocol = protocol self._loop = request.app.loop def start(self, request): warnings.warn('use .prepare(request) instead', DeprecationWarning) # make pre-check to don't hide it by do_handshake() exceptions resp_impl = self._start_pre_check(request) if resp_impl is not None: return resp_impl parser, protocol, writer = self._pre_start(request) resp_impl = super().start(request) self._post_start(request, parser, protocol, writer) return resp_impl def can_prepare(self, request): if self._writer is not None: raise RuntimeError('Already started') try: _, _, _, _, protocol = do_handshake( request.method, request.headers, request.transport, self._protocols) except HttpProcessingError: return WebSocketReady(False, None) else: return WebSocketReady(True, protocol) def can_start(self, request): warnings.warn('use .can_prepare(request) instead', DeprecationWarning) return self.can_prepare(request) @property def closed(self): return self._closed @property def close_code(self): return self._close_code @property def protocol(self): return self._protocol def exception(self): return self._exception def ping(self, message='b'): if self._writer is None: raise RuntimeError('Call .prepare() first') if self._closed: raise RuntimeError('websocket connection is closing') self._writer.ping(message) def pong(self, message='b'): # unsolicited pong if self._writer is None: raise RuntimeError('Call .prepare() first') if self._closed: raise RuntimeError('websocket connection is closing') self._writer.pong(message) def send_str(self, data): if self._writer is None: raise RuntimeError('Call .prepare() first') if self._closed: raise RuntimeError('websocket connection is closing') if not isinstance(data, str): raise TypeError('data argument must be str (%r)' % type(data)) self._writer.send(data, binary=False) def send_bytes(self, data): if self._writer is None: raise RuntimeError('Call .prepare() first') if self._closed: raise RuntimeError('websocket connection is closing') if not isinstance(data, (bytes, bytearray, memoryview)): raise TypeError('data argument must be byte-ish (%r)' % type(data)) self._writer.send(data, binary=True) def send_json(self, data, *, dumps=json.dumps): self.send_str(dumps(data)) @asyncio.coroutine def write_eof(self): if self._eof_sent: return if self._resp_impl is None: raise RuntimeError("Response has not been started") yield from self.close() self._eof_sent = True @asyncio.coroutine def close(self, *, code=1000, message=b''): if self._writer is None: raise RuntimeError('Call .prepare() first') if not self._closed: self._closed = True try: self._writer.close(code, message) except (asyncio.CancelledError, asyncio.TimeoutError): self._close_code = 1006 raise except Exception as exc: self._close_code = 1006 self._exception = exc return True if self._closing: return True begin = self._loop.time() while self._loop.time() - begin < self._timeout: try: with Timeout(timeout=self._timeout, loop=self._loop): msg = yield from self._reader.read() except asyncio.CancelledError: self._close_code = 1006 raise except Exception as exc: self._close_code = 1006 self._exception = exc return True if msg.type == WSMsgType.CLOSE: self._close_code = msg.data return True self._close_code = 1006 self._exception = asyncio.TimeoutError() return True else: return False @asyncio.coroutine def receive(self): if self._reader is None: raise RuntimeError('Call .prepare() first') if self._waiting: raise RuntimeError('Concurrent call to receive() is not allowed') self._waiting = True try: while True: if self._closed: self._conn_lost += 1 if self._conn_lost >= THRESHOLD_CONNLOST_ACCESS: raise RuntimeError('WebSocket connection is closed.') return CLOSED_MESSAGE try: msg = yield from self._reader.read() except (asyncio.CancelledError, asyncio.TimeoutError): raise except WebSocketError as exc: self._close_code = exc.code yield from self.close(code=exc.code) return WSMessage(WSMsgType.ERROR, exc, None) except ClientDisconnectedError: self._closed = True self._close_code = 1006 return WSMessage(WSMsgType.CLOSE, None, None) except Exception as exc: self._exception = exc self._closing = True self._close_code = 1006 yield from self.close() return WSMessage(WSMsgType.ERROR, exc, None) if msg.type == WSMsgType.CLOSE: self._closing = True self._close_code = msg.data if not self._closed and self._autoclose: yield from self.close() return msg if msg.type == WSMsgType.PING and self._autoping: self.pong(msg.data) elif msg.type == WSMsgType.PONG and self._autoping: continue else: return msg finally: self._waiting = False @asyncio.coroutine def receive_msg(self): warnings.warn( 'receive_msg() coroutine is deprecated. use receive() instead', DeprecationWarning) return (yield from self.receive()) @asyncio.coroutine def receive_str(self): msg = yield from self.receive() if msg.type != WSMsgType.TEXT: raise TypeError( "Received message {}:{!r} is not str".format(msg.type, msg.data)) return msg.data @asyncio.coroutine def receive_bytes(self): msg = yield from self.receive() if msg.type != WSMsgType.BINARY: raise TypeError( "Received message {}:{!r} is not bytes".format(msg.type, msg.data)) return msg.data @asyncio.coroutine def receive_json(self, *, loads=json.loads): data = yield from self.receive_str() return loads(data) def write(self, data): raise RuntimeError("Cannot call .write() for websocket") if PY_35: def __aiter__(self): return self if not PY_352: # pragma: no cover __aiter__ = asyncio.coroutine(__aiter__) @asyncio.coroutine def __anext__(self): msg = yield from self.receive() if msg.type == WSMsgType.CLOSE or msg.type == WSMsgType.CLOSED: raise StopAsyncIteration # NOQA return msg aiohttp-1.2.0/aiohttp/client_ws.py0000664000175000017500000001415713025134363020047 0ustar travistravis00000000000000"""WebSocket client for asyncio.""" import asyncio import json import sys from ._ws_impl import CLOSED_MESSAGE, WebSocketError, WSMessage, WSMsgType PY_35 = sys.version_info >= (3, 5) PY_352 = sys.version_info >= (3, 5, 2) class ClientWebSocketResponse: def __init__(self, reader, writer, protocol, response, timeout, autoclose, autoping, loop): self._response = response self._conn = response.connection self._writer = writer self._reader = reader self._protocol = protocol self._closed = False self._closing = False self._close_code = None self._timeout = timeout self._autoclose = autoclose self._autoping = autoping self._loop = loop self._waiting = False self._exception = None @property def closed(self): return self._closed @property def close_code(self): return self._close_code @property def protocol(self): return self._protocol def exception(self): return self._exception def ping(self, message='b'): if self._closed: raise RuntimeError('websocket connection is closed') self._writer.ping(message) def pong(self, message='b'): if self._closed: raise RuntimeError('websocket connection is closed') self._writer.pong(message) def send_str(self, data): if self._closed: raise RuntimeError('websocket connection is closed') if not isinstance(data, str): raise TypeError('data argument must be str (%r)' % type(data)) self._writer.send(data, binary=False) def send_bytes(self, data): if self._closed: raise RuntimeError('websocket connection is closed') if not isinstance(data, (bytes, bytearray, memoryview)): raise TypeError('data argument must be byte-ish (%r)' % type(data)) self._writer.send(data, binary=True) def send_json(self, data, *, dumps=json.dumps): self.send_str(dumps(data)) @asyncio.coroutine def close(self, *, code=1000, message=b''): if not self._closed: self._closed = True try: self._writer.close(code, message) except asyncio.CancelledError: self._close_code = 1006 self._response.close() raise except Exception as exc: self._close_code = 1006 self._exception = exc self._response.close() return True if self._closing: self._response.close() return True while True: try: msg = yield from asyncio.wait_for( self._reader.read(), self._timeout, loop=self._loop) except asyncio.CancelledError: self._close_code = 1006 self._response.close() raise except Exception as exc: self._close_code = 1006 self._exception = exc self._response.close() return True if msg.type == WSMsgType.CLOSE: self._close_code = msg.data self._response.close() return True else: return False @asyncio.coroutine def receive(self): if self._waiting: raise RuntimeError('Concurrent call to receive() is not allowed') self._waiting = True try: while True: if self._closed: return CLOSED_MESSAGE try: msg = yield from self._reader.read() except (asyncio.CancelledError, asyncio.TimeoutError): raise except WebSocketError as exc: self._close_code = exc.code yield from self.close(code=exc.code) return WSMessage(WSMsgType.ERROR, exc, None) except Exception as exc: self._exception = exc self._closing = True self._close_code = 1006 yield from self.close() return WSMessage(WSMsgType.ERROR, exc, None) if msg.type == WSMsgType.CLOSE: self._closing = True self._close_code = msg.data if not self._closed and self._autoclose: yield from self.close() return msg if msg.type == WSMsgType.PING and self._autoping: self.pong(msg.data) elif msg.type == WSMsgType.PONG and self._autoping: continue else: return msg finally: self._waiting = False @asyncio.coroutine def receive_str(self): msg = yield from self.receive() if msg.type != WSMsgType.TEXT: raise TypeError( "Received message {}:{!r} is not str".format(msg.type, msg.data)) return msg.data @asyncio.coroutine def receive_bytes(self): msg = yield from self.receive() if msg.type != WSMsgType.BINARY: raise TypeError( "Received message {}:{!r} is not bytes".format(msg.type, msg.data)) return msg.data @asyncio.coroutine def receive_json(self, *, loads=json.loads): data = yield from self.receive_str() return loads(data) if PY_35: def __aiter__(self): return self if not PY_352: # pragma: no cover __aiter__ = asyncio.coroutine(__aiter__) @asyncio.coroutine def __anext__(self): msg = yield from self.receive() if msg.type == WSMsgType.CLOSE or msg.type == WSMsgType.CLOSED: raise StopAsyncIteration # NOQA return msg aiohttp-1.2.0/aiohttp/connector.py0000664000175000017500000006650713025134363020060 0ustar travistravis00000000000000import asyncio import functools import http.cookies import ssl import sys import traceback import warnings from collections import defaultdict from hashlib import md5, sha1, sha256 from itertools import chain from math import ceil from types import MappingProxyType from yarl import URL import aiohttp from . import hdrs, helpers from .client import ClientRequest from .errors import (ClientOSError, ClientTimeoutError, FingerprintMismatch, HttpProxyError, ProxyConnectionError, ServerDisconnectedError) from .helpers import is_ip_address, sentinel from .resolver import DefaultResolver __all__ = ('BaseConnector', 'TCPConnector', 'ProxyConnector', 'UnixConnector') PY_343 = sys.version_info >= (3, 4, 3) HASHFUNC_BY_DIGESTLEN = { 16: md5, 20: sha1, 32: sha256, } class Connection: _source_traceback = None _transport = None def __init__(self, connector, key, request, transport, protocol, loop): self._key = key self._connector = connector self._request = request self._transport = transport self._protocol = protocol self._loop = loop self.reader = protocol.reader self.writer = protocol.writer if loop.get_debug(): self._source_traceback = traceback.extract_stack(sys._getframe(1)) def __repr__(self): return 'Connection<{}>'.format(self._key) def __del__(self, _warnings=warnings): if self._transport is not None: _warnings.warn('Unclosed connection {!r}'.format(self), ResourceWarning) if self._loop.is_closed(): return self._connector._release( self._key, self._request, self._transport, self._protocol, should_close=True) context = {'client_connection': self, 'message': 'Unclosed connection'} if self._source_traceback is not None: context['source_traceback'] = self._source_traceback self._loop.call_exception_handler(context) @property def loop(self): return self._loop def close(self): if self._transport is not None: self._connector._release( self._key, self._request, self._transport, self._protocol, should_close=True) self._transport = None def release(self): if self._transport is not None: self._connector._release( self._key, self._request, self._transport, self._protocol, should_close=False) self._transport = None def detach(self): if self._transport is not None: self._connector._release_acquired(self._key, self._transport) self._transport = None @property def closed(self): return self._transport is None class BaseConnector(object): """Base connector class. conn_timeout - (optional) Connect timeout. keepalive_timeout - (optional) Keep-alive timeout. force_close - Set to True to force close and do reconnect after each request (and between redirects). limit - The limit of simultaneous connections to the same endpoint. loop - Optional event loop. """ _closed = True # prevent AttributeError in __del__ if ctor was failed _source_traceback = None def __init__(self, *, conn_timeout=None, keepalive_timeout=sentinel, force_close=False, limit=20, loop=None): if force_close: if keepalive_timeout is not None and \ keepalive_timeout is not sentinel: raise ValueError('keepalive_timeout cannot ' 'be set if force_close is True') else: if keepalive_timeout is sentinel: keepalive_timeout = 30 if loop is None: loop = asyncio.get_event_loop() self._closed = False if loop.get_debug(): self._source_traceback = traceback.extract_stack(sys._getframe(1)) self._conns = {} self._acquired = defaultdict(set) self._conn_timeout = conn_timeout self._keepalive_timeout = keepalive_timeout self._cleanup_handle = None self._force_close = force_close self._limit = limit self._waiters = defaultdict(list) self._loop = loop self._factory = functools.partial( aiohttp.StreamProtocol, loop=loop, disconnect_error=ServerDisconnectedError) self.cookies = http.cookies.SimpleCookie() def __del__(self, _warnings=warnings): if self._closed: return if not self._conns: return conns = [repr(c) for c in self._conns.values()] self.close() _warnings.warn("Unclosed connector {!r}".format(self), ResourceWarning) 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) def __enter__(self): return self def __exit__(self, *exc): self.close() @property def force_close(self): """Ultimately close connection on releasing if True.""" return self._force_close @property def limit(self): """The limit for simultaneous connections to the same endpoint. Endpoints are the same if they are have equal (host, port, is_ssl) triple. If limit is None the connector has no limit. The default limit size is 20. """ return self._limit def _cleanup(self): """Cleanup unused transports.""" if self._cleanup_handle: self._cleanup_handle.cancel() self._cleanup_handle = None now = self._loop.time() connections = {} timeout = self._keepalive_timeout for key, conns in self._conns.items(): alive = [] for transport, proto, t0 in conns: if transport is not None: if proto and not proto.is_connected(): transport = None else: delta = t0 + self._keepalive_timeout - now if delta < 0: transport.close() transport = None elif delta < timeout: timeout = delta if transport is not None: alive.append((transport, proto, t0)) if alive: connections[key] = alive if connections: self._cleanup_handle = self._loop.call_at( ceil(now + timeout), self._cleanup) self._conns = connections def _start_cleanup_task(self): if self._cleanup_handle is None: now = self._loop.time() self._cleanup_handle = self._loop.call_at( ceil(now + self._keepalive_timeout), self._cleanup) def close(self): """Close all opened transports.""" ret = helpers.create_future(self._loop) ret.set_result(None) if self._closed: return ret self._closed = True try: if self._loop.is_closed(): return ret for key, data in self._conns.items(): for transport, proto, t0 in data: transport.close() for transport in chain(*self._acquired.values()): transport.close() if self._cleanup_handle: self._cleanup_handle.cancel() finally: self._conns.clear() self._acquired.clear() self._cleanup_handle = None return ret @property def closed(self): """Is connector closed. A readonly property. """ return self._closed @asyncio.coroutine def connect(self, req): """Get from pool or create new connection.""" key = (req.host, req.port, req.ssl) limit = self._limit if limit is not None: fut = helpers.create_future(self._loop) waiters = self._waiters[key] # The limit defines the maximum number of concurrent connections # for a key. Waiters must be counted against the limit, even before # the underlying connection is created. available = limit - len(waiters) - len(self._acquired[key]) # Don't wait if there are connections available. if available > 0: fut.set_result(None) # This connection will now count towards the limit. waiters.append(fut) try: if limit is not None: yield from fut transport, proto = self._get(key) if transport is None: try: if self._conn_timeout: transport, proto = yield from asyncio.wait_for( self._create_connection(req), self._conn_timeout, loop=self._loop) else: transport, proto = \ yield from self._create_connection(req) except asyncio.TimeoutError as exc: raise ClientTimeoutError( 'Connection timeout to host {0[0]}:{0[1]} ssl:{0[2]}' .format(key)) from exc except OSError as exc: raise ClientOSError( exc.errno, 'Cannot connect to host {0[0]}:{0[1]} ssl:{0[2]} [{1}]' .format(key, exc.strerror)) from exc except: self._release_waiter(key) raise self._acquired[key].add(transport) conn = Connection(self, key, req, transport, proto, self._loop) return conn def _get(self, key): try: conns = self._conns[key] except KeyError: return None, None t1 = self._loop.time() while conns: transport, proto, t0 = conns.pop() if transport is not None and proto.is_connected(): if t1 - t0 > self._keepalive_timeout: transport.close() transport = None else: if not conns: # The very last connection was reclaimed: drop the key del self._conns[key] return transport, proto # No more connections: drop the key del self._conns[key] return None, None def _release_waiter(self, key): waiters = self._waiters[key] while waiters: waiter = waiters.pop(0) if not waiter.done(): waiter.set_result(None) break def _release_acquired(self, key, transport): if self._closed: # acquired connection is already released on connector closing return acquired = self._acquired[key] try: acquired.remove(transport) except KeyError: # pragma: no cover # this may be result of undetermenistic order of objects # finalization due garbage collection. return None return acquired def _release(self, key, req, transport, protocol, *, should_close=False): if self._closed: # acquired connection is already released on connector closing return acquired = self._release_acquired(key, transport) if self._limit is not None and acquired is not None: if len(acquired) < self._limit: self._release_waiter(key) resp = req.response if not should_close: if self._force_close: should_close = True elif resp is not None: should_close = resp._should_close reader = protocol.reader if should_close or (reader.output and not reader.output.at_eof()): transport.close() else: conns = self._conns.get(key) if conns is None: conns = self._conns[key] = [] conns.append((transport, protocol, self._loop.time())) reader.unset_parser() self._start_cleanup_task() @asyncio.coroutine def _create_connection(self, req): raise NotImplementedError() _SSL_OP_NO_COMPRESSION = getattr(ssl, "OP_NO_COMPRESSION", 0) class TCPConnector(BaseConnector): """TCP connector. verify_ssl - Set to True to check ssl certifications. fingerprint - Pass the binary md5, sha1, or sha256 digest of the expected certificate in DER format to verify that the certificate the server presents matches. See also https://en.wikipedia.org/wiki/Transport_Layer_Security#Certificate_pinning resolve - (Deprecated) Set to True to do DNS lookup for host name. resolver - Enable DNS lookups and use this resolver use_dns_cache - Use memory cache for DNS lookups. family - socket address family local_addr - local tuple of (host, port) to bind socket to conn_timeout - (optional) Connect timeout. keepalive_timeout - (optional) Keep-alive timeout. force_close - Set to True to force close and do reconnect after each request (and between redirects). limit - The limit of simultaneous connections to the same endpoint. loop - Optional event loop. """ def __init__(self, *, verify_ssl=True, fingerprint=None, resolve=sentinel, use_dns_cache=sentinel, family=0, ssl_context=None, local_addr=None, resolver=None, conn_timeout=None, keepalive_timeout=sentinel, force_close=False, limit=20, loop=None): super().__init__(conn_timeout=conn_timeout, keepalive_timeout=keepalive_timeout, force_close=force_close, limit=limit, loop=loop) if not verify_ssl and ssl_context is not None: raise ValueError( "Either disable ssl certificate validation by " "verify_ssl=False or specify ssl_context, not both.") self._verify_ssl = verify_ssl if fingerprint: digestlen = len(fingerprint) hashfunc = HASHFUNC_BY_DIGESTLEN.get(digestlen) if not hashfunc: raise ValueError('fingerprint has invalid length') elif hashfunc is md5 or hashfunc is sha1: warnings.simplefilter('always') warnings.warn('md5 and sha1 are insecure and deprecated. ' 'Use sha256.', DeprecationWarning, stacklevel=2) self._hashfunc = hashfunc self._fingerprint = fingerprint if resolve is not sentinel: warnings.warn(("resolve parameter is deprecated, " "use use_dns_cache instead"), DeprecationWarning, stacklevel=2) if use_dns_cache is not sentinel and resolve is not sentinel: if use_dns_cache != resolve: raise ValueError("use_dns_cache must agree with resolve") _use_dns_cache = use_dns_cache elif use_dns_cache is not sentinel: _use_dns_cache = use_dns_cache elif resolve is not sentinel: _use_dns_cache = resolve else: _use_dns_cache = True if resolver is None: resolver = DefaultResolver(loop=self._loop) self._resolver = resolver self._use_dns_cache = _use_dns_cache self._cached_hosts = {} self._ssl_context = ssl_context self._family = family self._local_addr = local_addr @property def verify_ssl(self): """Do check for ssl certifications?""" return self._verify_ssl @property def fingerprint(self): """Expected ssl certificate fingerprint.""" return self._fingerprint @property def ssl_context(self): """SSLContext instance for https requests. Lazy property, creates context on demand. """ if self._ssl_context is None: if not self._verify_ssl: sslcontext = ssl.SSLContext(ssl.PROTOCOL_SSLv23) sslcontext.options |= ssl.OP_NO_SSLv2 sslcontext.options |= ssl.OP_NO_SSLv3 sslcontext.options |= _SSL_OP_NO_COMPRESSION sslcontext.set_default_verify_paths() else: sslcontext = ssl.create_default_context() self._ssl_context = sslcontext return self._ssl_context @property def family(self): """Socket family like AF_INET.""" return self._family @property def use_dns_cache(self): """True if local DNS caching is enabled.""" return self._use_dns_cache @property def cached_hosts(self): """Read-only dict of cached DNS record.""" return MappingProxyType(self._cached_hosts) def clear_dns_cache(self, host=None, port=None): """Remove specified host/port or clear all dns local cache.""" if host is not None and port is not None: self._cached_hosts.pop((host, port), None) elif host is not None or port is not None: raise ValueError("either both host and port " "or none of them are allowed") else: self._cached_hosts.clear() @property def resolve(self): """Do DNS lookup for host name?""" warnings.warn((".resolve property is deprecated, " "use .dns_cache instead"), DeprecationWarning, stacklevel=2) return self.use_dns_cache @property def resolved_hosts(self): """The dict of (host, port) -> (ipaddr, port) pairs.""" warnings.warn((".resolved_hosts property is deprecated, " "use .cached_hosts instead"), DeprecationWarning, stacklevel=2) return self.cached_hosts def clear_resolved_hosts(self, host=None, port=None): """Remove specified host/port or clear all resolve cache.""" warnings.warn((".clear_resolved_hosts() is deprecated, " "use .clear_dns_cache() instead"), DeprecationWarning, stacklevel=2) if host is not None and port is not None: self.clear_dns_cache(host, port) else: self.clear_dns_cache() @asyncio.coroutine def _resolve_host(self, host, port): if is_ip_address(host): return [{'hostname': host, 'host': host, 'port': port, 'family': self._family, 'proto': 0, 'flags': 0}] if self._use_dns_cache: key = (host, port) if key not in self._cached_hosts: self._cached_hosts[key] = yield from \ self._resolver.resolve(host, port, family=self._family) return self._cached_hosts[key] else: res = yield from self._resolver.resolve( host, port, family=self._family) return res @asyncio.coroutine def _create_connection(self, req): """Create connection. Has same keyword arguments as BaseEventLoop.create_connection. """ if req.proxy: transport, proto = yield from self._create_proxy_connection(req) else: transport, proto = yield from self._create_direct_connection(req) return transport, proto @asyncio.coroutine def _create_direct_connection(self, req): if req.ssl: sslcontext = self.ssl_context else: sslcontext = None hosts = yield from self._resolve_host(req.host, req.port) exc = None for hinfo in hosts: try: host = hinfo['host'] port = hinfo['port'] transp, proto = yield from self._loop.create_connection( self._factory, host, port, ssl=sslcontext, family=hinfo['family'], proto=hinfo['proto'], flags=hinfo['flags'], server_hostname=hinfo['hostname'] if sslcontext else None, local_addr=self._local_addr) has_cert = transp.get_extra_info('sslcontext') if has_cert and self._fingerprint: sock = transp.get_extra_info('socket') if not hasattr(sock, 'getpeercert'): # Workaround for asyncio 3.5.0 # Starting from 3.5.1 version # there is 'ssl_object' extra info in transport sock = transp._ssl_protocol._sslpipe.ssl_object # gives DER-encoded cert as a sequence of bytes (or None) cert = sock.getpeercert(binary_form=True) assert cert got = self._hashfunc(cert).digest() expected = self._fingerprint if got != expected: transp.close() raise FingerprintMismatch(expected, got, host, port) return transp, proto except OSError as e: exc = e else: raise ClientOSError(exc.errno, 'Can not connect to %s:%s [%s]' % (req.host, req.port, exc.strerror)) from exc @asyncio.coroutine def _create_proxy_connection(self, req): proxy_req = ClientRequest( hdrs.METH_GET, req.proxy, headers={hdrs.HOST: req.headers[hdrs.HOST]}, auth=req.proxy_auth, loop=self._loop) try: # create connection to proxy server transport, proto = yield from self._create_direct_connection( proxy_req) except OSError as exc: raise ProxyConnectionError(*exc.args) from exc if hdrs.AUTHORIZATION in proxy_req.headers: auth = proxy_req.headers[hdrs.AUTHORIZATION] del proxy_req.headers[hdrs.AUTHORIZATION] if not req.ssl: req.headers[hdrs.PROXY_AUTHORIZATION] = auth else: proxy_req.headers[hdrs.PROXY_AUTHORIZATION] = auth if req.ssl: # For HTTPS requests over HTTP proxy # we must notify proxy to tunnel connection # so we send CONNECT command: # CONNECT www.python.org:443 HTTP/1.1 # Host: www.python.org # # next we must do TLS handshake and so on # to do this we must wrap raw socket into secure one # asyncio handles this perfectly proxy_req.method = hdrs.METH_CONNECT proxy_req.url = req.url key = (req.host, req.port, req.ssl) conn = Connection(self, key, proxy_req, transport, proto, self._loop) self._acquired[key].add(conn._transport) proxy_resp = proxy_req.send(conn.writer, conn.reader) try: resp = yield from proxy_resp.start(conn, True) except: proxy_resp.close() conn.close() raise else: conn.detach() try: if resp.status != 200: raise HttpProxyError(code=resp.status, message=resp.reason) rawsock = transport.get_extra_info('socket', default=None) if rawsock is None: raise RuntimeError( "Transport does not expose socket instance") # Duplicate the socket, so now we can close proxy transport rawsock = rawsock.dup() finally: transport.close() transport, proto = yield from self._loop.create_connection( self._factory, ssl=self.ssl_context, sock=rawsock, server_hostname=req.host) finally: proxy_resp.close() return transport, proto class ProxyConnector(TCPConnector): """Http Proxy connector. Deprecated, use ClientSession.request with proxy parameters. Is still here for backward compatibility. proxy - Proxy URL address. Only HTTP proxy supported. proxy_auth - (optional) Proxy HTTP Basic Auth proxy_auth - aiohttp.helpers.BasicAuth conn_timeout - (optional) Connect timeout. keepalive_timeout - (optional) Keep-alive timeout. force_close - Set to True to force close and do reconnect after each request (and between redirects). limit - The limit of simultaneous connections to the same endpoint. loop - Optional event loop. Usage: >>> conn = ProxyConnector(proxy="http://some.proxy.com") >>> session = ClientSession(connector=conn) >>> resp = yield from session.get('http://python.org') """ def __init__(self, proxy, *, proxy_auth=None, force_close=True, conn_timeout=None, keepalive_timeout=sentinel, limit=20, loop=None): warnings.warn("ProxyConnector is deprecated, use " "client.get(url, proxy=proxy_url) instead", DeprecationWarning) super().__init__(force_close=force_close, conn_timeout=conn_timeout, keepalive_timeout=keepalive_timeout, limit=limit, loop=loop) proxy = URL(proxy) self._proxy = proxy self._proxy_auth = proxy_auth @property def proxy(self): return self._proxy @property def proxy_auth(self): return self._proxy_auth @asyncio.coroutine def _create_connection(self, req): """ Use TCPConnector _create_connection, to emulate old ProxyConnector. """ req.update_proxy(self._proxy, self._proxy_auth) transport, proto = yield from super()._create_connection(req) return transport, proto class UnixConnector(BaseConnector): """Unix socket connector. path - Unix socket path. conn_timeout - (optional) Connect timeout. keepalive_timeout - (optional) Keep-alive timeout. force_close - Set to True to force close and do reconnect after each request (and between redirects). limit - The limit of simultaneous connections to the same endpoint. loop - Optional event loop. Usage: >>> conn = UnixConnector(path='/path/to/socket') >>> session = ClientSession(connector=conn) >>> resp = yield from session.get('http://python.org') """ def __init__(self, path, force_close=False, conn_timeout=None, keepalive_timeout=sentinel, limit=20, loop=None): super().__init__(force_close=force_close, conn_timeout=conn_timeout, keepalive_timeout=keepalive_timeout, limit=limit, loop=loop) self._path = path @property def path(self): """Path to unix socket.""" return self._path @asyncio.coroutine def _create_connection(self, req): return (yield from self._loop.create_unix_connection( self._factory, self._path)) aiohttp-1.2.0/aiohttp/test_utils.py0000664000175000017500000003647513025134363020266 0ustar travistravis00000000000000"""Utilities shared by tests.""" import asyncio import contextlib import functools import gc import socket import sys import unittest from abc import ABC, abstractmethod from unittest import mock from multidict import CIMultiDict from yarl import URL import aiohttp from aiohttp.client import _RequestContextManager from . import ClientSession, hdrs from .helpers import sentinel from .protocol import HttpVersion, RawRequestMessage from .signals import Signal from .web import Application, Request, Server, UrlMappingMatchInfo PY_35 = sys.version_info >= (3, 5) def run_briefly(loop): @asyncio.coroutine def once(): pass t = asyncio.Task(once(), loop=loop) loop.run_until_complete(t) def unused_port(): """Return a port that is unused on the current host.""" with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind(('127.0.0.1', 0)) return s.getsockname()[1] class BaseTestServer(ABC): def __init__(self, *, scheme=sentinel, host='127.0.0.1'): self.port = None self.server = None self.handler = None self._root = None self.host = host self._closed = False self.scheme = scheme @asyncio.coroutine def start_server(self, **kwargs): if self.server: return self.port = unused_port() self._ssl = kwargs.pop('ssl', None) if self.scheme is sentinel: if self._ssl: scheme = 'https' else: scheme = 'http' self.scheme = scheme self._root = URL('{}://{}:{}'.format(self.scheme, self.host, self.port)) handler = yield from self._make_factory(**kwargs) self.server = yield from self._loop.create_server(handler, self.host, self.port, ssl=self._ssl) @abstractmethod # pragma: no cover @asyncio.coroutine def _make_factory(self, **kwargs): pass def make_url(self, path): url = URL(path) assert not url.is_absolute() return self._root.join(url) @property def started(self): return self.server is not None @property def closed(self): return self._closed @asyncio.coroutine def close(self): """Close all fixtures created by the test client. After that point, the TestClient is no longer usable. This is an idempotent function: running close multiple times will not have any additional effects. close is also run when the object is garbage collected, and on exit when used as a context manager. """ if self.started and not self.closed: self.server.close() yield from self.server.wait_closed() self._root = None self.port = None yield from self._close_hook() self._closed = True @abstractmethod @asyncio.coroutine def _close_hook(self): pass # pragma: no cover def __enter__(self): self._loop.run_until_complete(self.start_server()) return self def __exit__(self, exc_type, exc_value, traceback): self._loop.run_until_complete(self.close()) if PY_35: @asyncio.coroutine def __aenter__(self): yield from self.start_server() return self @asyncio.coroutine def __aexit__(self, exc_type, exc_value, traceback): yield from self.close() class TestServer(BaseTestServer): def __init__(self, app, *, scheme=sentinel, host='127.0.0.1'): self.app = app self._loop = app.loop super().__init__(scheme=scheme, host=host) @asyncio.coroutine def _make_factory(self, **kwargs): yield from self.app.startup() self.handler = self.app.make_handler(**kwargs) return self.handler @asyncio.coroutine def _close_hook(self): yield from self.app.shutdown() yield from self.handler.shutdown() yield from self.app.cleanup() class RawTestServer(BaseTestServer): def __init__(self, handler, *, loop=None, scheme=sentinel, host='127.0.0.1'): if loop is None: loop = asyncio.get_event_loop() self._loop = loop self._handler = handler super().__init__(scheme=scheme, host=host) @asyncio.coroutine def _make_factory(self, **kwargs): self.handler = Server(self._handler, loop=self._loop, **kwargs) return self.handler @asyncio.coroutine def _close_hook(self): return class TestClient: """ A test client implementation, for a aiohttp.web.Application. :param app: the aiohttp.web application passed to create_test_server :type app: aiohttp.web.Application :param protocol: http or https :type protocol: str TestClient can also be used as a contextmanager, returning the instance of itself instantiated. """ def __init__(self, app_or_server, *, scheme=sentinel, host=sentinel, cookie_jar=None, **kwargs): if isinstance(app_or_server, BaseTestServer): if scheme is not sentinel or host is not sentinel: raise ValueError("scheme and host are mutable exclusive " "with TestServer parameter") self._server = app_or_server elif isinstance(app_or_server, Application): scheme = "http" if scheme is sentinel else scheme host = '127.0.0.1' if host is sentinel else host self._server = TestServer(app_or_server, scheme=scheme, host=host) else: raise TypeError("app_or_server should be either web.Application " "or TestServer instance") self._loop = self._server._loop if cookie_jar is None: cookie_jar = aiohttp.CookieJar(unsafe=True, loop=self._loop) self._session = ClientSession(loop=self._loop, cookie_jar=cookie_jar, **kwargs) self._closed = False self._responses = [] self._websockets = [] @asyncio.coroutine def start_server(self): yield from self._server.start_server() @property def host(self): return self._server.host @property def port(self): return self._server.port @property def server(self): return self._server @property def session(self): """An internal aiohttp.ClientSession. Unlike the methods on the TestClient, client session requests do not automatically include the host in the url queried, and will require an absolute path to the resource. """ return self._session def make_url(self, path): return self._server.make_url(path) @asyncio.coroutine def request(self, method, path, *args, **kwargs): """Routes a request to tested http server. The interface is identical to asyncio.ClientSession.request, except the loop kwarg is overridden by the instance used by the test server. """ resp = yield from self._session.request( method, self.make_url(path), *args, **kwargs ) # save it to close later self._responses.append(resp) return resp def get(self, path, *args, **kwargs): """Perform an HTTP GET request.""" return _RequestContextManager( self.request(hdrs.METH_GET, path, *args, **kwargs) ) def post(self, path, *args, **kwargs): """Perform an HTTP POST request.""" return _RequestContextManager( self.request(hdrs.METH_POST, path, *args, **kwargs) ) def options(self, path, *args, **kwargs): """Perform an HTTP OPTIONS request.""" return _RequestContextManager( self.request(hdrs.METH_OPTIONS, path, *args, **kwargs) ) def head(self, path, *args, **kwargs): """Perform an HTTP HEAD request.""" return _RequestContextManager( self.request(hdrs.METH_HEAD, path, *args, **kwargs) ) def put(self, path, *args, **kwargs): """Perform an HTTP PUT request.""" return _RequestContextManager( self.request(hdrs.METH_PUT, path, *args, **kwargs) ) def patch(self, path, *args, **kwargs): """Perform an HTTP PATCH request.""" return _RequestContextManager( self.request(hdrs.METH_PATCH, path, *args, **kwargs) ) def delete(self, path, *args, **kwargs): """Perform an HTTP PATCH request.""" return _RequestContextManager( self.request(hdrs.METH_DELETE, path, *args, **kwargs) ) @asyncio.coroutine def ws_connect(self, path, *args, **kwargs): """Initiate websocket connection. The api corresponds to aiohttp.ClientSession.ws_connect. """ ws = yield from self._session.ws_connect( self.make_url(path), *args, **kwargs) self._websockets.append(ws) return ws @asyncio.coroutine def close(self): """Close all fixtures created by the test client. After that point, the TestClient is no longer usable. This is an idempotent function: running close multiple times will not have any additional effects. close is also run on exit when used as a(n) (asynchronous) context manager. """ if not self._closed: for resp in self._responses: resp.close() for ws in self._websockets: yield from ws.close() yield from self._session.close() yield from self._server.close() self._closed = True def __enter__(self): self._loop.run_until_complete(self.start_server()) return self def __exit__(self, exc_type, exc_value, traceback): self._loop.run_until_complete(self.close()) if PY_35: @asyncio.coroutine def __aenter__(self): yield from self.start_server() return self @asyncio.coroutine def __aexit__(self, exc_type, exc_value, traceback): yield from self.close() class AioHTTPTestCase(unittest.TestCase): """A base class to allow for unittest web applications using aiohttp. Provides the following: * self.client (aiohttp.test_utils.TestClient): an aiohttp test client. * self.loop (asyncio.BaseEventLoop): the event loop in which the application and server are running. * self.app (aiohttp.web.Application): the application returned by self.get_app() Note that the TestClient's methods are asynchronous: you have to execute function on the test client using asynchronous methods. """ def get_app(self, loop): """ This method should be overridden to return the aiohttp.web.Application object to test. :param loop: the event_loop to use :type loop: asyncio.BaseEventLoop """ pass # pragma: no cover def setUp(self): self.loop = setup_test_loop() self.app = self.get_app(self.loop) self.client = TestClient(self.app) self.loop.run_until_complete(self.client.start_server()) def tearDown(self): self.loop.run_until_complete(self.client.close()) teardown_test_loop(self.loop) def unittest_run_loop(func): """A decorator dedicated to use with asynchronous methods of an AioHTTPTestCase. Handles executing an asynchronous function, using the self.loop of the AioHTTPTestCase. """ @functools.wraps(func) def new_func(self): return self.loop.run_until_complete(func(self)) return new_func @contextlib.contextmanager def loop_context(loop_factory=asyncio.new_event_loop): """A contextmanager that creates an event_loop, for test purposes. Handles the creation and cleanup of a test loop. """ loop = setup_test_loop(loop_factory) yield loop teardown_test_loop(loop) def setup_test_loop(loop_factory=asyncio.new_event_loop): """Create and return an asyncio.BaseEventLoop instance. The caller should also call teardown_test_loop, once they are done with the loop. """ loop = loop_factory() asyncio.set_event_loop(None) return loop def teardown_test_loop(loop): """Teardown and cleanup an event_loop created by setup_test_loop. :param loop: the loop to teardown :type loop: asyncio.BaseEventLoop """ closed = loop.is_closed() if not closed: loop.call_soon(loop.stop) loop.run_forever() loop.close() gc.collect() asyncio.set_event_loop(None) def _create_app_mock(): app = mock.Mock() app._debug = False app.on_response_prepare = Signal(app) return app def _create_transport(sslcontext=None): transport = mock.Mock() def get_extra_info(key): if key == 'sslcontext': return sslcontext else: return None transport.get_extra_info.side_effect = get_extra_info return transport def make_mocked_request(method, path, headers=None, *, version=HttpVersion(1, 1), closing=False, app=None, reader=sentinel, writer=sentinel, transport=sentinel, payload=sentinel, sslcontext=None, secure_proxy_ssl_header=None): """Creates mocked web.Request testing purposes. Useful in unit tests, when spinning full web server is overkill or specific conditions and errors are hard to trigger. """ if version < HttpVersion(1, 1): closing = True if headers: hdrs = CIMultiDict(headers) raw_hdrs = [ (k.encode('utf-8'), v.encode('utf-8')) for k, v in headers.items()] else: hdrs = CIMultiDict() raw_hdrs = [] message = RawRequestMessage(method, path, version, hdrs, raw_hdrs, closing, False) if app is None: app = _create_app_mock() if reader is sentinel: reader = mock.Mock() if writer is sentinel: writer = mock.Mock() if transport is sentinel: transport = _create_transport(sslcontext) if payload is sentinel: payload = mock.Mock() time_service = mock.Mock() time_service.time.return_value = 12345 time_service.strtime.return_value = "Tue, 15 Nov 1994 08:12:31 GMT" task = mock.Mock() req = Request(message, payload, transport, reader, writer, time_service, task, secure_proxy_ssl_header=secure_proxy_ssl_header) match_info = UrlMappingMatchInfo({}, mock.Mock()) match_info.add_app(app) req._match_info = match_info return req def make_mocked_coro(return_value=sentinel, raise_exception=sentinel): """Creates a coroutine mock.""" @asyncio.coroutine def mock_coro(*args, **kwargs): if raise_exception is not sentinel: raise raise_exception return return_value return mock.Mock(wraps=mock_coro) aiohttp-1.2.0/aiohttp/server.py0000664000175000017500000003277013025134363017367 0ustar travistravis00000000000000"""simple HTTP server.""" import asyncio import http.server import socket import traceback import warnings from contextlib import suppress from html import escape as html_escape import aiohttp from aiohttp import errors, hdrs, helpers, streams from aiohttp.helpers import Timeout, _get_kwarg, ensure_future from aiohttp.log import access_logger, server_logger __all__ = ('ServerHttpProtocol',) RESPONSES = http.server.BaseHTTPRequestHandler.responses DEFAULT_ERROR_MESSAGE = """ {status} {reason}

{status} {reason}

{message} """ if hasattr(socket, 'SO_KEEPALIVE'): def tcp_keepalive(server, transport): sock = transport.get_extra_info('socket') sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) else: def tcp_keepalive(server, transport): # pragma: no cover pass EMPTY_PAYLOAD = streams.EmptyStreamReader() class ServerHttpProtocol(aiohttp.StreamProtocol): """Simple HTTP protocol implementation. ServerHttpProtocol handles incoming HTTP request. It reads request line, request headers and request payload and calls handle_request() method. By default it always returns with 404 response. ServerHttpProtocol handles errors in incoming request, like bad status line, bad headers or incomplete payload. If any error occurs, connection gets closed. :param keepalive_timeout: number of seconds before closing keep-alive connection :type keepalive_timeout: int or None :param bool tcp_keepalive: TCP keep-alive is on, default is on :param int slow_request_timeout: slow request timeout :param bool debug: enable debug mode :param logger: custom logger object :type logger: aiohttp.log.server_logger :param access_log: custom logging object :type access_log: aiohttp.log.server_logger :param str access_log_format: access log format string :param loop: Optional event loop :param int max_line_size: Optional maximum header line size :param int max_field_size: Optional maximum header field size :param int max_headers: Optional maximum header size """ _request_count = 0 _request_handler = None _reading_request = False _keepalive = False # keep transport open def __init__(self, *, loop=None, keepalive_timeout=75, # NGINX default value is 75 secs tcp_keepalive=True, slow_request_timeout=0, logger=server_logger, access_log=access_logger, access_log_format=helpers.AccessLogger.LOG_FORMAT, debug=False, max_line_size=8190, max_headers=32768, max_field_size=8190, lingering_time=30, lingering_timeout=5, **kwargs): # process deprecated params logger = _get_kwarg(kwargs, 'log', 'logger', logger) tcp_keepalive = _get_kwarg(kwargs, 'keep_alive_on', 'tcp_keepalive', tcp_keepalive) keepalive_timeout = _get_kwarg(kwargs, 'keep_alive', 'keepalive_timeout', keepalive_timeout) slow_request_timeout = _get_kwarg(kwargs, 'timeout', 'slow_request_timeout', slow_request_timeout) super().__init__( loop=loop, disconnect_error=errors.ClientDisconnectedError, **kwargs) self._tcp_keepalive = tcp_keepalive self._keepalive_timeout = keepalive_timeout self._slow_request_timeout = slow_request_timeout self._lingering_time = float(lingering_time) self._lingering_timeout = float(lingering_timeout) self._loop = loop if loop is not None else asyncio.get_event_loop() self._request_parser = aiohttp.HttpRequestParser( max_line_size=max_line_size, max_field_size=max_field_size, max_headers=max_headers) self.logger = logger self.debug = debug self.access_log = access_log if access_log: self.access_logger = helpers.AccessLogger(access_log, access_log_format) else: self.access_logger = None self._closing = False @property def keep_alive_timeout(self): warnings.warn("Use keepalive_timeout property instead", DeprecationWarning, stacklevel=2) return self._keepalive_timeout @property def keepalive_timeout(self): return self._keepalive_timeout @asyncio.coroutine def shutdown(self, timeout=15.0): """Worker process is about to exit, we need cleanup everything and stop accepting requests. It is especially important for keep-alive connections.""" if self._request_handler is None: return self._closing = True if self._request_count > 1 and not self._reading_request: # force-close idle keep-alive connections self._request_handler.cancel() elif timeout: canceller = self._loop.call_later(timeout, self._request_handler.cancel) with suppress(asyncio.CancelledError): yield from self._request_handler canceller.cancel() else: self._request_handler.cancel() def connection_made(self, transport): super().connection_made(transport) self._request_handler = ensure_future(self.start(), loop=self._loop) if self._tcp_keepalive: tcp_keepalive(self, transport) def connection_lost(self, exc): super().connection_lost(exc) self._closing = True if self._request_handler is not None: self._request_handler.cancel() def data_received(self, data): super().data_received(data) # we can not gracefully shutdown handler # if we in process of reading request self._reading_request = True def keep_alive(self, val): """Set keep-alive connection mode. :param bool val: new state. """ self._keepalive = val def log_access(self, message, environ, response, time): if self.access_logger: self.access_logger.log(message, environ, response, self.transport, time) def log_debug(self, *args, **kw): if self.debug: self.logger.debug(*args, **kw) def log_exception(self, *args, **kw): self.logger.exception(*args, **kw) @asyncio.coroutine def start(self): """Start processing of incoming requests. It reads request line, request headers and request payload, then calls handle_request() method. Subclass has to override handle_request(). start() handles various exceptions in request or response handling. Connection is being closed always unless keep_alive(True) specified. """ reader = self.reader self.writer.set_tcp_nodelay(True) try: while not self._closing: message = None self._keepalive = False self._request_count += 1 self._reading_request = False payload = None # slow request timer with Timeout(max(self._slow_request_timeout, self._keepalive_timeout), loop=self._loop): # read request headers httpstream = reader.set_parser(self._request_parser) message = yield from httpstream.read() # request may not have payload try: content_length = int( message.headers.get(hdrs.CONTENT_LENGTH, 0)) except ValueError: raise errors.InvalidHeader(hdrs.CONTENT_LENGTH) from None if (content_length > 0 or message.method == hdrs.METH_CONNECT or hdrs.SEC_WEBSOCKET_KEY1 in message.headers or 'chunked' in message.headers.get( hdrs.TRANSFER_ENCODING, '')): payload = streams.FlowControlStreamReader( reader, loop=self._loop) reader.set_parser( aiohttp.HttpPayloadParser(message), payload) else: payload = EMPTY_PAYLOAD yield from self.handle_request(message, payload) if not payload.is_eof(): self.log_debug('Uncompleted request.') self._closing = True if self._lingering_time: self.transport.write_eof() self.log_debug( 'Start lingering close timer for %s sec.', self._lingering_time) end_time = self._loop.time() + self._lingering_time with suppress(asyncio.TimeoutError, errors.ClientDisconnectedError): while self._loop.time() < end_time: with Timeout(self._lingering_timeout, loop=self._loop): # read and ignore yield from payload.readany() else: reader.unset_parser() if not self._keepalive or not self._keepalive_timeout: self._closing = True except asyncio.CancelledError: self.log_debug( 'Request handler cancelled.') return except asyncio.TimeoutError: self.log_debug( 'Request handler timed out.') return except errors.ClientDisconnectedError: self.log_debug( 'Ignored premature client disconnection #1.') return except errors.HttpProcessingError as exc: yield from self.handle_error(exc.code, message, None, exc, exc.headers, exc.message) except Exception as exc: yield from self.handle_error(500, message, None, exc) finally: self._request_handler = None if self.transport is None: self.log_debug( 'Ignored premature client disconnection #2.') else: self.transport.close() def handle_error(self, status=500, message=None, payload=None, exc=None, headers=None, reason=None): """Handle errors. Returns HTTP response with specific status code. Logs additional information. It always closes current connection.""" now = self._loop.time() try: if self.transport is None: # client has been disconnected during writing. return () if status == 500: self.log_exception("Error handling request") try: if reason is None or reason == '': reason, msg = RESPONSES[status] else: msg = reason except KeyError: status = 500 reason, msg = '???', '' if self.debug and exc is not None: try: tb = traceback.format_exc() tb = html_escape(tb) msg += '

Traceback:

\n
{}
'.format(tb) except: pass html = DEFAULT_ERROR_MESSAGE.format( status=status, reason=reason, message=msg).encode('utf-8') response = aiohttp.Response(self.writer, status, close=True) response.add_header(hdrs.CONTENT_TYPE, 'text/html; charset=utf-8') response.add_header(hdrs.CONTENT_LENGTH, str(len(html))) if headers is not None: for name, value in headers: response.add_header(name, value) response.send_headers() response.write(html) # disable CORK, enable NODELAY if needed self.writer.set_tcp_nodelay(True) drain = response.write_eof() self.log_access(message, None, response, self._loop.time() - now) return drain finally: self.keep_alive(False) def handle_request(self, message, payload): """Handle a single HTTP request. Subclass should override this method. By default it always returns 404 response. :param message: Request headers :type message: aiohttp.protocol.HttpRequestParser :param payload: Request payload :type payload: aiohttp.streams.FlowControlStreamReader """ now = self._loop.time() response = aiohttp.Response( self.writer, 404, http_version=message.version, close=True) body = b'Page Not Found!' response.add_header(hdrs.CONTENT_TYPE, 'text/plain') response.add_header(hdrs.CONTENT_LENGTH, str(len(body))) response.send_headers() response.write(body) drain = response.write_eof() self.keep_alive(False) self.log_access(message, None, response, self._loop.time() - now) return drain aiohttp-1.2.0/aiohttp/streams.py0000664000175000017500000004476413025134363017545 0ustar travistravis00000000000000import asyncio import collections import functools import sys import traceback from . import helpers from .log import internal_logger __all__ = ( 'EofStream', 'StreamReader', 'DataQueue', 'ChunksQueue', 'FlowControlStreamReader', 'FlowControlDataQueue', 'FlowControlChunksQueue') PY_35 = sys.version_info >= (3, 5) PY_352 = sys.version_info >= (3, 5, 2) DEFAULT_LIMIT = 2 ** 16 class EofStream(Exception): """eof stream indication.""" if PY_35: class AsyncStreamIterator: def __init__(self, read_func): self.read_func = read_func def __aiter__(self): return self if not PY_352: # pragma: no cover __aiter__ = asyncio.coroutine(__aiter__) @asyncio.coroutine def __anext__(self): try: rv = yield from self.read_func() except EofStream: raise StopAsyncIteration # NOQA if rv == b'': raise StopAsyncIteration # NOQA return rv class AsyncStreamReaderMixin: if PY_35: def __aiter__(self): return AsyncStreamIterator(self.readline) if not PY_352: # pragma: no cover __aiter__ = asyncio.coroutine(__aiter__) def iter_chunked(self, n): """Returns an asynchronous iterator that yields chunks of size n. Python-3.5 available for Python 3.5+ only """ return AsyncStreamIterator(lambda: self.read(n)) def iter_any(self): """Returns an asynchronous iterator that yields slices of data as they come. Python-3.5 available for Python 3.5+ only """ return AsyncStreamIterator(self.readany) class StreamReader(AsyncStreamReaderMixin): """An enhancement of asyncio.StreamReader. Supports asynchronous iteration by line, chunk or as available:: async for line in reader: ... async for chunk in reader.iter_chunked(1024): ... async for slice in reader.iter_any(): ... """ total_bytes = 0 def __init__(self, limit=DEFAULT_LIMIT, timeout=None, loop=None): self._limit = limit if loop is None: loop = asyncio.get_event_loop() self._loop = loop self._buffer = collections.deque() self._buffer_size = 0 self._buffer_offset = 0 self._eof = False self._waiter = None self._canceller = None self._eof_waiter = None self._exception = None self._timeout = timeout def __repr__(self): info = ['StreamReader'] if self._buffer_size: info.append('%d bytes' % self._buffer_size) if self._eof: info.append('eof') if self._limit != DEFAULT_LIMIT: info.append('l=%d' % self._limit) if self._waiter: info.append('w=%r' % self._waiter) if self._exception: info.append('e=%r' % self._exception) return '<%s>' % ' '.join(info) def exception(self): return self._exception def set_exception(self, exc): self._exception = exc waiter = self._waiter if waiter is not None: self._waiter = None if not waiter.cancelled(): waiter.set_exception(exc) canceller = self._canceller if canceller is not None: self._canceller = None canceller.cancel() def feed_eof(self): self._eof = True waiter = self._waiter if waiter is not None: self._waiter = None if not waiter.cancelled(): waiter.set_result(True) canceller = self._canceller if canceller is not None: self._canceller = None canceller.cancel() waiter = self._eof_waiter if waiter is not None: self._eof_waiter = None if not waiter.cancelled(): waiter.set_result(True) def is_eof(self): """Return True if 'feed_eof' was called.""" return self._eof def at_eof(self): """Return True if the buffer is empty and 'feed_eof' was called.""" return self._eof and not self._buffer @asyncio.coroutine def wait_eof(self): if self._eof: return assert self._eof_waiter is None self._eof_waiter = helpers.create_future(self._loop) try: yield from self._eof_waiter finally: self._eof_waiter = None def unread_data(self, data): """ rollback reading some data from stream, inserting it to buffer head. """ if not data: return if self._buffer_offset: self._buffer[0] = self._buffer[0][self._buffer_offset:] self._buffer_offset = 0 self._buffer.appendleft(data) self._buffer_size += len(data) def feed_data(self, data): assert not self._eof, 'feed_data after feed_eof' if not data: return self._buffer.append(data) self._buffer_size += len(data) self.total_bytes += len(data) waiter = self._waiter if waiter is not None: self._waiter = None if not waiter.cancelled(): waiter.set_result(False) canceller = self._canceller if canceller is not None: self._canceller = None canceller.cancel() @asyncio.coroutine def _wait(self, func_name): # StreamReader uses a future to link the protocol feed_data() method # to a read coroutine. Running two read coroutines at the same time # would have an unexpected behaviour. It would not possible to know # which coroutine would get the next data. if self._waiter is not None: raise RuntimeError('%s() called while another coroutine is ' 'already waiting for incoming data' % func_name) waiter = self._waiter = helpers.create_future(self._loop) if self._timeout: self._canceller = self._loop.call_later(self._timeout, self.set_exception, asyncio.TimeoutError()) try: yield from waiter finally: self._waiter = None if self._canceller is not None: self._canceller.cancel() self._canceller = None @asyncio.coroutine def readline(self): if self._exception is not None: raise self._exception line = [] line_size = 0 not_enough = True while not_enough: while self._buffer and not_enough: offset = self._buffer_offset ichar = self._buffer[0].find(b'\n', offset) + 1 # Read from current offset to found b'\n' or to the end. data = self._read_nowait_chunk(ichar - offset if ichar else -1) line.append(data) line_size += len(data) if ichar: not_enough = False if line_size > self._limit: raise ValueError('Line is too long') if self._eof: break if not_enough: yield from self._wait('readline') return b''.join(line) @asyncio.coroutine def read(self, n=-1): if self._exception is not None: raise self._exception # migration problem; with DataQueue you have to catch # EofStream exception, so common way is to run payload.read() inside # infinite loop. what can cause real infinite loop with StreamReader # lets keep this code one major release. if __debug__: if self._eof and not self._buffer: self._eof_counter = getattr(self, '_eof_counter', 0) + 1 if self._eof_counter > 5: stack = traceback.format_stack() internal_logger.warning( 'Multiple access to StreamReader in eof state, ' 'might be infinite loop: \n%s', stack) if not n: return b'' if n < 0: # This used to just loop creating a new waiter hoping to # collect everything in self._buffer, but that would # deadlock if the subprocess sends more than self.limit # bytes. So just call self.readany() until EOF. blocks = [] while True: block = yield from self.readany() if not block: break blocks.append(block) return b''.join(blocks) if not self._buffer and not self._eof: yield from self._wait('read') return self._read_nowait(n) @asyncio.coroutine def readany(self): if self._exception is not None: raise self._exception if not self._buffer and not self._eof: yield from self._wait('readany') return self._read_nowait(-1) @asyncio.coroutine def readexactly(self, n): if self._exception is not None: raise self._exception blocks = [] while n > 0: block = yield from self.read(n) if not block: partial = b''.join(blocks) raise asyncio.streams.IncompleteReadError( partial, len(partial) + n) blocks.append(block) n -= len(block) return b''.join(blocks) def read_nowait(self, n=-1): # default was changed to be consistent with .read(-1) # # I believe the most users don't know about the method and # they are not affected. assert n is not None, "n should be -1" if self._exception is not None: raise self._exception if self._waiter and not self._waiter.done(): raise RuntimeError( 'Called while some coroutine is waiting for incoming data.') return self._read_nowait(n) def _read_nowait_chunk(self, n): first_buffer = self._buffer[0] offset = self._buffer_offset if n != -1 and len(first_buffer) - offset > n: data = first_buffer[offset:offset + n] self._buffer_offset += n elif offset: self._buffer.popleft() data = first_buffer[offset:] self._buffer_offset = 0 else: data = self._buffer.popleft() self._buffer_size -= len(data) return data def _read_nowait(self, n): chunks = [] while self._buffer: chunk = self._read_nowait_chunk(n) chunks.append(chunk) if n != -1: n -= len(chunk) if n == 0: break return b''.join(chunks) if chunks else b'' class EmptyStreamReader(AsyncStreamReaderMixin): def exception(self): return None def set_exception(self, exc): pass def feed_eof(self): pass def is_eof(self): return True def at_eof(self): return True @asyncio.coroutine def wait_eof(self): return def feed_data(self, data): pass @asyncio.coroutine def readline(self): return b'' @asyncio.coroutine def read(self, n=-1): return b'' @asyncio.coroutine def readany(self): return b'' @asyncio.coroutine def readexactly(self, n): raise asyncio.streams.IncompleteReadError(b'', n) def read_nowait(self): return b'' class DataQueue: """DataQueue is a general-purpose blocking queue with one reader.""" def __init__(self, *, loop=None): self._loop = loop self._eof = False self._waiter = None self._exception = None self._size = 0 self._buffer = collections.deque() def is_eof(self): return self._eof def at_eof(self): return self._eof and not self._buffer def exception(self): return self._exception def set_exception(self, exc): self._exception = exc waiter = self._waiter if waiter is not None: self._waiter = None if not waiter.done(): waiter.set_exception(exc) def feed_data(self, data, size=0): self._size += size self._buffer.append((data, size)) waiter = self._waiter if waiter is not None: self._waiter = None if not waiter.cancelled(): waiter.set_result(True) def feed_eof(self): self._eof = True waiter = self._waiter if waiter is not None: self._waiter = None if not waiter.cancelled(): waiter.set_result(False) @asyncio.coroutine def read(self): if not self._buffer and not self._eof: if self._exception is not None: raise self._exception assert not self._waiter self._waiter = helpers.create_future(self._loop) try: yield from self._waiter except (asyncio.CancelledError, asyncio.TimeoutError): self._waiter = None raise if self._buffer: data, size = self._buffer.popleft() self._size -= size return data else: if self._exception is not None: raise self._exception else: raise EofStream if PY_35: def __aiter__(self): return AsyncStreamIterator(self.read) if not PY_352: # pragma: no cover __aiter__ = asyncio.coroutine(__aiter__) class ChunksQueue(DataQueue): """Like a :class:`DataQueue`, but for binary chunked data transfer.""" @asyncio.coroutine def read(self): try: return (yield from super().read()) except EofStream: return b'' readany = read def maybe_resume(func): if asyncio.iscoroutinefunction(func): @asyncio.coroutine @functools.wraps(func) def wrapper(self, *args, **kw): result = yield from func(self, *args, **kw) self._check_buffer_size() return result else: @functools.wraps(func) def wrapper(self, *args, **kw): result = func(self, *args, **kw) self._check_buffer_size() return result return wrapper class FlowControlStreamReader(StreamReader): def __init__(self, stream, limit=DEFAULT_LIMIT, *args, **kwargs): super().__init__(*args, **kwargs) self._stream = stream self._b_limit = limit * 2 # resume transport reading if stream.paused: try: self._stream.transport.resume_reading() except (AttributeError, NotImplementedError): pass else: self._stream.paused = False def _check_buffer_size(self): if self._stream.paused: if self._buffer_size < self._b_limit: try: self._stream.transport.resume_reading() except (AttributeError, NotImplementedError): pass else: self._stream.paused = False else: if self._buffer_size > self._b_limit: try: self._stream.transport.pause_reading() except (AttributeError, NotImplementedError): pass else: self._stream.paused = True def feed_data(self, data, size=0): has_waiter = self._waiter is not None and not self._waiter.cancelled() super().feed_data(data) if (not self._stream.paused and not has_waiter and self._buffer_size > self._b_limit): try: self._stream.transport.pause_reading() except (AttributeError, NotImplementedError): pass else: self._stream.paused = True @maybe_resume @asyncio.coroutine def read(self, n=-1): return (yield from super().read(n)) @maybe_resume @asyncio.coroutine def readline(self): return (yield from super().readline()) @maybe_resume @asyncio.coroutine def readany(self): return (yield from super().readany()) @maybe_resume @asyncio.coroutine def readexactly(self, n): return (yield from super().readexactly(n)) @maybe_resume def read_nowait(self, n=-1): return super().read_nowait(n) class FlowControlDataQueue(DataQueue): """FlowControlDataQueue resumes and pauses an underlying stream. It is a destination for parsed data.""" def __init__(self, stream, *, limit=DEFAULT_LIMIT, loop=None): super().__init__(loop=loop) self._stream = stream self._limit = limit * 2 # resume transport reading if stream.paused: try: self._stream.transport.resume_reading() except (AttributeError, NotImplementedError): pass else: self._stream.paused = False def feed_data(self, data, size): has_waiter = self._waiter is not None and not self._waiter.cancelled() super().feed_data(data, size) if (not self._stream.paused and not has_waiter and self._size > self._limit): try: self._stream.transport.pause_reading() except (AttributeError, NotImplementedError): pass else: self._stream.paused = True @asyncio.coroutine def read(self): result = yield from super().read() if self._stream.paused: if self._size < self._limit: try: self._stream.transport.resume_reading() except (AttributeError, NotImplementedError): pass else: self._stream.paused = False else: if self._size > self._limit: try: self._stream.transport.pause_reading() except (AttributeError, NotImplementedError): pass else: self._stream.paused = True return result class FlowControlChunksQueue(FlowControlDataQueue): @asyncio.coroutine def read(self): try: return (yield from super().read()) except EofStream: return b'' readany = read aiohttp-1.2.0/aiohttp/resolver.py0000664000175000017500000000553713025134363017723 0ustar travistravis00000000000000import asyncio import socket from .abc import AbstractResolver __all__ = ('ThreadedResolver', 'AsyncResolver', 'DefaultResolver') try: import aiodns # aiodns_default = hasattr(aiodns.DNSResolver, 'gethostbyname') except ImportError: # pragma: no cover aiodns = None aiodns_default = False class ThreadedResolver(AbstractResolver): """Use Executor for synchronous getaddrinfo() calls, which defaults to concurrent.futures.ThreadPoolExecutor. """ def __init__(self, loop=None): if loop is None: loop = asyncio.get_event_loop() self._loop = loop @asyncio.coroutine def resolve(self, host, port=0, family=socket.AF_INET): infos = yield from self._loop.getaddrinfo( host, port, type=socket.SOCK_STREAM, family=family) hosts = [] for family, _, proto, _, address in infos: hosts.append( {'hostname': host, 'host': address[0], 'port': address[1], 'family': family, 'proto': proto, 'flags': socket.AI_NUMERICHOST}) return hosts @asyncio.coroutine def close(self): pass class AsyncResolver(AbstractResolver): """Use the `aiodns` package to make asynchronous DNS lookups""" def __init__(self, loop=None, *args, **kwargs): if loop is None: loop = asyncio.get_event_loop() if aiodns is None: raise RuntimeError("Resolver requires aiodns library") self._loop = loop self._resolver = aiodns.DNSResolver(*args, loop=loop, **kwargs) if not hasattr(self._resolver, 'gethostbyname'): # aiodns 1.1 is not available, fallback to DNSResolver.query self.resolve = self.resolve_with_query @asyncio.coroutine def resolve(self, host, port=0, family=socket.AF_INET): hosts = [] resp = yield from self._resolver.gethostbyname(host, family) for address in resp.addresses: hosts.append( {'hostname': host, 'host': address, 'port': port, 'family': family, 'proto': 0, 'flags': socket.AI_NUMERICHOST}) return hosts @asyncio.coroutine def resolve_with_query(self, host, port=0, family=socket.AF_INET): if family == socket.AF_INET6: qtype = 'AAAA' else: qtype = 'A' hosts = [] resp = yield from self._resolver.query(host, qtype) for rr in resp: hosts.append( {'hostname': host, 'host': rr.host, 'port': port, 'family': family, 'proto': 0, 'flags': socket.AI_NUMERICHOST}) return hosts @asyncio.coroutine def close(self): return self._resolver.cancel() DefaultResolver = AsyncResolver if aiodns_default else ThreadedResolver aiohttp-1.2.0/aiohttp/_websocket.pyx0000664000175000017500000000257613025134363020377 0ustar travistravis00000000000000from cpython cimport PyBytes_AsString #from cpython cimport PyByteArray_AsString # cython still not exports that cdef extern from "Python.h": char* PyByteArray_AsString(bytearray ba) except NULL from libc.stdint cimport uint32_t, uint64_t, uintmax_t def _websocket_mask_cython(bytes mask, bytearray data): """Note, this function mutates it's `data` argument """ cdef: Py_ssize_t data_len, i # bit operations on signed integers are implementation-specific unsigned char * in_buf const unsigned char * mask_buf uint32_t uint32_msk uint64_t uint64_msk assert len(mask) == 4 data_len = len(data) in_buf = PyByteArray_AsString(data) mask_buf = PyBytes_AsString(mask) uint32_msk = (mask_buf)[0] # TODO: align in_data ptr to achieve even faster speeds # does it need in python ?! malloc() always aligns to sizeof(long) bytes if sizeof(size_t) >= 8: uint64_msk = uint32_msk uint64_msk = (uint64_msk << 32) | uint32_msk while data_len >= 8: (in_buf)[0] ^= uint64_msk in_buf += 8 data_len -= 8 while data_len >= 4: (in_buf)[0] ^= uint32_msk in_buf += 4 data_len -= 4 for i in range(0, data_len): in_buf[i] ^= mask_buf[i] return data aiohttp-1.2.0/aiohttp/file_sender.py0000664000175000017500000001470113025134363020332 0ustar travistravis00000000000000import asyncio import mimetypes import os from . import hdrs from .helpers import create_future from .web_exceptions import (HTTPNotModified, HTTPOk, HTTPPartialContent, HTTPRequestRangeNotSatisfiable) from .web_reqrep import StreamResponse class FileSender: """"A helper that can be used to send files. """ def __init__(self, *, resp_factory=StreamResponse, chunk_size=256*1024): self._response_factory = resp_factory self._chunk_size = chunk_size if bool(os.environ.get("AIOHTTP_NOSENDFILE")): self._sendfile = self._sendfile_fallback def _sendfile_cb(self, fut, out_fd, in_fd, offset, count, loop, registered): if registered: loop.remove_writer(out_fd) if fut.cancelled(): return try: n = os.sendfile(out_fd, in_fd, offset, count) if n == 0: # EOF reached n = count except (BlockingIOError, InterruptedError): n = 0 except Exception as exc: fut.set_exception(exc) return if n < count: loop.add_writer(out_fd, self._sendfile_cb, fut, out_fd, in_fd, offset + n, count - n, loop, True) else: fut.set_result(None) @asyncio.coroutine def _sendfile_system(self, request, resp, fobj, count): # Write count bytes of fobj to resp using # the os.sendfile system call. # # request should be a aiohttp.web.Request instance. # # resp should be a aiohttp.web.StreamResponse instance. # # fobj should be an open file object. # # count should be an integer > 0. transport = request.transport if transport.get_extra_info("sslcontext"): yield from self._sendfile_fallback(request, resp, fobj, count) return def _send_headers(resp_impl): # Durty hack required for # https://github.com/KeepSafe/aiohttp/issues/1093 # don't send headers in sendfile mode pass resp._send_headers = _send_headers @asyncio.coroutine def write_eof(): # Durty hack required for # https://github.com/KeepSafe/aiohttp/issues/1177 # do nothing in write_eof pass resp.write_eof = write_eof resp_impl = yield from resp.prepare(request) loop = request.app.loop # See https://github.com/KeepSafe/aiohttp/issues/958 for details # send headers headers = ['HTTP/{0.major}.{0.minor} {1} OK\r\n'.format( request.version, resp.status)] for hdr, val in resp.headers.items(): headers.append('{}: {}\r\n'.format(hdr, val)) headers.append('\r\n') out_socket = transport.get_extra_info("socket").dup() out_socket.setblocking(False) out_fd = out_socket.fileno() in_fd = fobj.fileno() offset = fobj.tell() bheaders = ''.join(headers).encode('utf-8') headers_length = len(bheaders) resp_impl.headers_length = headers_length resp_impl.output_length = headers_length + count try: yield from loop.sock_sendall(out_socket, bheaders) fut = create_future(loop) self._sendfile_cb(fut, out_fd, in_fd, offset, count, loop, False) yield from fut finally: out_socket.close() @asyncio.coroutine def _sendfile_fallback(self, request, resp, fobj, count): # Mimic the _sendfile_system() method, but without using the # os.sendfile() system call. This should be used on systems # that don't support the os.sendfile(). # To avoid blocking the event loop & to keep memory usage low, # fobj is transferred in chunks controlled by the # constructor's chunk_size argument. yield from resp.prepare(request) resp.set_tcp_cork(True) try: chunk_size = self._chunk_size chunk = fobj.read(chunk_size) while True: resp.write(chunk) yield from resp.drain() count = count - chunk_size if count <= 0: break chunk = fobj.read(min(chunk_size, count)) finally: resp.set_tcp_nodelay(True) if hasattr(os, "sendfile"): # pragma: no cover _sendfile = _sendfile_system else: # pragma: no cover _sendfile = _sendfile_fallback @asyncio.coroutine def send(self, request, filepath): """Send filepath to client using request.""" gzip = False if 'gzip' in request.headers.get(hdrs.ACCEPT_ENCODING, ''): gzip_path = filepath.with_name(filepath.name + '.gz') if gzip_path.is_file(): filepath = gzip_path gzip = True st = filepath.stat() modsince = request.if_modified_since if modsince is not None and st.st_mtime <= modsince.timestamp(): raise HTTPNotModified() ct, encoding = mimetypes.guess_type(str(filepath)) if not ct: ct = 'application/octet-stream' status = HTTPOk.status_code file_size = st.st_size count = file_size try: rng = request.http_range start = rng.start end = rng.stop except ValueError: raise HTTPRequestRangeNotSatisfiable # If a range request has been made, convert start, end slice notation # into file pointer offset and count if start is not None or end is not None: status = HTTPPartialContent.status_code if start is None and end < 0: # return tail of file start = file_size + end count = -end else: count = (end or file_size) - start if start + count > file_size: raise HTTPRequestRangeNotSatisfiable resp = self._response_factory(status=status) resp.content_type = ct if encoding: resp.headers[hdrs.CONTENT_ENCODING] = encoding if gzip: resp.headers[hdrs.VARY] = hdrs.ACCEPT_ENCODING resp.last_modified = st.st_mtime resp.content_length = count with filepath.open('rb') as f: if start: f.seek(start) yield from self._sendfile(request, resp, f, count) return resp aiohttp-1.2.0/aiohttp/errors.py0000664000175000017500000001044713025134363017372 0ustar travistravis00000000000000"""HTTP related errors.""" from asyncio import TimeoutError __all__ = ( 'DisconnectedError', 'ClientDisconnectedError', 'ServerDisconnectedError', 'HttpProcessingError', 'BadHttpMessage', 'HttpMethodNotAllowed', 'HttpBadRequest', 'HttpProxyError', 'BadStatusLine', 'LineTooLong', 'InvalidHeader', 'ClientError', 'ClientHttpProcessingError', 'ClientConnectionError', 'ClientOSError', 'ClientTimeoutError', 'ProxyConnectionError', 'ClientRequestError', 'ClientResponseError', 'FingerprintMismatch', 'WSServerHandshakeError') class DisconnectedError(Exception): """Disconnected.""" class ClientDisconnectedError(DisconnectedError): """Client disconnected.""" class ServerDisconnectedError(DisconnectedError): """Server disconnected.""" class ClientError(Exception): """Base class for client connection errors.""" class ClientHttpProcessingError(ClientError): """Base class for client HTTP processing errors.""" class ClientRequestError(ClientHttpProcessingError): """Connection error during sending request.""" class ClientResponseError(ClientHttpProcessingError): """Connection error during reading response.""" class ClientConnectionError(ClientError): """Base class for client socket errors.""" class ClientOSError(ClientConnectionError, OSError): """OSError error.""" class ClientTimeoutError(ClientConnectionError, TimeoutError): """Client connection timeout error.""" class ProxyConnectionError(ClientConnectionError): """Proxy connection error. Raised in :class:`aiohttp.connector.ProxyConnector` if connection to proxy can not be established. """ class HttpProcessingError(Exception): """HTTP error. Shortcut for raising HTTP errors with custom code, message and headers. :param int code: HTTP Error code. :param str message: (optional) Error message. :param list of [tuple] headers: (optional) Headers to be sent in response. """ code = 0 message = '' headers = None def __init__(self, *, code=None, message='', headers=None): if code is not None: self.code = code self.headers = headers self.message = message super().__init__("%s, message='%s'" % (self.code, message)) class WSServerHandshakeError(HttpProcessingError): """websocket server handshake error.""" class HttpProxyError(HttpProcessingError): """HTTP proxy error. Raised in :class:`aiohttp.connector.ProxyConnector` if proxy responds with status other than ``200 OK`` on ``CONNECT`` request. """ class BadHttpMessage(HttpProcessingError): code = 400 message = 'Bad Request' def __init__(self, message, *, headers=None): super().__init__(message=message, headers=headers) class HttpMethodNotAllowed(HttpProcessingError): code = 405 message = 'Method Not Allowed' class HttpBadRequest(BadHttpMessage): code = 400 message = 'Bad Request' class ContentEncodingError(BadHttpMessage): """Content encoding error.""" class TransferEncodingError(BadHttpMessage): """transfer encoding error.""" class LineTooLong(BadHttpMessage): def __init__(self, line, limit='Unknown'): super().__init__( "Got more than %s bytes when reading %s." % (limit, line)) class InvalidHeader(BadHttpMessage): def __init__(self, hdr): if isinstance(hdr, bytes): hdr = hdr.decode('utf-8', 'surrogateescape') super().__init__('Invalid HTTP Header: {}'.format(hdr)) self.hdr = hdr class BadStatusLine(BadHttpMessage): def __init__(self, line=''): if not line: line = repr(line) self.args = line, self.line = line class LineLimitExceededParserError(HttpBadRequest): """Line is too long.""" def __init__(self, msg, limit): super().__init__(msg) self.limit = limit class FingerprintMismatch(ClientConnectionError): """SSL certificate does not match expected fingerprint.""" def __init__(self, expected, got, host, port): self.expected = expected self.got = got self.host = host self.port = port def __repr__(self): return '<{} expected={} got={} host={} port={}>'.format( self.__class__.__name__, self.expected, self.got, self.host, self.port) aiohttp-1.2.0/aiohttp/web_reqrep.py0000664000175000017500000010053613025134363020210 0ustar travistravis00000000000000import asyncio import binascii import cgi import collections import datetime import enum import io import json import math import re import time import warnings from email.utils import parsedate from http.cookies import SimpleCookie from types import MappingProxyType from multidict import CIMultiDict, CIMultiDictProxy, MultiDict, MultiDictProxy from yarl import URL from . import hdrs, multipart from .helpers import HeadersMixin, reify, sentinel from .protocol import WebResponse as ResponseImpl from .protocol import HttpVersion10, HttpVersion11 __all__ = ( 'ContentCoding', 'BaseRequest', 'Request', 'StreamResponse', 'Response', 'json_response' ) FileField = collections.namedtuple('Field', 'name filename file content_type') class ContentCoding(enum.Enum): # The content codings that we have support for. # # Additional registered codings are listed at: # https://www.iana.org/assignments/http-parameters/http-parameters.xhtml#content-coding deflate = 'deflate' gzip = 'gzip' identity = 'identity' ############################################################ # HTTP Request ############################################################ class BaseRequest(collections.MutableMapping, HeadersMixin): POST_METHODS = {hdrs.METH_PATCH, hdrs.METH_POST, hdrs.METH_PUT, hdrs.METH_TRACE, hdrs.METH_DELETE} def __init__(self, message, payload, transport, reader, writer, time_service, task, *, secure_proxy_ssl_header=None): self._message = message self._transport = transport self._reader = reader self._writer = writer self._post = None self._post_files_cache = None self._payload = payload self._read_bytes = None self._has_body = not payload.at_eof() self._secure_proxy_ssl_header = secure_proxy_ssl_header self._time_service = time_service self._state = {} self._cache = {} self._task = task def clone(self, *, method=sentinel, rel_url=sentinel, headers=sentinel): """Clone itself with replacement some attributes. Creates and returns a new instance of Request object. If no parameters are given, an exact copy is returned. If a parameter is not passed, it will reuse the one from the current request object. """ if self._read_bytes: raise RuntimeError("Cannot clone request " "after reading it's content") dct = {} if method is not sentinel: dct['method'] = method if rel_url is not sentinel: dct['path'] = str(URL(rel_url)) if headers is not sentinel: dct['headers'] = CIMultiDict(headers) dct['raw_headers'] = [(k.encode('utf-8'), v.encode('utf-8')) for k, v in headers.items()] message = self._message._replace(**dct) return self.__class__( message, self._payload, self._transport, self._reader, self._writer, self._time_service, self._task, secure_proxy_ssl_header=self._secure_proxy_ssl_header) # MutableMapping API def __getitem__(self, key): return self._state[key] def __setitem__(self, key, value): self._state[key] = value def __delitem__(self, key): del self._state[key] def __len__(self): return len(self._state) def __iter__(self): return iter(self._state) ######## @reify def scheme(self): """A string representing the scheme of the request. 'http' or 'https'. """ warnings.warn("path_qs property is deprecated, " "use .url.scheme instead", DeprecationWarning) return self.url.scheme @reify def _scheme(self): if self._transport.get_extra_info('sslcontext'): return 'https' secure_proxy_ssl_header = self._secure_proxy_ssl_header if secure_proxy_ssl_header is not None: header, value = secure_proxy_ssl_header if self.headers.get(header) == value: return 'https' return 'http' @reify def method(self): """Read only property for getting HTTP method. The value is upper-cased str like 'GET', 'POST', 'PUT' etc. """ return self._message.method @reify def version(self): """Read only property for getting HTTP version of request. Returns aiohttp.protocol.HttpVersion instance. """ return self._message.version @reify def host(self): """Read only property for getting *HOST* header of request. Returns str or None if HTTP request has no HOST header. """ warnings.warn("host property is deprecated, " "use .url.host instead", DeprecationWarning) return self._message.headers.get(hdrs.HOST) @reify def rel_url(self): return URL(self._message.path) @reify def path_qs(self): """The URL including PATH_INFO and the query string. E.g, /app/blog?id=10 """ warnings.warn("path_qs property is deprecated, " "use str(request.rel_url) instead", DeprecationWarning) return str(self.rel_url) @reify def url(self): return URL('{}://{}{}'.format(self._scheme, self._message.headers.get(hdrs.HOST), str(self.rel_url))) @reify def raw_path(self): """ The URL including raw *PATH INFO* without the host or scheme. Warning, the path is unquoted and may contains non valid URL characters E.g., ``/my%2Fpath%7Cwith%21some%25strange%24characters`` """ warnings.warn("raw_path property is deprecated, " "use .rel_url.raw_path instead", DeprecationWarning) return self.rel_url.raw_path @reify def path(self): """The URL including *PATH INFO* without the host or scheme. E.g., ``/app/blog`` """ warnings.warn("path property is deprecated, use .rel_url.path instead", DeprecationWarning) return self.rel_url.path @reify def query_string(self): """The query string in the URL. E.g., id=10 """ warnings.warn("query_string property is deprecated, " "use .rel_url.query_string instead", DeprecationWarning) return self.rel_url.query_string @reify def GET(self): """A multidict with all the variables in the query string. Lazy property. """ warnings.warn("GET property is deprecated, use .rel_url.query instead", DeprecationWarning) return self.rel_url.query @reify def POST(self): """A multidict with all the variables in the POST parameters. post() methods has to be called before using this attribute. """ warnings.warn("POST property is deprecated, use .post() instead", DeprecationWarning) if self._post is None: raise RuntimeError("POST is not available before post()") return self._post @reify def headers(self): """A case-insensitive multidict proxy with all headers.""" return CIMultiDictProxy(self._message.headers) @reify def raw_headers(self): """A sequence of pars for all headers.""" return tuple(self._message.raw_headers) @reify def if_modified_since(self, _IF_MODIFIED_SINCE=hdrs.IF_MODIFIED_SINCE): """The value of If-Modified-Since HTTP header, or None. This header is represented as a `datetime` object. """ httpdate = self.headers.get(_IF_MODIFIED_SINCE) if httpdate is not None: timetuple = parsedate(httpdate) if timetuple is not None: return datetime.datetime(*timetuple[:6], tzinfo=datetime.timezone.utc) return None @property def keep_alive(self): """Is keepalive enabled by client?""" return not self._message.should_close @property def transport(self): """Transport used for request processing.""" return self._transport @reify def cookies(self): """Return request cookies. A read-only dictionary-like object. """ raw = self.headers.get(hdrs.COOKIE, '') parsed = SimpleCookie(raw) return MappingProxyType( {key: val.value for key, val in parsed.items()}) @property def http_range(self, *, _RANGE=hdrs.RANGE): """The content of Range HTTP header. Return a slice instance. """ rng = self.headers.get(_RANGE) start, end = None, None if rng is not None: try: pattern = r'^bytes=(\d*)-(\d*)$' start, end = re.findall(pattern, rng)[0] except IndexError: # pattern was not found in header raise ValueError("range not in acceptible format") end = int(end) if end else None start = int(start) if start else None if start is None and end is not None: # end with no start is to return tail of content end = -end if start is not None and end is not None: # end is inclusive in range header, exclusive for slice end += 1 if start >= end: raise ValueError('start cannot be after end') if start is end is None: # No valid range supplied raise ValueError('No start or end of range specified') return slice(start, end, 1) @property def content(self): """Return raw payload stream.""" return self._payload @property def has_body(self): """Return True if request has HTTP BODY, False otherwise.""" return self._has_body @asyncio.coroutine def release(self): """Release request. Eat unread part of HTTP BODY if present. """ while not self._payload.at_eof(): yield from self._payload.readany() @asyncio.coroutine def read(self): """Read request body if present. Returns bytes object with full request content. """ if self._read_bytes is None: body = bytearray() while True: chunk = yield from self._payload.readany() body.extend(chunk) if not chunk: break self._read_bytes = bytes(body) return self._read_bytes @asyncio.coroutine def text(self): """Return BODY as text using encoding from .charset.""" bytes_body = yield from self.read() encoding = self.charset or 'utf-8' return bytes_body.decode(encoding) @asyncio.coroutine def json(self, *, loads=json.loads, loader=None): """Return BODY as JSON.""" if loader is not None: warnings.warn( "Using loader argument is deprecated, use loads instead", DeprecationWarning) loads = loader body = yield from self.text() return loads(body) @asyncio.coroutine def multipart(self, *, reader=multipart.MultipartReader): """Return async iterator to process BODY as multipart.""" return reader(self.headers, self.content) @asyncio.coroutine def post(self): """Return POST parameters.""" if self._post is not None: return self._post if self.method not in self.POST_METHODS: self._post = MultiDictProxy(MultiDict()) return self._post content_type = self.content_type if (content_type not in ('', 'application/x-www-form-urlencoded', 'multipart/form-data')): self._post = MultiDictProxy(MultiDict()) return self._post if self.content_type.startswith('multipart/'): warnings.warn('To process multipart requests use .multipart' ' coroutine instead.', DeprecationWarning) body = yield from self.read() content_charset = self.charset or 'utf-8' environ = {'REQUEST_METHOD': self.method, 'CONTENT_LENGTH': str(len(body)), 'QUERY_STRING': '', 'CONTENT_TYPE': self.headers.get(hdrs.CONTENT_TYPE)} fs = cgi.FieldStorage(fp=io.BytesIO(body), environ=environ, keep_blank_values=True, encoding=content_charset) supported_transfer_encoding = { 'base64': binascii.a2b_base64, 'quoted-printable': binascii.a2b_qp } out = MultiDict() _count = 1 for field in fs.list or (): transfer_encoding = field.headers.get( hdrs.CONTENT_TRANSFER_ENCODING, None) if field.filename: ff = FileField(field.name, field.filename, field.file, # N.B. file closed error field.type) if self._post_files_cache is None: self._post_files_cache = {} self._post_files_cache[field.name+str(_count)] = field _count += 1 out.add(field.name, ff) else: value = field.value if transfer_encoding in supported_transfer_encoding: # binascii accepts bytes value = value.encode('utf-8') value = supported_transfer_encoding[ transfer_encoding](value) out.add(field.name, value) self._post = MultiDictProxy(out) return self._post def __repr__(self): ascii_encodable_path = self.path.encode('ascii', 'backslashreplace') \ .decode('ascii') return "<{} {} {} >".format(self.__class__.__name__, self.method, ascii_encodable_path) @asyncio.coroutine def _prepare_hook(self, response): return yield # pragma: no cover class Request(BaseRequest): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # matchdict, route_name, handler # or information about traversal lookup self._match_info = None # initialized after route resolving @property def match_info(self): """Result of route resolving.""" return self._match_info @reify def app(self): """Application instance.""" return self._match_info.apps[-1] @asyncio.coroutine def _prepare_hook(self, response): match_info = self._match_info if match_info is None: return for app in match_info.apps: yield from app.on_response_prepare.send(self, response) ############################################################ # HTTP Response classes ############################################################ class StreamResponse(HeadersMixin): def __init__(self, *, status=200, reason=None, headers=None): self._body = None self._keep_alive = None self._chunked = False self._chunk_size = None self._compression = False self._compression_force = False self._headers = CIMultiDict() self._cookies = SimpleCookie() self._req = None self._resp_impl = None self._eof_sent = False self._task = None if headers is not None: # TODO: optimize CIMultiDict extending self._headers.extend(headers) self._headers.setdefault(hdrs.CONTENT_TYPE, 'application/octet-stream') self.set_status(status, reason) @property def prepared(self): return self._resp_impl is not None @property def started(self): warnings.warn('use Response.prepared instead', DeprecationWarning) return self.prepared @property def task(self): return self._task @property def status(self): return self._status @property def chunked(self): return self._chunked @property def compression(self): return self._compression @property def reason(self): return self._reason def set_status(self, status, reason=None): if self.prepared: raise RuntimeError("Cannot change the response status code after " "the headers have been sent") self._status = int(status) if reason is None: reason = ResponseImpl.calc_reason(status) self._reason = reason @property def keep_alive(self): return self._keep_alive def force_close(self): self._keep_alive = False @property def body_length(self): return self._resp_impl.body_length @property def output_length(self): return self._resp.impl.output_length def enable_chunked_encoding(self, chunk_size=None): """Enables automatic chunked transfer encoding.""" self._chunked = True self._chunk_size = chunk_size def enable_compression(self, force=None): """Enables response compression encoding.""" # Backwards compatibility for when force was a bool <0.17. if type(force) == bool: force = ContentCoding.deflate if force else ContentCoding.identity elif force is not None: assert isinstance(force, ContentCoding), ("force should one of " "None, bool or " "ContentEncoding") self._compression = True self._compression_force = force @property def headers(self): return self._headers @property def cookies(self): return self._cookies def set_cookie(self, name, value, *, expires=None, domain=None, max_age=None, path='/', secure=None, httponly=None, version=None): """Set or update response cookie. Sets new cookie or updates existent with new value. Also updates only those params which are not None. """ old = self._cookies.get(name) if old is not None and old.coded_value == '': # deleted cookie self._cookies.pop(name, None) self._cookies[name] = value c = self._cookies[name] if expires is not None: c['expires'] = expires elif c.get('expires') == 'Thu, 01 Jan 1970 00:00:00 GMT': del c['expires'] if domain is not None: c['domain'] = domain if max_age is not None: c['max-age'] = max_age elif 'max-age' in c: del c['max-age'] c['path'] = path if secure is not None: c['secure'] = secure if httponly is not None: c['httponly'] = httponly if version is not None: c['version'] = version def del_cookie(self, name, *, domain=None, path='/'): """Delete cookie. Creates new empty expired cookie. """ # TODO: do we need domain/path here? self._cookies.pop(name, None) self.set_cookie(name, '', max_age=0, expires="Thu, 01 Jan 1970 00:00:00 GMT", domain=domain, path=path) @property def content_length(self): # Just a placeholder for adding setter return super().content_length @content_length.setter def content_length(self, value): if value is not None: value = int(value) # TODO: raise error if chunked enabled self.headers[hdrs.CONTENT_LENGTH] = str(value) else: self.headers.pop(hdrs.CONTENT_LENGTH, None) @property def content_type(self): # Just a placeholder for adding setter return super().content_type @content_type.setter def content_type(self, value): self.content_type # read header values if needed self._content_type = str(value) self._generate_content_type_header() @property def charset(self): # Just a placeholder for adding setter return super().charset @charset.setter def charset(self, value): ctype = self.content_type # read header values if needed if ctype == 'application/octet-stream': raise RuntimeError("Setting charset for application/octet-stream " "doesn't make sense, setup content_type first") if value is None: self._content_dict.pop('charset', None) else: self._content_dict['charset'] = str(value).lower() self._generate_content_type_header() @property def last_modified(self, _LAST_MODIFIED=hdrs.LAST_MODIFIED): """The value of Last-Modified HTTP header, or None. This header is represented as a `datetime` object. """ httpdate = self.headers.get(_LAST_MODIFIED) if httpdate is not None: timetuple = parsedate(httpdate) if timetuple is not None: return datetime.datetime(*timetuple[:6], tzinfo=datetime.timezone.utc) return None @last_modified.setter def last_modified(self, value): if value is None: self.headers.pop(hdrs.LAST_MODIFIED, None) elif isinstance(value, (int, float)): self.headers[hdrs.LAST_MODIFIED] = time.strftime( "%a, %d %b %Y %H:%M:%S GMT", time.gmtime(math.ceil(value))) elif isinstance(value, datetime.datetime): self.headers[hdrs.LAST_MODIFIED] = time.strftime( "%a, %d %b %Y %H:%M:%S GMT", value.utctimetuple()) elif isinstance(value, str): self.headers[hdrs.LAST_MODIFIED] = value @property def tcp_nodelay(self): resp_impl = self._resp_impl if resp_impl is None: raise RuntimeError("Cannot get tcp_nodelay for " "not prepared response") return resp_impl.transport.tcp_nodelay def set_tcp_nodelay(self, value): resp_impl = self._resp_impl if resp_impl is None: raise RuntimeError("Cannot set tcp_nodelay for " "not prepared response") resp_impl.transport.set_tcp_nodelay(value) @property def tcp_cork(self): resp_impl = self._resp_impl if resp_impl is None: raise RuntimeError("Cannot get tcp_cork for " "not prepared response") return resp_impl.transport.tcp_cork def set_tcp_cork(self, value): resp_impl = self._resp_impl if resp_impl is None: raise RuntimeError("Cannot set tcp_cork for " "not prepared response") resp_impl.transport.set_tcp_cork(value) def _generate_content_type_header(self, CONTENT_TYPE=hdrs.CONTENT_TYPE): params = '; '.join("%s=%s" % i for i in self._content_dict.items()) if params: ctype = self._content_type + '; ' + params else: ctype = self._content_type self.headers[CONTENT_TYPE] = ctype def _start_pre_check(self, request): if self._resp_impl is not None: if self._req is not request: raise RuntimeError( "Response has been started with different request.") else: return self._resp_impl else: return None def _do_start_compression(self, coding): if coding != ContentCoding.identity: self.headers[hdrs.CONTENT_ENCODING] = coding.value self._resp_impl.add_compression_filter(coding.value) self.content_length = None def _start_compression(self, request): if self._compression_force: self._do_start_compression(self._compression_force) else: accept_encoding = request.headers.get( hdrs.ACCEPT_ENCODING, '').lower() for coding in ContentCoding: if coding.value in accept_encoding: self._do_start_compression(coding) return def start(self, request): warnings.warn('use .prepare(request) instead', DeprecationWarning) resp_impl = self._start_pre_check(request) if resp_impl is not None: return resp_impl return self._start(request) @asyncio.coroutine def prepare(self, request): resp_impl = self._start_pre_check(request) if resp_impl is not None: return resp_impl yield from request._prepare_hook(self) return self._start(request) def _start(self, request, HttpVersion10=HttpVersion10, HttpVersion11=HttpVersion11, CONNECTION=hdrs.CONNECTION, DATE=hdrs.DATE, SERVER=hdrs.SERVER, SET_COOKIE=hdrs.SET_COOKIE, TRANSFER_ENCODING=hdrs.TRANSFER_ENCODING): self._req = request keep_alive = self._keep_alive if keep_alive is None: keep_alive = request.keep_alive self._keep_alive = keep_alive version = request.version resp_impl = self._resp_impl = ResponseImpl( request._writer, self._status, version, not keep_alive, self._reason) headers = self.headers for cookie in self._cookies.values(): value = cookie.output(header='')[1:] headers.add(SET_COOKIE, value) if self._compression: self._start_compression(request) if self._chunked: if request.version != HttpVersion11: raise RuntimeError("Using chunked encoding is forbidden " "for HTTP/{0.major}.{0.minor}".format( request.version)) resp_impl.chunked = True if self._chunk_size: resp_impl.add_chunking_filter(self._chunk_size) headers[TRANSFER_ENCODING] = 'chunked' else: resp_impl.length = self.content_length headers.setdefault(DATE, request._time_service.strtime()) headers.setdefault(SERVER, resp_impl.SERVER_SOFTWARE) if CONNECTION not in headers: if keep_alive: if version == HttpVersion10: headers[CONNECTION] = 'keep-alive' else: if version == HttpVersion11: headers[CONNECTION] = 'close' resp_impl.headers = headers self._send_headers(resp_impl) self._task = request._task return resp_impl def _send_headers(self, resp_impl): # Durty hack required for # https://github.com/KeepSafe/aiohttp/issues/1093 # File sender may override it resp_impl.send_headers() def write(self, data): assert isinstance(data, (bytes, bytearray, memoryview)), \ "data argument must be byte-ish (%r)" % type(data) if self._eof_sent: raise RuntimeError("Cannot call write() after write_eof()") if self._resp_impl is None: raise RuntimeError("Cannot call write() before start()") if data: return self._resp_impl.write(data) else: return () @asyncio.coroutine def drain(self): if self._resp_impl is None: raise RuntimeError("Response has not been started") yield from self._resp_impl.transport.drain() @asyncio.coroutine def write_eof(self): if self._eof_sent: return if self._resp_impl is None: raise RuntimeError("Response has not been started") yield from self._resp_impl.write_eof() self._eof_sent = True def __repr__(self): if self.started: info = "{} {} ".format(self._req.method, self._req.path) else: info = "not started" return "<{} {} {}>".format(self.__class__.__name__, self.reason, info) class Response(StreamResponse): def __init__(self, *, body=None, status=200, reason=None, text=None, headers=None, content_type=None, charset=None): if body is not None and text is not None: raise ValueError("body and text are not allowed together") if headers is None: headers = CIMultiDict() elif not isinstance(headers, (CIMultiDict, CIMultiDictProxy)): headers = CIMultiDict(headers) if content_type is not None and ";" in content_type: raise ValueError("charset must not be in content_type " "argument") if text is not None: if hdrs.CONTENT_TYPE in headers: if content_type or charset: raise ValueError("passing both Content-Type header and " "content_type or charset params " "is forbidden") else: # fast path for filling headers if not isinstance(text, str): raise TypeError("text argument must be str (%r)" % type(text)) if content_type is None: content_type = 'text/plain' if charset is None: charset = 'utf-8' headers[hdrs.CONTENT_TYPE] = ( content_type + '; charset=' + charset) body = text.encode(charset) text = None else: if hdrs.CONTENT_TYPE in headers: if content_type is not None or charset is not None: raise ValueError("passing both Content-Type header and " "content_type or charset params " "is forbidden") else: if content_type is not None: if charset is not None: content_type += '; charset=' + charset headers[hdrs.CONTENT_TYPE] = content_type super().__init__(status=status, reason=reason, headers=headers) if text is not None: self.text = text elif body is None and hdrs.CONTENT_LENGTH in headers: self._body = None else: self.body = body @property def body(self): return self._body @body.setter def body(self, body): if body is not None and not isinstance(body, bytes): raise TypeError("body argument must be bytes (%r)" % type(body)) self._body = body if body is not None: self.content_length = len(body) else: self.content_length = 0 @property def text(self): if self._body is None: return None return self._body.decode(self.charset or 'utf-8') @text.setter def text(self, text): if text is not None and not isinstance(text, str): raise TypeError("text argument must be str (%r)" % type(text)) if self.content_type == 'application/octet-stream': self.content_type = 'text/plain' if self.charset is None: self.charset = 'utf-8' self.body = text.encode(self.charset) @asyncio.coroutine def write_eof(self): body = self._body if (body is not None and self._req.method != hdrs.METH_HEAD and self._status not in [204, 304]): self.write(body) yield from super().write_eof() def json_response(data=sentinel, *, text=None, body=None, status=200, reason=None, headers=None, content_type='application/json', dumps=json.dumps): if data is not sentinel: if text or body: raise ValueError( "only one of data, text, or body should be specified" ) else: text = dumps(data) return Response(text=text, body=body, status=status, reason=reason, headers=headers, content_type=content_type) aiohttp-1.2.0/aiohttp/web.py0000664000175000017500000002531413025134363016632 0ustar travistravis00000000000000import asyncio import sys import warnings from argparse import ArgumentParser from collections import MutableMapping from importlib import import_module from yarl import URL from . import (hdrs, web_exceptions, web_reqrep, web_server, web_urldispatcher, web_ws) from .abc import AbstractMatchInfo, AbstractRouter from .helpers import FrozenList, sentinel from .log import access_logger, web_logger from .protocol import HttpVersion # noqa from .signals import PostSignal, PreSignal, Signal from .web_exceptions import * # noqa from .web_reqrep import * # noqa from .web_server import Server from .web_urldispatcher import * # noqa from .web_ws import * # noqa __all__ = (web_reqrep.__all__ + web_exceptions.__all__ + web_urldispatcher.__all__ + web_ws.__all__ + web_server.__all__ + ('Application', 'HttpVersion', 'MsgType')) class Application(MutableMapping): def __init__(self, *, logger=web_logger, loop=None, router=None, middlewares=(), debug=...): if loop is None: loop = asyncio.get_event_loop() if router is None: router = web_urldispatcher.UrlDispatcher() assert isinstance(router, AbstractRouter), router router.post_init(self) if debug is ...: debug = loop.get_debug() self._debug = debug self._router = router self._secure_proxy_ssl_header = None self._loop = loop self.logger = logger self._middlewares = FrozenList(middlewares) self._state = {} self._frozen = False self._on_pre_signal = PreSignal() self._on_post_signal = PostSignal() self._on_response_prepare = Signal(self) self._on_startup = Signal(self) self._on_shutdown = Signal(self) self._on_cleanup = Signal(self) # MutableMapping API def __getitem__(self, key): return self._state[key] def _check_frozen(self): if self._frozen: warnings.warn("Changing state of started or joined " "application is deprecated", DeprecationWarning, stacklevel=3) def __setitem__(self, key, value): self._check_frozen() self._state[key] = value def __delitem__(self, key): self._check_frozen() del self._state[key] def __len__(self): return len(self._state) def __iter__(self): return iter(self._state) ######## @property def frozen(self): return self._frozen def freeze(self): if self._frozen: return self._frozen = True self._router.freeze() self._middlewares.freeze() self._on_pre_signal.freeze() self._on_post_signal.freeze() self._on_response_prepare.freeze() self._on_startup.freeze() self._on_shutdown.freeze() self._on_cleanup.freeze() @property def debug(self): return self._debug def _reg_subapp_signals(self, subapp): def reg_handler(signame): subsig = getattr(subapp, signame) @asyncio.coroutine def handler(app): yield from subsig.send(subapp) appsig = getattr(self, signame) appsig.append(handler) reg_handler('on_startup') reg_handler('on_shutdown') reg_handler('on_cleanup') @property def on_response_prepare(self): return self._on_response_prepare @property def on_pre_signal(self): return self._on_pre_signal @property def on_post_signal(self): return self._on_post_signal @property def on_startup(self): return self._on_startup @property def on_shutdown(self): return self._on_shutdown @property def on_cleanup(self): return self._on_cleanup @property def router(self): return self._router @property def loop(self): return self._loop @property def middlewares(self): return self._middlewares def make_handler(self, *, secure_proxy_ssl_header=None, **kwargs): debug = kwargs.pop('debug', sentinel) if debug is not sentinel: warnings.warn( "`debug` parameter is deprecated. " "Use Application's debug mode instead", DeprecationWarning) if debug != self.debug: raise ValueError( "The value of `debug` parameter conflicts with the debug " "settings of the `Application` instance. The " "application's debug mode setting should be used instead " "as a single point to setup a debug mode. For more " "information please check " "http://aiohttp.readthedocs.io/en/stable/" "web_reference.html#aiohttp.web.Application" ) self.freeze() self._secure_proxy_ssl_header = secure_proxy_ssl_header return Server(self._handle, request_factory=self._make_request, debug=self.debug, loop=self.loop, **kwargs) @asyncio.coroutine def startup(self): """Causes on_startup signal Should be called in the event loop along with the request handler. """ yield from self.on_startup.send(self) @asyncio.coroutine def shutdown(self): """Causes on_shutdown signal Should be called before cleanup() """ yield from self.on_shutdown.send(self) @asyncio.coroutine def cleanup(self): """Causes on_cleanup signal Should be called after shutdown() """ yield from self.on_cleanup.send(self) @asyncio.coroutine def finish(self): """Finalize an application. Deprecated alias for .cleanup() """ warnings.warn("Use .cleanup() instead", DeprecationWarning) yield from self.cleanup() def register_on_finish(self, func, *args, **kwargs): warnings.warn("Use .on_cleanup.append() instead", DeprecationWarning) self.on_cleanup.append(lambda app: func(app, *args, **kwargs)) def _make_request(self, message, payload, protocol, _cls=web_reqrep.Request): return _cls( message, payload, protocol.transport, protocol.reader, protocol.writer, protocol.time_service, protocol._request_handler, secure_proxy_ssl_header=self._secure_proxy_ssl_header) @asyncio.coroutine def _handle(self, request): match_info = yield from self._router.resolve(request) assert isinstance(match_info, AbstractMatchInfo), match_info match_info.add_app(self) match_info.freeze() resp = None request._match_info = match_info expect = request.headers.get(hdrs.EXPECT) if expect: resp = ( yield from match_info.expect_handler(request)) if resp is None: handler = match_info.handler for app in match_info.apps: for factory in reversed(app.middlewares): handler = yield from factory(app, handler) resp = yield from handler(request) assert isinstance(resp, web_reqrep.StreamResponse), \ ("Handler {!r} should return response instance, " "got {!r} [middlewares {!r}]").format( match_info.handler, type(resp), [middleware for middleware in app.middlewares for app in match_info.apps]) return resp def __call__(self): """gunicorn compatibility""" return self def __repr__(self): return "".format(id(self)) def run_app(app, *, host='0.0.0.0', port=None, shutdown_timeout=60.0, ssl_context=None, print=print, backlog=128, access_log_format=None, access_log=access_logger): """Run an app locally""" if port is None: if not ssl_context: port = 8080 else: port = 8443 loop = app.loop make_handler_kwargs = dict() if access_log_format is not None: make_handler_kwargs['access_log_format'] = access_log_format handler = app.make_handler(access_log=access_log, **make_handler_kwargs) loop.run_until_complete(app.startup()) srv = loop.run_until_complete(loop.create_server(handler, host, port, ssl=ssl_context, backlog=backlog)) scheme = 'https' if ssl_context else 'http' url = URL('{}://localhost'.format(scheme)) url = url.with_host(host).with_port(port) print("======== Running on {} ========\n" "(Press CTRL+C to quit)".format(url)) try: loop.run_forever() except KeyboardInterrupt: # pragma: no cover pass finally: srv.close() loop.run_until_complete(srv.wait_closed()) loop.run_until_complete(app.shutdown()) loop.run_until_complete(handler.shutdown(shutdown_timeout)) loop.run_until_complete(app.cleanup()) loop.close() def main(argv): arg_parser = ArgumentParser( description="aiohttp.web Application server", prog="aiohttp.web" ) arg_parser.add_argument( "entry_func", help=("Callable returning the `aiohttp.web.Application` instance to " "run. Should be specified in the 'module:function' syntax."), metavar="entry-func" ) arg_parser.add_argument( "-H", "--hostname", help="TCP/IP hostname to serve on (default: %(default)r)", default="localhost" ) arg_parser.add_argument( "-P", "--port", help="TCP/IP port to serve on (default: %(default)r)", type=int, default="8080" ) args, extra_argv = arg_parser.parse_known_args(argv) # Import logic mod_str, _, func_str = args.entry_func.partition(":") if not func_str or not mod_str: arg_parser.error( "'entry-func' not in 'module:function' syntax" ) if mod_str.startswith("."): arg_parser.error("relative module names not supported") try: module = import_module(mod_str) except ImportError as ex: arg_parser.error("unable to import %s: %s" % (mod_str, ex)) try: func = getattr(module, func_str) except AttributeError: arg_parser.error("module %r has no attribute %r" % (mod_str, func_str)) app = func(extra_argv) run_app(app, host=args.hostname, port=args.port) arg_parser.exit(message="Stopped\n") if __name__ == "__main__": # pragma: no branch main(sys.argv[1:]) # pragma: no cover aiohttp-1.2.0/aiohttp/client_reqrep.py0000664000175000017500000006445513025134363020722 0ustar travistravis00000000000000import asyncio import http.cookies import io import json import mimetypes import os import sys import traceback import warnings from multidict import CIMultiDict, CIMultiDictProxy, MultiDict, MultiDictProxy from yarl import URL import aiohttp from . import hdrs, helpers, streams from .helpers import HeadersMixin, Timeout from .log import client_logger from .multipart import MultipartWriter from .protocol import HttpMessage from .streams import FlowControlStreamReader try: import cchardet as chardet except ImportError: # pragma: no cover import chardet __all__ = ('ClientRequest', 'ClientResponse') PY_35 = sys.version_info >= (3, 5) class ClientRequest: GET_METHODS = {hdrs.METH_GET, hdrs.METH_HEAD, hdrs.METH_OPTIONS} POST_METHODS = {hdrs.METH_PATCH, hdrs.METH_POST, hdrs.METH_PUT} ALL_METHODS = GET_METHODS.union(POST_METHODS).union( {hdrs.METH_DELETE, hdrs.METH_TRACE}) DEFAULT_HEADERS = { hdrs.ACCEPT: '*/*', hdrs.ACCEPT_ENCODING: 'gzip, deflate', } SERVER_SOFTWARE = HttpMessage.SERVER_SOFTWARE body = b'' auth = None response = None response_class = None _writer = None # async task for streaming data _continue = None # waiter future for '100 Continue' response # N.B. # Adding __del__ method with self._writer closing doesn't make sense # because _writer is instance method, thus it keeps a reference to self. # Until writer has finished finalizer will not be called. def __init__(self, method, url, *, params=None, headers=None, skip_auto_headers=frozenset(), data=None, cookies=None, auth=None, encoding='utf-8', version=aiohttp.HttpVersion11, compress=None, chunked=None, expect100=False, loop=None, response_class=None, proxy=None, proxy_auth=None, timeout=5*60): if loop is None: loop = asyncio.get_event_loop() assert isinstance(url, URL), url assert isinstance(proxy, (URL, type(None))), proxy if params: q = MultiDict(url.query) url2 = url.with_query(params) q.extend(url2.query) url = url.with_query(q) self.url = url.with_fragment(None) self.method = method.upper() self.encoding = encoding self.chunked = chunked self.compress = compress self.loop = loop self.response_class = response_class or ClientResponse self._timeout = timeout if loop.get_debug(): self._source_traceback = traceback.extract_stack(sys._getframe(1)) self.update_version(version) self.update_host(url) self.update_headers(headers) self.update_auto_headers(skip_auto_headers) self.update_cookies(cookies) self.update_content_encoding(data) self.update_auth(auth) self.update_proxy(proxy, proxy_auth) self.update_body_from_data(data, skip_auto_headers) self.update_transfer_encoding() self.update_expect_continue(expect100) @property def host(self): return self.url.host @property def port(self): return self.url.port def update_host(self, url): """Update destination host, port and connection type (ssl).""" # get host/port if not url.host: raise ValueError('Host could not be detected.') # basic auth info username, password = url.user, url.password if username: self.auth = helpers.BasicAuth(username, password or '') # Record entire netloc for usage in host header scheme = url.scheme self.ssl = scheme in ('https', 'wss') def update_version(self, version): """Convert request version to two elements tuple. parser HTTP version '1.1' => (1, 1) """ if isinstance(version, str): v = [l.strip() for l in version.split('.', 1)] try: version = int(v[0]), int(v[1]) except ValueError: raise ValueError( 'Can not parse http version number: {}' .format(version)) from None self.version = version def update_headers(self, headers): """Update request headers.""" self.headers = CIMultiDict() if headers: if isinstance(headers, dict): headers = headers.items() elif isinstance(headers, (MultiDictProxy, MultiDict)): headers = headers.items() for key, value in headers: self.headers.add(key, value) def update_auto_headers(self, skip_auto_headers): self.skip_auto_headers = skip_auto_headers used_headers = set(self.headers) | skip_auto_headers for hdr, val in self.DEFAULT_HEADERS.items(): if hdr not in used_headers: self.headers.add(hdr, val) # add host if hdrs.HOST not in used_headers: netloc = self.url.raw_host if not self.url.is_default_port(): netloc += ':' + str(self.url.port) self.headers[hdrs.HOST] = netloc if hdrs.USER_AGENT not in used_headers: self.headers[hdrs.USER_AGENT] = self.SERVER_SOFTWARE def update_cookies(self, cookies): """Update request cookies header.""" if not cookies: return c = http.cookies.SimpleCookie() if hdrs.COOKIE in self.headers: c.load(self.headers.get(hdrs.COOKIE, '')) del self.headers[hdrs.COOKIE] for name, value in cookies.items(): if isinstance(value, http.cookies.Morsel): # Preserve coded_value mrsl_val = value.get(value.key, http.cookies.Morsel()) mrsl_val.set(value.key, value.value, value.coded_value) c[name] = mrsl_val else: c[name] = value self.headers[hdrs.COOKIE] = c.output(header='', sep=';').strip() def update_content_encoding(self, data): """Set request content encoding.""" if not data: return enc = self.headers.get(hdrs.CONTENT_ENCODING, '').lower() if enc: if self.compress is not False: self.compress = enc # enable chunked, no need to deal with length self.chunked = True elif self.compress: if not isinstance(self.compress, str): self.compress = 'deflate' self.headers[hdrs.CONTENT_ENCODING] = self.compress self.chunked = True # enable chunked, no need to deal with length def update_auth(self, auth): """Set basic auth.""" if auth is None: auth = self.auth if auth is None: return if not isinstance(auth, helpers.BasicAuth): raise TypeError('BasicAuth() tuple is required instead') self.headers[hdrs.AUTHORIZATION] = auth.encode() def update_body_from_data(self, data, skip_auto_headers): if not data: return if isinstance(data, str): data = data.encode(self.encoding) if isinstance(data, (bytes, bytearray)): self.body = data if (hdrs.CONTENT_TYPE not in self.headers and hdrs.CONTENT_TYPE not in skip_auto_headers): self.headers[hdrs.CONTENT_TYPE] = 'application/octet-stream' if hdrs.CONTENT_LENGTH not in self.headers and not self.chunked: self.headers[hdrs.CONTENT_LENGTH] = str(len(self.body)) elif isinstance(data, (asyncio.StreamReader, streams.StreamReader, streams.DataQueue)): self.body = data elif asyncio.iscoroutine(data): self.body = data if (hdrs.CONTENT_LENGTH not in self.headers and self.chunked is None): self.chunked = True elif isinstance(data, io.IOBase): assert not isinstance(data, io.StringIO), \ 'attempt to send text data instead of binary' self.body = data if not self.chunked and isinstance(data, io.BytesIO): # Not chunking if content-length can be determined size = len(data.getbuffer()) self.headers[hdrs.CONTENT_LENGTH] = str(size) self.chunked = False elif (not self.chunked and isinstance(data, (io.BufferedReader, io.BufferedRandom))): # Not chunking if content-length can be determined try: size = os.fstat(data.fileno()).st_size - data.tell() self.headers[hdrs.CONTENT_LENGTH] = str(size) self.chunked = False except OSError: # data.fileno() is not supported, e.g. # io.BufferedReader(io.BytesIO(b'data')) self.chunked = True else: self.chunked = True if hasattr(data, 'mode'): if data.mode == 'r': raise ValueError('file {!r} should be open in binary mode' ''.format(data)) if (hdrs.CONTENT_TYPE not in self.headers and hdrs.CONTENT_TYPE not in skip_auto_headers and hasattr(data, 'name')): mime = mimetypes.guess_type(data.name)[0] mime = 'application/octet-stream' if mime is None else mime self.headers[hdrs.CONTENT_TYPE] = mime elif isinstance(data, MultipartWriter): self.body = data.serialize() self.headers.update(data.headers) self.chunked = self.chunked or 8192 else: if not isinstance(data, helpers.FormData): data = helpers.FormData(data) self.body = data(self.encoding) if (hdrs.CONTENT_TYPE not in self.headers and hdrs.CONTENT_TYPE not in skip_auto_headers): self.headers[hdrs.CONTENT_TYPE] = data.content_type if data.is_multipart: self.chunked = self.chunked or 8192 else: if (hdrs.CONTENT_LENGTH not in self.headers and not self.chunked): self.headers[hdrs.CONTENT_LENGTH] = str(len(self.body)) def update_transfer_encoding(self): """Analyze transfer-encoding header.""" te = self.headers.get(hdrs.TRANSFER_ENCODING, '').lower() if self.chunked: if hdrs.CONTENT_LENGTH in self.headers: del self.headers[hdrs.CONTENT_LENGTH] if 'chunked' not in te: self.headers[hdrs.TRANSFER_ENCODING] = 'chunked' self.chunked = self.chunked if type(self.chunked) is int else 8192 else: if 'chunked' in te: self.chunked = 8192 else: self.chunked = None if hdrs.CONTENT_LENGTH not in self.headers: self.headers[hdrs.CONTENT_LENGTH] = str(len(self.body)) def update_expect_continue(self, expect=False): if expect: self.headers[hdrs.EXPECT] = '100-continue' elif self.headers.get(hdrs.EXPECT, '').lower() == '100-continue': expect = True if expect: self._continue = helpers.create_future(self.loop) def update_proxy(self, proxy, proxy_auth): if proxy and not proxy.scheme == 'http': raise ValueError("Only http proxies are supported") if proxy_auth and not isinstance(proxy_auth, helpers.BasicAuth): raise ValueError("proxy_auth must be None or BasicAuth() tuple") self.proxy = proxy self.proxy_auth = proxy_auth @asyncio.coroutine def write_bytes(self, request, reader): """Support coroutines that yields bytes objects.""" # 100 response if self._continue is not None: yield from self._continue try: if asyncio.iscoroutine(self.body): exc = None value = None stream = self.body while True: try: if exc is not None: result = stream.throw(exc) else: result = stream.send(value) except StopIteration as exc: if isinstance(exc.value, bytes): yield from request.write(exc.value, drain=True) break except: self.response.close() raise if isinstance(result, asyncio.Future): exc = None value = None try: value = yield result except Exception as err: exc = err elif isinstance(result, (bytes, bytearray)): yield from request.write(result, drain=True) value = None else: raise ValueError( 'Bytes object is expected, got: %s.' % type(result)) elif isinstance(self.body, (asyncio.StreamReader, streams.StreamReader)): chunk = yield from self.body.read(streams.DEFAULT_LIMIT) while chunk: yield from request.write(chunk, drain=True) chunk = yield from self.body.read(streams.DEFAULT_LIMIT) elif isinstance(self.body, streams.DataQueue): while True: try: chunk = yield from self.body.read() if not chunk: break yield from request.write(chunk, drain=True) except streams.EofStream: break elif isinstance(self.body, io.IOBase): chunk = self.body.read(self.chunked) while chunk: request.write(chunk) chunk = self.body.read(self.chunked) else: if isinstance(self.body, (bytes, bytearray)): self.body = (self.body,) for chunk in self.body: request.write(chunk) except Exception as exc: new_exc = aiohttp.ClientRequestError( 'Can not write request body for %s' % self.url) new_exc.__context__ = exc new_exc.__cause__ = exc reader.set_exception(new_exc) else: try: ret = request.write_eof() # NB: in asyncio 3.4.1+ StreamWriter.drain() is coroutine # see bug #170 if (asyncio.iscoroutine(ret) or isinstance(ret, asyncio.Future)): yield from ret except Exception as exc: new_exc = aiohttp.ClientRequestError( 'Can not write request body for %s' % self.url) new_exc.__context__ = exc new_exc.__cause__ = exc reader.set_exception(new_exc) self._writer = None def send(self, writer, reader): # Specify request target: # - CONNECT request must send authority form URI # - not CONNECT proxy must send absolute form URI # - most common is origin form URI if self.method == hdrs.METH_CONNECT: path = '{}:{}'.format(self.url.raw_host, self.url.port) elif self.proxy and not self.ssl: path = str(self.url) else: path = self.url.raw_path if self.url.raw_query_string: path += '?' + self.url.raw_query_string request = aiohttp.Request(writer, self.method, path, self.version) if self.compress: request.add_compression_filter(self.compress) if self.chunked is not None: request.enable_chunked_encoding() request.add_chunking_filter(self.chunked) # set default content-type if (self.method in self.POST_METHODS and hdrs.CONTENT_TYPE not in self.skip_auto_headers and hdrs.CONTENT_TYPE not in self.headers): self.headers[hdrs.CONTENT_TYPE] = 'application/octet-stream' for k, value in self.headers.items(): request.add_header(k, value) request.send_headers() self._writer = helpers.ensure_future( self.write_bytes(request, reader), loop=self.loop) self.response = self.response_class( self.method, self.url, writer=self._writer, continue100=self._continue, timeout=self._timeout) self.response._post_init(self.loop) return self.response @asyncio.coroutine def close(self): if self._writer is not None: try: yield from self._writer finally: self._writer = None def terminate(self): if self._writer is not None: if not self.loop.is_closed(): self._writer.cancel() self._writer = None class ClientResponse(HeadersMixin): # from the Status-Line of the response version = None # HTTP-Version status = None # Status-Code reason = None # Reason-Phrase content = None # Payload stream headers = None # Response headers, CIMultiDictProxy raw_headers = None # Response raw headers, a sequence of pairs _connection = None # current connection flow_control_class = FlowControlStreamReader # reader flow control _reader = None # input stream _response_parser = aiohttp.HttpResponseParser() _source_traceback = None # setted up by ClientRequest after ClientResponse object creation # post-init stage allows to not change ctor signature _loop = None _closed = True # to allow __del__ for non-initialized properly response def __init__(self, method, url, *, writer=None, continue100=None, timeout=5*60): assert isinstance(url, URL) self.method = method self._url_obj = url self._content = None self._writer = writer self._continue = continue100 self._closed = False self._should_close = True # override by message.should_close later self._history = () self._timeout = timeout self.cookies = http.cookies.SimpleCookie() @property def url_obj(self): return self._url_obj @property def url(self): warnings.warn("Deprecated, use .url_obj", DeprecationWarning, stacklevel=2) return str(self._url_obj) @property def host(self): warnings.warn("Deprecated, use .url_obj.host", DeprecationWarning, stacklevel=2) return self._url_obj.host def _post_init(self, loop): self._loop = loop if loop.get_debug(): self._source_traceback = traceback.extract_stack(sys._getframe(1)) def __del__(self, _warnings=warnings): if self._loop is None: return # not started if self._closed: return self.close() _warnings.warn("Unclosed response {!r}".format(self), ResourceWarning) context = {'client_response': self, 'message': 'Unclosed response'} if self._source_traceback: context['source_traceback'] = self._source_traceback self._loop.call_exception_handler(context) def __repr__(self): out = io.StringIO() ascii_encodable_url = str(self.url) if self.reason: ascii_encodable_reason = self.reason.encode('ascii', 'backslashreplace') \ .decode('ascii') else: ascii_encodable_reason = self.reason print(''.format( ascii_encodable_url, self.status, ascii_encodable_reason), file=out) print(self.headers, file=out) return out.getvalue() @property def connection(self): return self._connection @property def history(self): """A sequence of of responses, if redirects occurred.""" return self._history def _setup_connection(self, connection): self._reader = connection.reader self._connection = connection self.content = self.flow_control_class( connection.reader, loop=connection.loop, timeout=self._timeout) def _need_parse_response_body(self): return (self.method.lower() != 'head' and self.status not in [204, 304]) @asyncio.coroutine def start(self, connection, read_until_eof=False): """Start response processing.""" self._setup_connection(connection) while True: httpstream = self._reader.set_parser(self._response_parser) # read response with Timeout(self._timeout, loop=self._loop): message = yield from httpstream.read() if message.code != 100: break if self._continue is not None and not self._continue.done(): self._continue.set_result(True) self._continue = None # response status self.version = message.version self.status = message.code self.reason = message.reason self._should_close = message.should_close # headers self.headers = CIMultiDictProxy(message.headers) self.raw_headers = tuple(message.raw_headers) # payload rwb = self._need_parse_response_body() self._reader.set_parser( aiohttp.HttpPayloadParser(message, readall=read_until_eof, response_with_body=rwb), self.content) # cookies for hdr in self.headers.getall(hdrs.SET_COOKIE, ()): try: self.cookies.load(hdr) except http.cookies.CookieError as exc: client_logger.warning( 'Can not load response cookies: %s', exc) return self def close(self): if self._closed: return self._closed = True if self._loop is None or self._loop.is_closed(): return if self._connection is not None: self._connection.close() self._connection = None self._cleanup_writer() self._notify_content() @asyncio.coroutine def release(self): if self._closed: return try: content = self.content if content is not None: while not content.at_eof(): yield from content.readany() except Exception: self._connection.close() self._connection = None raise finally: self._closed = True if self._connection is not None: self._connection.release() if self._reader is not None: self._reader.unset_parser() self._connection = None self._cleanup_writer() self._notify_content() def raise_for_status(self): if 400 <= self.status: raise aiohttp.HttpProcessingError( code=self.status, message=self.reason) def _cleanup_writer(self): if self._writer is not None and not self._writer.done(): self._writer.cancel() self._writer = None def _notify_content(self): content = self.content if content and content.exception() is None and not content.is_eof(): content.set_exception( aiohttp.ClientDisconnectedError('Connection closed')) @asyncio.coroutine def wait_for_close(self): if self._writer is not None: try: yield from self._writer finally: self._writer = None yield from self.release() @asyncio.coroutine def read(self): """Read response payload.""" if self._content is None: try: self._content = yield from self.content.read() except: self.close() raise else: yield from self.release() return self._content def _get_encoding(self): ctype = self.headers.get(hdrs.CONTENT_TYPE, '').lower() mtype, stype, _, params = helpers.parse_mimetype(ctype) encoding = params.get('charset') if not encoding: if mtype == 'application' and stype == 'json': # RFC 7159 states that the default encoding is UTF-8. encoding = 'utf-8' else: encoding = chardet.detect(self._content)['encoding'] if not encoding: encoding = 'utf-8' return encoding @asyncio.coroutine def text(self, encoding=None): """Read response payload and decode.""" if self._content is None: yield from self.read() if encoding is None: encoding = self._get_encoding() return self._content.decode(encoding) @asyncio.coroutine def json(self, *, encoding=None, loads=json.loads): """Read and decodes JSON response.""" if self._content is None: yield from self.read() ctype = self.headers.get(hdrs.CONTENT_TYPE, '').lower() if 'json' not in ctype: client_logger.warning( 'Attempt to decode JSON with unexpected mimetype: %s', ctype) stripped = self._content.strip() if not stripped: return None if encoding is None: encoding = self._get_encoding() return loads(stripped.decode(encoding)) if PY_35: @asyncio.coroutine def __aenter__(self): return self @asyncio.coroutine def __aexit__(self, exc_type, exc_val, exc_tb): if exc_type is None: yield from self.release() else: self.close() aiohttp-1.2.0/docs/0000775000175000017500000000000013025135427014760 5ustar travistravis00000000000000aiohttp-1.2.0/docs/conf.py0000664000175000017500000002430413025134363016260 0ustar travistravis00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- # # aiohttp documentation build configuration file, created by # sphinx-quickstart on Wed Mar 5 12:35:35 2014. # # This file is execfile()d with the current directory set to its # containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys import os import codecs import re _docs_path = os.path.dirname(__file__) _version_path = os.path.abspath(os.path.join(_docs_path, '..', 'aiohttp', '__init__.py')) with codecs.open(_version_path, 'r', 'latin1') as fp: try: _version_info = re.search(r"^__version__ = '" r"(?P\d+)" r"\.(?P\d+)" r"\.(?P\d+)" r"(?P.*)?'$", fp.read(), re.M).groupdict() except IndexError: raise RuntimeError('Unable to determine version.') # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. sys.path.insert(0, os.path.abspath('..')) sys.path.insert(0, os.path.abspath('.')) # import alabaster # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. # needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.viewcode', 'sphinx.ext.intersphinx', 'alabaster', 'sphinxcontrib.asyncio', 'sphinxcontrib.newsfeed', ] try: import sphinxcontrib.spelling # noqa extensions.append('sphinxcontrib.spelling') except ImportError: pass intersphinx_mapping = { 'python': ('http://docs.python.org/3', None), 'multidict': ('https://multidict.readthedocs.io/en/stable/', None), 'yarl': ('https://yarl.readthedocs.io/en/stable/', None), 'aiohttpjinja2': ('https://aiohttp-jinja2.readthedocs.io/en/stable/', None), 'aiohttpsession': ('https://aiohttp-session.readthedocs.io/en/stable/', None)} # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. # source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = 'aiohttp' copyright = '2013-2016, KeepSafe' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = '{major}.{minor}'.format(**_version_info) # The full version, including alpha/beta/rc tags. release = '{major}.{minor}.{patch}-{tag}'.format(**_version_info) # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: # today = '' # Else, today_fmt is used as the format for a strftime call. # today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ['_build'] # The reST default role (used for this markup: `text`) to use for all # documents. # default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. # add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). # add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. # show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # The default language to highlight source code in. highlight_language = 'python3' # A list of ignored prefixes for module index sorting. # modindex_common_prefix = [] # If true, keep warnings as "system message" paragraphs in the built documents. # keep_warnings = False # -- Options for HTML output ---------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = 'alabaster' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. html_theme_options = { 'logo': 'aiohttp-icon-128x128.png', 'description': 'http client/server for asyncio', 'github_user': 'KeepSafe', 'github_repo': 'aiohttp', 'github_button': True, 'github_type': 'star', 'github_banner': True, 'travis_button': True, 'codecov_button': True, 'pre_bg': '#FFF6E5', 'note_bg': '#E5ECD1', 'note_border': '#BFCF8C', 'body_text': '#482C0A', 'sidebar_text': '#49443E', 'sidebar_header': '#4B4032', } # Add any paths that contain custom themes here, relative to this directory. # html_theme_path = [alabaster.get_path()] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". # html_title = None # A shorter title for the navigation bar. Default is the same as html_title. # html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. # html_logo = 'aiohttp-icon.svg' # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. html_favicon = 'aiohttp-icon.ico' # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] # Add any extra paths that contain custom files (such as robots.txt or # .htaccess) here, relative to this directory. These files are copied # directly to the root of the documentation. # html_extra_path = [] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. # html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. # html_use_smartypants = True # Custom sidebar templates, maps document names to template names. html_sidebars = { '**': [ 'about.html', 'navigation.html', 'searchbox.html', ] } # Additional templates that should be rendered to pages, maps page names to # template names. # html_additional_pages = {} # If false, no module index is generated. # html_domain_indices = True # If false, no index is generated. # html_use_index = True # If true, the index is split into individual pages for each letter. # html_split_index = False # If true, links to the reST sources are added to the pages. # html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. # html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. # html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. # html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). # html_file_suffix = None # Output file base name for HTML help builder. htmlhelp_basename = 'aiohttpdoc' # -- Options for LaTeX output --------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). # 'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). # 'pointsize': '10pt', # Additional stuff for the LaTeX preamble. # 'preamble': '', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ ('index', 'aiohttp.tex', 'aiohttp Documentation', 'KeepSafe', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. # latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. # latex_use_parts = False # If true, show page references after internal links. # latex_show_pagerefs = False # If true, show URL addresses after external links. # latex_show_urls = False # Documents to append as an appendix to all manuals. # latex_appendices = [] # If false, no module index is generated. # latex_domain_indices = True # -- Options for manual page output --------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ ('index', 'aiohttp', 'aiohttp Documentation', ['KeepSafe'], 1) ] # If true, show URL addresses after external links. # man_show_urls = False # -- Options for Texinfo output ------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ('index', 'aiohttp', 'aiohttp Documentation', 'KeepSafe', 'aiohttp', 'One line description of project.', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. # texinfo_appendices = [] # If false, no module index is generated. # texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. # texinfo_show_urls = 'footnote' # If true, do not generate a @detailmenu in the "Top" node's menu. # texinfo_no_detailmenu = False disqus_shortname = 'aiohttp' aiohttp-1.2.0/docs/Makefile0000664000175000017500000001533313025134363016423 0ustar travistravis00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build # User-friendly check for sphinx-build ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1) $(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/) endif # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " xml to make Docutils-native XML files" @echo " pseudoxml to make pseudoxml-XML files for display purposes" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" clean: rm -rf $(BUILDDIR)/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/aiohttp.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/aiohttp.qhc" devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/aiohttp" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/aiohttp" @echo "# devhelp" epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." latexpdfja: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through platex and dvipdfmx..." $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." xml: $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml @echo @echo "Build finished. The XML files are in $(BUILDDIR)/xml." pseudoxml: $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml @echo @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml." spelling: $(SPHINXBUILD) -b spelling $(ALLSPHINXOPTS) $(BUILDDIR)/spelling @echo @echo "Build finished." aiohttp-1.2.0/docs/make.bat0000664000175000017500000001505713025134363016373 0ustar travistravis00000000000000@ECHO OFF REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=sphinx-build ) set BUILDDIR=_build set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% . set I18NSPHINXOPTS=%SPHINXOPTS% . if NOT "%PAPER%" == "" ( set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS% set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS% ) if "%1" == "" goto help if "%1" == "help" ( :help echo.Please use `make ^` where ^ is one of echo. html to make standalone HTML files echo. dirhtml to make HTML files named index.html in directories echo. singlehtml to make a single large HTML file echo. pickle to make pickle files echo. json to make JSON files echo. htmlhelp to make HTML files and a HTML help project echo. qthelp to make HTML files and a qthelp project echo. devhelp to make HTML files and a Devhelp project echo. epub to make an epub echo. latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter echo. text to make text files echo. man to make manual pages echo. texinfo to make Texinfo files echo. gettext to make PO message catalogs echo. changes to make an overview over all changed/added/deprecated items echo. xml to make Docutils-native XML files echo. pseudoxml to make pseudoxml-XML files for display purposes echo. linkcheck to check all external links for integrity echo. doctest to run all doctests embedded in the documentation if enabled goto end ) if "%1" == "clean" ( for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i del /q /s %BUILDDIR%\* goto end ) %SPHINXBUILD% 2> nul if errorlevel 9009 ( echo. echo.The 'sphinx-build' command was not found. Make sure you have Sphinx echo.installed, then set the SPHINXBUILD environment variable to point echo.to the full path of the 'sphinx-build' executable. Alternatively you echo.may add the Sphinx directory to PATH. echo. echo.If you don't have Sphinx installed, grab it from echo.http://sphinx-doc.org/ exit /b 1 ) if "%1" == "html" ( %SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/html. goto end ) if "%1" == "dirhtml" ( %SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml. goto end ) if "%1" == "singlehtml" ( %SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml. goto end ) if "%1" == "pickle" ( %SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the pickle files. goto end ) if "%1" == "json" ( %SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the JSON files. goto end ) if "%1" == "htmlhelp" ( %SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run HTML Help Workshop with the ^ .hhp project file in %BUILDDIR%/htmlhelp. goto end ) if "%1" == "qthelp" ( %SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run "qcollectiongenerator" with the ^ .qhcp project file in %BUILDDIR%/qthelp, like this: echo.^> qcollectiongenerator %BUILDDIR%\qthelp\aiohttp.qhcp echo.To view the help file: echo.^> assistant -collectionFile %BUILDDIR%\qthelp\aiohttp.ghc goto end ) if "%1" == "devhelp" ( %SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp if errorlevel 1 exit /b 1 echo. echo.Build finished. goto end ) if "%1" == "epub" ( %SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub if errorlevel 1 exit /b 1 echo. echo.Build finished. The epub file is in %BUILDDIR%/epub. goto end ) if "%1" == "latex" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex if errorlevel 1 exit /b 1 echo. echo.Build finished; the LaTeX files are in %BUILDDIR%/latex. goto end ) if "%1" == "latexpdf" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex cd %BUILDDIR%/latex make all-pdf cd %BUILDDIR%/.. echo. echo.Build finished; the PDF files are in %BUILDDIR%/latex. goto end ) if "%1" == "latexpdfja" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex cd %BUILDDIR%/latex make all-pdf-ja cd %BUILDDIR%/.. echo. echo.Build finished; the PDF files are in %BUILDDIR%/latex. goto end ) if "%1" == "text" ( %SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text if errorlevel 1 exit /b 1 echo. echo.Build finished. The text files are in %BUILDDIR%/text. goto end ) if "%1" == "man" ( %SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man if errorlevel 1 exit /b 1 echo. echo.Build finished. The manual pages are in %BUILDDIR%/man. goto end ) if "%1" == "texinfo" ( %SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo if errorlevel 1 exit /b 1 echo. echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo. goto end ) if "%1" == "gettext" ( %SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale if errorlevel 1 exit /b 1 echo. echo.Build finished. The message catalogs are in %BUILDDIR%/locale. goto end ) if "%1" == "changes" ( %SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes if errorlevel 1 exit /b 1 echo. echo.The overview file is in %BUILDDIR%/changes. goto end ) if "%1" == "linkcheck" ( %SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck if errorlevel 1 exit /b 1 echo. echo.Link check complete; look for any errors in the above output ^ or in %BUILDDIR%/linkcheck/output.txt. goto end ) if "%1" == "doctest" ( %SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest if errorlevel 1 exit /b 1 echo. echo.Testing of doctests in the sources finished, look at the ^ results in %BUILDDIR%/doctest/output.txt. goto end ) if "%1" == "xml" ( %SPHINXBUILD% -b xml %ALLSPHINXOPTS% %BUILDDIR%/xml if errorlevel 1 exit /b 1 echo. echo.Build finished. The XML files are in %BUILDDIR%/xml. goto end ) if "%1" == "pseudoxml" ( %SPHINXBUILD% -b pseudoxml %ALLSPHINXOPTS% %BUILDDIR%/pseudoxml if errorlevel 1 exit /b 1 echo. echo.Build finished. The pseudo-XML files are in %BUILDDIR%/pseudoxml. goto end ) :end aiohttp-1.2.0/docs/web_lowlevel.rst0000664000175000017500000000516513025134363020205 0ustar travistravis00000000000000.. _aiohttp-web-lowlevel: Low Level Server ================ .. currentmodule:: aiohttp.web This topic describes :mod:`aiohttp.web` based *low level* API. Abstract -------- Sometimes user don't need high-level concepts introduced in :ref:`aiohttp-web`: applications, routers, middlewares and signals. All what is needed is supporting asynchronous callable which accepts a request and returns a response object. This is done by introducing :class:`aiohttp.web.WebServer` class which serves a *protocol factory* role for :meth:`asyncio.AbstractEventLoop.create_server` and bridges data stream to *web handler* and sends result back. Low level *web handler* should accept the single :class:`BaseRequest` parameter and performs one of the following actions: 1. Return a :class:`Response` with the whole HTTP body stored in memory. 2. Create a :class:`StreamResponse`, send headers by :meth:`StreamResponse.prepare` call, send data chunks by :meth:`StreamResponse.write` / :meth:`StreamResponse.drain`, return finished response. 3. Raise :class:`HTTPException` derived exception (see :ref:`aiohttp-web-exceptions` section). All other exceptions not derived from :class:`HTTPException` leads to *500 Internal Server Error* response. 4. Initiate and process Web-Socket connection by :class:`WebSocketResponse` using (see :ref:`aiohttp-web-websockets`). Run a Basic Low-Level Server ---------------------------- The following code demonstrates very trivial usage example:: import asyncio from aiohttp import web async def handler(request): return web.Response(text="OK") async def main(loop): server = web.Server(handler) await loop.create_server(server, "127.0.0.1", 8080) print("======= Serving on http://127.0.0.1:8080/ ======") # pause here for very long time by serving HTTP requests and # waiting for keyboard interruption await asyncio.sleep(100*3600) loop = asyncio.get_event_loop() try: loop.run_until_complete(main(loop)) except KeyboardInterrupt: pass loop.close() In the snippet we have ``handler`` which returns a regular :class:`Response` with ``"OK"`` in BODY. This *handler* is processed by ``server`` (:class:`Server` which acts as *protocol factory*). Network communication is created by ``loop.create_server`` call to serve ``http://127.0.0.1:8080/``. The handler should process every request: ``GET``, ``POST``, Web-Socket for every *path*. The example is very basic: it always return ``200 OK`` response, real life code should be much more complex. .. disqus:: :title: aiohttp.web low-level server aiohttp-1.2.0/docs/web_reference.rst0000664000175000017500000020206013025134363020303 0ustar travistravis00000000000000.. _aiohttp-web-reference: Server Reference ================ .. module:: aiohttp.web .. currentmodule:: aiohttp.web .. _aiohttp-web-request: Request and Base Request ------------------------ The Request object contains all the information about an incoming HTTP request. :class:`BaseRequest` is used for :ref:`Low-Level Servers` (which have no applications, routers, signals and middlewares) and :class:`Request` has an *application* and *match info* attributes. A :class:`BaseRequest`/:class:`Request` are :obj:`dict`-like objects, allowing them to be used for :ref:`sharing data` among :ref:`aiohttp-web-middlewares` and :ref:`aiohttp-web-signals` handlers. .. class:: BaseRequest .. attribute:: version *HTTP version* of request, Read-only property. Returns :class:`aiohttp.protocol.HttpVersion` instance. .. attribute:: method *HTTP method*, read-only property. The value is upper-cased :class:`str` like ``"GET"``, ``"POST"``, ``"PUT"`` etc. .. attribute:: url A :class:`~yarl.URL` instance with absolute URL to resource (*scheme*, *host* and *port* are included). .. note:: In case of malformed request (e.g. without ``"HOST"`` HTTP header) the absolute url may be unavailable. .. attribute:: rel_url A :class:`~yarl.URL` instance with relative URL to resource (contains *path*, *query* and *fragment* parts only, *scheme*, *host* and *port* are excluded). The property is equal to ``.url.relative()`` but is always present. .. seealso:: A note from :attr:`url`. .. attribute:: scheme A string representing the scheme of the request. The scheme is ``'https'`` if transport for request handling is *SSL* or ``secure_proxy_ssl_header`` is matching. ``'http'`` otherwise. Read-only :class:`str` property. .. seealso:: :meth:`Application.make_handler` .. deprecated:: 1.1 Use :attr:`url` (``request.url.scheme``) instead. .. attribute:: host *HOST* header of request, Read-only property. Returns :class:`str` or ``None`` if HTTP request has no *HOST* header. .. deprecated:: 1.1 Use :attr:`url` (``request.url.host``) instead. .. attribute:: path_qs The URL including PATH_INFO and the query string. e.g., ``/app/blog?id=10`` Read-only :class:`str` property. .. deprecated:: 1.1 Use :attr:`url` (``str(request.rel_url)``) instead. .. attribute:: path The URL including *PATH INFO* without the host or scheme. e.g., ``/app/blog``. The path is URL-unquoted. For raw path info see :attr:`raw_path`. Read-only :class:`str` property. .. deprecated:: 1.1 Use :attr:`url` (``request.rel_url.path``) instead. .. attribute:: raw_path The URL including raw *PATH INFO* without the host or scheme. Warning, the path may be quoted and may contains non valid URL characters, e.g. ``/my%2Fpath%7Cwith%21some%25strange%24characters``. For unquoted version please take a look on :attr:`path`. Read-only :class:`str` property. .. deprecated:: 1.1 Use :attr:`url` (``request.rel_url.raw_path``) instead. .. attribute:: query_string The query string in the URL, e.g., ``id=10`` Read-only :class:`str` property. .. deprecated:: 1.1 Use :attr:`url` (``request.rel_url.query_string``) instead. .. attribute:: GET A multidict with all the variables in the query string. Read-only :class:`~multidict.MultiDictProxy` lazy property. .. versionchanged:: 0.17 A multidict contains empty items for query string like ``?arg=``. .. deprecated:: 1.1 Use :attr:`url` (``request.rel_url.query``) instead. .. attribute:: POST A multidict with all the variables in the POST parameters. POST property available only after :meth:`Request.post` coroutine call. Read-only :class:`~multidict.MultiDictProxy`. :raises RuntimeError: if :meth:`Request.post` was not called \ before accessing the property. .. deprecated:: 1.1 Since POST date preloaded is not implemented yet and probably will never be done the :meth:`post` call is required and recommended way for accessing to POST data. :meth:`multipart` is useful for working with multipart encoded content. .. attribute:: headers A case-insensitive multidict proxy with all headers. Read-only :class:`~multidict.CIMultiDictProxy` property. .. attribute:: raw_headers HTTP headers of response as unconverted bytes, a sequence of ``(key, value)`` pairs. .. attribute:: keep_alive ``True`` if keep-alive connection enabled by HTTP client and protocol version supports it, otherwise ``False``. Read-only :class:`bool` property. .. attribute:: transport An :ref:`transport` used to process request, Read-only property. The property can be used, for example, for getting IP address of client's peer:: peername = request.transport.get_extra_info('peername') if peername is not None: host, port = peername .. attribute:: cookies A multidict of all request's cookies. Read-only :class:`~multidict.MultiDictProxy` lazy property. .. attribute:: content A :class:`~aiohttp.StreamReader` instance, input stream for reading request's *BODY*. Read-only property. .. attribute:: has_body Return ``True`` if request has *HTTP BODY*, ``False`` otherwise. Read-only :class:`bool` property. .. versionadded:: 0.16 .. attribute:: content_type Read-only property with *content* part of *Content-Type* header. Returns :class:`str` like ``'text/html'`` .. note:: Returns value is ``'application/octet-stream'`` if no Content-Type header present in HTTP headers according to :rfc:`2616` .. attribute:: charset Read-only property that specifies the *encoding* for the request's BODY. The value is parsed from the *Content-Type* HTTP header. Returns :class:`str` like ``'utf-8'`` or ``None`` if *Content-Type* has no charset information. .. attribute:: content_length Read-only property that returns length of the request's BODY. The value is parsed from the *Content-Length* HTTP header. Returns :class:`int` or ``None`` if *Content-Length* is absent. .. attribute:: http_range Read-only property that returns information about *Range* HTTP header. Returns a :class:`slice` where ``.start`` is *left inclusive bound*, ``.stop`` is *right exclusive bound* and ``.step`` is ``1``. The property might be used in two manners: 1. Attribute-access style (example assumes that both left and right borders are set, the real logic for case of open bounds is more complex):: rng = request.http_rangea with open(filename, 'rb') as f: f.seek(rng.start) return f.read(rng.stop-rng.start) 2. Slice-style:: return buffer[request.http_range] .. versionadded:: 1.2 .. attribute:: if_modified_since Read-only property that returns the date specified in the *If-Modified-Since* header. Returns :class:`datetime.datetime` or ``None`` if *If-Modified-Since* header is absent or is not a valid HTTP date. .. method:: clone(*, method=..., rel_url=..., headers=...) Clone itself with replacement some attributes. Creates and returns a new instance of Request object. If no parameters are given, an exact copy is returned. If a parameter is not passed, it will reuse the one from the current request object. :param str method: http method :param rel_url: url to use, :class:`str` or :class:`~yarl.URL` :param headers: :class:`~multidict.CIMultidict` or compatible headers container. :return: a cloned :class:`Request` instance. .. coroutinemethod:: read() Read request body, returns :class:`bytes` object with body content. .. note:: The method **does** store read data internally, subsequent :meth:`~Request.read` call will return the same value. .. coroutinemethod:: text() Read request body, decode it using :attr:`charset` encoding or ``UTF-8`` if no encoding was specified in *MIME-type*. Returns :class:`str` with body content. .. note:: The method **does** store read data internally, subsequent :meth:`~Request.text` call will return the same value. .. coroutinemethod:: json(*, loads=json.loads) Read request body decoded as *json*. The method is just a boilerplate :ref:`coroutine ` implemented as:: async def json(self, *, loads=json.loads): body = await self.text() return loads(body) :param callable loads: any :term:`callable` that accepts :class:`str` and returns :class:`dict` with parsed JSON (:func:`json.loads` by default). .. note:: The method **does** store read data internally, subsequent :meth:`~Request.json` call will return the same value. .. coroutinemethod:: multipart(*, reader=aiohttp.multipart.MultipartReader) Returns :class:`aiohttp.multipart.MultipartReader` which processes incoming *multipart* request. The method is just a boilerplate :ref:`coroutine ` implemented as:: async def multipart(self, *, reader=aiohttp.multipart.MultipartReader): return reader(self.headers, self._payload) This method is a coroutine for consistency with the else reader methods. .. warning:: The method **does not** store read data internally. That means once you exhausts multipart reader, you cannot get the request payload one more time. .. seealso:: :ref:`aiohttp-multipart` .. coroutinemethod:: post() A :ref:`coroutine ` that reads POST parameters from request body. Returns :class:`~multidict.MultiDictProxy` instance filled with parsed data. If :attr:`method` is not *POST*, *PUT*, *PATCH*, *TRACE* or *DELETE* or :attr:`content_type` is not empty or *application/x-www-form-urlencoded* or *multipart/form-data* returns empty multidict. .. note:: The method **does** store read data internally, subsequent :meth:`~Request.post` call will return the same value. .. coroutinemethod:: release() Release request. Eat unread part of HTTP BODY if present. .. note:: User code may never call :meth:`~Request.release`, all required work will be processed by :mod:`aiohttp.web` internal machinery. .. class:: Request An request used for receiving request's information by *web handler*. Every :ref:`handler` accepts a request instance as the first positional parameter. The class in derived from :class:`BaseRequest`, shares all parent's attributes and methods but has a couple of additional properties: .. attribute:: match_info Read-only property with :class:`~aiohttp.abc.AbstractMatchInfo` instance for result of route resolving. .. note:: Exact type of property depends on used router. If ``app.router`` is :class:`UrlDispatcher` the property contains :class:`UrlMappingMatchInfo` instance. .. attribute:: app An :class:`Application` instance used to call :ref:`request handler `, Read-only property. .. note:: You should never create the :class:`Request` instance manually -- :mod:`aiohttp.web` does it for you. But :meth:`~BaseRequest.clone` may be used for cloning *modified* request copy with changed *path*, *method* etc. .. _aiohttp-web-response: Response classes ---------------- For now, :mod:`aiohttp.web` has two classes for the *HTTP response*: :class:`StreamResponse` and :class:`Response`. Usually you need to use the second one. :class:`StreamResponse` is intended for streaming data, while :class:`Response` contains *HTTP BODY* as an attribute and sends own content as single piece with the correct *Content-Length HTTP header*. For sake of design decisions :class:`Response` is derived from :class:`StreamResponse` parent class. The response supports *keep-alive* handling out-of-the-box if *request* supports it. You can disable *keep-alive* by :meth:`~StreamResponse.force_close` though. The common case for sending an answer from :ref:`web-handler` is returning a :class:`Response` instance:: def handler(request): return Response("All right!") StreamResponse ^^^^^^^^^^^^^^ .. class:: StreamResponse(*, status=200, reason=None) The base class for the *HTTP response* handling. Contains methods for setting *HTTP response headers*, *cookies*, *response status code*, writing *HTTP response BODY* and so on. The most important thing you should know about *response* --- it is *Finite State Machine*. That means you can do any manipulations with *headers*, *cookies* and *status code* only before :meth:`prepare` coroutine is called. Once you call :meth:`prepare` any change of the *HTTP header* part will raise :exc:`RuntimeError` exception. Any :meth:`write` call after :meth:`write_eof` is also forbidden. :param int status: HTTP status code, ``200`` by default. :param str reason: HTTP reason. If param is ``None`` reason will be calculated basing on *status* parameter. Otherwise pass :class:`str` with arbitrary *status* explanation.. .. attribute:: prepared Read-only :class:`bool` property, ``True`` if :meth:`prepare` has been called, ``False`` otherwise. .. versionadded:: 0.18 .. attribute:: started Deprecated alias for :attr:`prepared`. .. deprecated:: 0.18 .. attribute:: task A task that serves HTTP request handling. May be useful for graceful shutdown of long-running requests (streaming, long polling or web-socket). .. versionadded:: 1.2 .. attribute:: status Read-only property for *HTTP response status code*, :class:`int`. ``200`` (OK) by default. .. attribute:: reason Read-only property for *HTTP response reason*, :class:`str`. .. method:: set_status(status, reason=None) Set :attr:`status` and :attr:`reason`. *reason* value is auto calculated if not specified (``None``). .. attribute:: keep_alive Read-only property, copy of :attr:`Request.keep_alive` by default. Can be switched to ``False`` by :meth:`force_close` call. .. method:: force_close Disable :attr:`keep_alive` for connection. There are no ways to enable it back. .. attribute:: compression Read-only :class:`bool` property, ``True`` if compression is enabled. ``False`` by default. .. seealso:: :meth:`enable_compression` .. method:: enable_compression(force=None) Enable compression. When *force* is unset compression encoding is selected based on the request's *Accept-Encoding* header. *Accept-Encoding* is not checked if *force* is set to a :class:`ContentCoding`. .. seealso:: :attr:`compression` .. attribute:: chunked Read-only property, indicates if chunked encoding is on. Can be enabled by :meth:`enable_chunked_encoding` call. .. seealso:: :attr:`enable_chunked_encoding` .. method:: enable_chunked_encoding Enables :attr:`chunked` encoding for response. There are no ways to disable it back. With enabled :attr:`chunked` encoding each `write()` operation encoded in separate chunk. .. warning:: chunked encoding can be enabled for ``HTTP/1.1`` only. Setting up both :attr:`content_length` and chunked encoding is mutually exclusive. .. seealso:: :attr:`chunked` .. attribute:: headers :class:`~aiohttp.CIMultiiDct` instance for *outgoing* *HTTP headers*. .. attribute:: cookies An instance of :class:`http.cookies.SimpleCookie` for *outgoing* cookies. .. warning:: Direct setting up *Set-Cookie* header may be overwritten by explicit calls to cookie manipulation. We are encourage using of :attr:`cookies` and :meth:`set_cookie`, :meth:`del_cookie` for cookie manipulations. .. method:: set_cookie(name, value, *, path='/', expires=None, \ domain=None, max_age=None, \ secure=None, httponly=None, version=None) Convenient way for setting :attr:`cookies`, allows to specify some additional properties like *max_age* in a single call. :param str name: cookie name :param str value: cookie value (will be converted to :class:`str` if value has another type). :param expires: expiration date (optional) :param str domain: cookie domain (optional) :param int max_age: defines the lifetime of the cookie, in seconds. The delta-seconds value is a decimal non- negative integer. After delta-seconds seconds elapse, the client should discard the cookie. A value of zero means the cookie should be discarded immediately. (optional) :param str path: specifies the subset of URLs to which this cookie applies. (optional, ``'/'`` by default) :param bool secure: attribute (with no value) directs the user agent to use only (unspecified) secure means to contact the origin server whenever it sends back this cookie. The user agent (possibly under the user's control) may determine what level of security it considers appropriate for "secure" cookies. The *secure* should be considered security advice from the server to the user agent, indicating that it is in the session's interest to protect the cookie contents. (optional) :param bool httponly: ``True`` if the cookie HTTP only (optional) :param int version: a decimal integer, identifies to which version of the state management specification the cookie conforms. (Optional, *version=1* by default) .. warning:: In HTTP version 1.1, ``expires`` was deprecated and replaced with the easier-to-use ``max-age``, but Internet Explorer (IE6, IE7, and IE8) **does not** support ``max-age``. .. method:: del_cookie(name, *, path='/', domain=None) Deletes cookie. :param str name: cookie name :param str domain: optional cookie domain :param str path: optional cookie path, ``'/'`` by default .. versionchanged:: 1.0 Fixed cookie expiration support for Internet Explorer (version less than 11). .. attribute:: content_length *Content-Length* for outgoing response. .. attribute:: content_type *Content* part of *Content-Type* for outgoing response. .. attribute:: charset *Charset* aka *encoding* part of *Content-Type* for outgoing response. The value converted to lower-case on attribute assigning. .. attribute:: last_modified *Last-Modified* header for outgoing response. This property accepts raw :class:`str` values, :class:`datetime.datetime` objects, Unix timestamps specified as an :class:`int` or a :class:`float` object, and the value ``None`` to unset the header. .. attribute:: tcp_cork :const:`~socket.TCP_CORK` (linux) or :const:`~socket.TCP_NOPUSH` (FreeBSD and MacOSX) is applied to underlying transport if the property is ``True``. Use :meth:`set_tcp_cork` to assign new value to the property. Default value is ``False``. .. method:: set_tcp_cork(value) Set :attr:`tcp_cork` property to *value*. Clear :attr:`tcp_nodelay` if *value* is ``True``. .. attribute:: tcp_nodelay :const:`~socket.TCP_NODELAY` is applied to underlying transport if the property is ``True``. Use :meth:`set_tcp_nodelay` to assign new value to the property. Default value is ``True``. .. method:: set_tcp_nodelay(value) Set :attr:`tcp_nodelay` property to *value*. Clear :attr:`tcp_cork` if *value* is ``True``. .. method:: start(request) :param aiohttp.web.Request request: HTTP request object, that the response answers. Send *HTTP header*. You should not change any header data after calling this method. .. deprecated:: 0.18 Use :meth:`prepare` instead. .. warning:: The method doesn't call :attr:`~aiohttp.web.Application.on_response_prepare` signal, use :meth:`prepare` instead. .. coroutinemethod:: prepare(request) :param aiohttp.web.Request request: HTTP request object, that the response answers. Send *HTTP header*. You should not change any header data after calling this method. The coroutine calls :attr:`~aiohttp.web.Application.on_response_prepare` signal handlers. .. versionadded:: 0.18 .. method:: write(data) Send byte-ish data as the part of *response BODY*. :meth:`prepare` must be called before. Raises :exc:`TypeError` if data is not :class:`bytes`, :class:`bytearray` or :class:`memoryview` instance. Raises :exc:`RuntimeError` if :meth:`prepare` has not been called. Raises :exc:`RuntimeError` if :meth:`write_eof` has been called. .. coroutinemethod:: drain() A :ref:`coroutine` to let the write buffer of the underlying transport a chance to be flushed. The intended use is to write:: resp.write(data) await resp.drain() Yielding from :meth:`drain` gives the opportunity for the loop to schedule the write operation and flush the buffer. It should especially be used when a possibly large amount of data is written to the transport, and the coroutine does not yield-from between calls to :meth:`write`. .. coroutinemethod:: write_eof() A :ref:`coroutine` *may* be called as a mark of the *HTTP response* processing finish. *Internal machinery* will call this method at the end of the request processing if needed. After :meth:`write_eof` call any manipulations with the *response* object are forbidden. Response ^^^^^^^^ .. class:: Response(*, status=200, headers=None, content_type=None, \ charset=None, \ body=None, text=None) The most usable response class, inherited from :class:`StreamResponse`. Accepts *body* argument for setting the *HTTP response BODY*. The actual :attr:`body` sending happens in overridden :meth:`~StreamResponse.write_eof`. :param bytes body: response's BODY :param int status: HTTP status code, 200 OK by default. :param collections.abc.Mapping headers: HTTP headers that should be added to response's ones. :param str text: response's BODY :param str content_type: response's content type. ``'text/plain'`` if *text* is passed also, ``'application/octet-stream'`` otherwise. :param str charset: response's charset. ``'utf-8'`` if *text* is passed also, ``None`` otherwise. .. attribute:: body Read-write attribute for storing response's content aka BODY, :class:`bytes`. Setting :attr:`body` also recalculates :attr:`~StreamResponse.content_length` value. Resetting :attr:`body` (assigning ``None``) sets :attr:`~StreamResponse.content_length` to ``None`` too, dropping *Content-Length* HTTP header. .. attribute:: text Read-write attribute for storing response's content, represented as string, :class:`str`. Setting :attr:`text` also recalculates :attr:`~StreamResponse.content_length` value and :attr:`~StreamResponse.body` value Resetting :attr:`text` (assigning ``None``) sets :attr:`~StreamResponse.content_length` to ``None`` too, dropping *Content-Length* HTTP header. WebSocketResponse ^^^^^^^^^^^^^^^^^ .. class:: WebSocketResponse(*, timeout=10.0, autoclose=True, \ autoping=True, protocols=()) Class for handling server-side websockets, inherited from :class:`StreamResponse`. After starting (by :meth:`prepare` call) the response you cannot use :meth:`~StreamResponse.write` method but should to communicate with websocket client by :meth:`send_str`, :meth:`receive` and others. :param bool autoping: Automatically send :const:`~aiohttp.WSMsgType.PONG` on :const:`~aiohttp.WSMsgType.PING` message from client, and handle :const:`~aiohttp.WSMsgType.PONG` responses from client. Note that server doesn't send :const:`~aiohttp.WSMsgType.PING` requests, you need to do this explicitly using :meth:`ping` method. .. versionadded:: 0.19 The class supports ``async for`` statement for iterating over incoming messages:: ws = web.WebSocketResponse() await ws.prepare(request) async for msg in ws: print(msg.data) .. coroutinemethod:: prepare(request) Starts websocket. After the call you can use websocket methods. :param aiohttp.web.Request request: HTTP request object, that the response answers. :raises HTTPException: if websocket handshake has failed. .. versionadded:: 0.18 .. method:: start(request) Starts websocket. After the call you can use websocket methods. :param aiohttp.web.Request request: HTTP request object, that the response answers. :raises HTTPException: if websocket handshake has failed. .. deprecated:: 0.18 Use :meth:`prepare` instead. .. method:: can_prepare(request) Performs checks for *request* data to figure out if websocket can be started on the request. If :meth:`can_prepare` call is success then :meth:`prepare` will success too. :param aiohttp.web.Request request: HTTP request object, that the response answers. :return: :class:`WebSocketReady` instance. :attr:`WebSocketReady.ok` is ``True`` on success, :attr:`WebSocketReady.protocol` is websocket subprotocol which is passed by client and accepted by server (one of *protocols* sequence from :class:`WebSocketResponse` ctor). :attr:`WebSocketReady.protocol` may be ``None`` if client and server subprotocols are not overlapping. .. note:: The method never raises exception. .. method:: can_start(request) Deprecated alias for :meth:`can_prepare` .. deprecated:: 0.18 .. attribute:: closed Read-only property, ``True`` if connection has been closed or in process of closing. :const:`~aiohttp.WSMsgType.CLOSE` message has been received from peer. .. attribute:: close_code Read-only property, close code from peer. It is set to ``None`` on opened connection. .. attribute:: protocol Websocket *subprotocol* chosen after :meth:`start` call. May be ``None`` if server and client protocols are not overlapping. .. method:: exception() Returns last occurred exception or None. .. method:: ping(message=b'') Send :const:`~aiohttp.WSMsgType.PING` to peer. :param message: optional payload of *ping* message, :class:`str` (converted to *UTF-8* encoded bytes) or :class:`bytes`. :raise RuntimeError: if connections is not started or closing. .. method:: pong(message=b'') Send *unsolicited* :const:`~aiohttp.WSMsgType.PONG` to peer. :param message: optional payload of *pong* message, :class:`str` (converted to *UTF-8* encoded bytes) or :class:`bytes`. :raise RuntimeError: if connections is not started or closing. .. method:: send_str(data) Send *data* to peer as :const:`~aiohttp.WSMsgType.TEXT` message. :param str data: data to send. :raise RuntimeError: if connection is not started or closing :raise TypeError: if data is not :class:`str` .. method:: send_bytes(data) Send *data* to peer as :const:`~aiohttp.WSMsgType.BINARY` message. :param data: data to send. :raise RuntimeError: if connection is not started or closing :raise TypeError: if data is not :class:`bytes`, :class:`bytearray` or :class:`memoryview`. .. method:: send_json(data, *, dumps=json.loads) Send *data* to peer as JSON string. :param data: data to send. :param callable dumps: any :term:`callable` that accepts an object and returns a JSON string (:func:`json.dumps` by default). :raise RuntimeError: if connection is not started or closing :raise ValueError: if data is not serializable object :raise TypeError: if value returned by ``dumps`` param is not :class:`str` .. coroutinemethod:: close(*, code=1000, message=b'') A :ref:`coroutine` that initiates closing handshake by sending :const:`~aiohttp.WSMsgType.CLOSE` message. .. note:: Can only be called by the request handling task. To programmatically close websocket server side see the :ref:`FAQ section `. :param int code: closing code :param message: optional payload of *pong* message, :class:`str` (converted to *UTF-8* encoded bytes) or :class:`bytes`. :raise RuntimeError: if connection is not started or closing .. coroutinemethod:: receive() A :ref:`coroutine` that waits upcoming *data* message from peer and returns it. The coroutine implicitly handles :const:`~aiohttp.WSMsgType.PING`, :const:`~aiohttp.WSMsgType.PONG` and :const:`~aiohttp.WSMsgType.CLOSE` without returning the message. It process *ping-pong game* and performs *closing handshake* internally. .. note:: Can only be called by the request handling task. :return: :class:`~aiohttp.WSMessage` :raise RuntimeError: if connection is not started :raise: :exc:`~aiohttp.errors.WSClientDisconnectedError` on closing. .. coroutinemethod:: receive_str() A :ref:`coroutine` that calls :meth:`receive` but also asserts the message type is :const:`~aiohttp.WSMsgType.TEXT`. .. note:: Can only be called by the request handling task. :return str: peer's message content. :raise TypeError: if message is :const:`~aiohttp.WSMsgType.BINARY`. .. coroutinemethod:: receive_bytes() A :ref:`coroutine` that calls :meth:`receive` but also asserts the message type is :const:`~aiohttp.WSMsgType.BINARY`. .. note:: Can only be called by the request handling task. :return bytes: peer's message content. :raise TypeError: if message is :const:`~aiohttp.WSMsgType.TEXT`. .. coroutinemethod:: receive_json(*, loads=json.loads) A :ref:`coroutine` that calls :meth:`receive_str` and loads the JSON string to a Python dict. .. note:: Can only be called by the request handling task. :param callable loads: any :term:`callable` that accepts :class:`str` and returns :class:`dict` with parsed JSON (:func:`json.loads` by default). :return dict: loaded JSON content :raise TypeError: if message is :const:`~aiohttp.WSMsgType.BINARY`. :raise ValueError: if message is not valid JSON. .. versionadded:: 0.22 .. seealso:: :ref:`WebSockets handling` WebSocketReady ^^^^^^^^^^^^^^ .. class:: WebSocketReady A named tuple for returning result from :meth:`WebSocketResponse.can_prepare`. Has :class:`bool` check implemented, e.g.:: if not await ws.can_prepare(...): cannot_start_websocket() .. attribute:: ok ``True`` if websocket connection can be established, ``False`` otherwise. .. attribute:: protocol :class:`str` represented selected websocket sub-protocol. .. seealso:: :meth:`WebSocketResponse.can_prepare` json_response ------------- .. function:: json_response([data], *, text=None, body=None, \ status=200, reason=None, headers=None, \ content_type='application/json', \ dumps=json.dumps) Return :class:`Response` with predefined ``'application/json'`` content type and *data* encoded by ``dumps`` parameter (:func:`json.dumps` by default). .. _aiohttp-web-app-and-router: Application and Router ---------------------- Application ^^^^^^^^^^^ Application is a synonym for web-server. To get fully working example, you have to make *application*, register supported urls in *router* and create a *server socket* with :class:`~aiohttp.web.Server` as a *protocol factory*. *Server* could be constructed with :meth:`Application.make_handler`. *Application* contains a *router* instance and a list of callbacks that will be called during application finishing. :class:`Application` is a :obj:`dict`-like object, so you can use it for :ref:`sharing data` globally by storing arbitrary properties for later access from a :ref:`handler` via the :attr:`Request.app` property:: app = Application(loop=loop) app['database'] = await aiopg.create_engine(**db_config) async def handler(request): with (await request.app['database']) as conn: conn.execute("DELETE * FROM table") Although :class:`Application` is a :obj:`dict`-like object, it can't be duplicated like one using :meth:`Application.copy`. .. class:: Application(*, loop=None, router=None, logger=, \ middlewares=(), debug=False, **kwargs) The class inherits :class:`dict`. :param loop: :ref:`event loop` used for processing HTTP requests. If param is ``None`` :func:`asyncio.get_event_loop` used for getting default event loop, but we strongly recommend to use explicit loops everywhere. :param router: :class:`aiohttp.abc.AbstractRouter` instance, the system creates :class:`UrlDispatcher` by default if *router* is ``None``. :param logger: :class:`logging.Logger` instance for storing application logs. By default the value is ``logging.getLogger("aiohttp.web")`` :param middlewares: :class:`list` of middleware factories, see :ref:`aiohttp-web-middlewares` for details. :param debug: Switches debug mode. .. attribute:: router Read-only property that returns *router instance*. .. attribute:: logger :class:`logging.Logger` instance for storing application logs. .. attribute:: loop :ref:`event loop` used for processing HTTP requests. .. attribute:: debug Boolean value indicating whether the debug mode is turned on or off. .. attribute:: on_response_prepare A :class:`~aiohttp.signals.Signal` that is fired at the beginning of :meth:`StreamResponse.prepare` with parameters *request* and *response*. It can be used, for example, to add custom headers to each response before sending. Signal handlers should have the following signature:: async def on_prepare(request, response): pass .. attribute:: on_startup A :class:`~aiohttp.signals.Signal` that is fired on application start-up. Subscribers may use the signal to run background tasks in the event loop along with the application's request handler just after the application start-up. Signal handlers should have the following signature:: async def on_startup(app): pass .. seealso:: :ref:`aiohttp-web-background-tasks`. .. attribute:: on_shutdown A :class:`~aiohttp.signals.Signal` that is fired on application shutdown. Subscribers may use the signal for gracefully closing long running connections, e.g. websockets and data streaming. Signal handlers should have the following signature:: async def on_shutdown(app): pass It's up to end user to figure out which :term:`web-handler`\s are still alive and how to finish them properly. We suggest keeping a list of long running handlers in :class:`Application` dictionary. .. seealso:: :ref:`aiohttp-web-graceful-shutdown` and :attr:`on_cleanup`. .. attribute:: on_cleanup A :class:`~aiohttp.signals.Signal` that is fired on application cleanup. Subscribers may use the signal for gracefully closing connections to database server etc. Signal handlers should have the following signature:: async def on_cleanup(app): pass .. seealso:: :ref:`aiohttp-web-graceful-shutdown` and :attr:`on_shutdown`. .. method:: make_handler(**kwargs) Creates HTTP protocol factory for handling requests. :param tuple secure_proxy_ssl_header: Secure proxy SSL header. Can be used to detect request scheme, e.g. ``secure_proxy_ssl_header=('X-Forwarded-Proto', 'https')``. Default: ``None``. :param bool tcp_keepalive: Enable TCP Keep-Alive. Default: ``True``. :param int keepalive_timeout: Number of seconds before closing Keep-Alive connection. Default: ``75`` seconds (NGINX's default value). :param slow_request_timeout: Slow request timeout. Default: ``0``. :param logger: Custom logger object. Default: :data:`aiohttp.log.server_logger`. :param access_log: Custom logging object. Default: :data:`aiohttp.log.access_logger`. :param str access_log_format: Access log format string. Default: :attr:`helpers.AccessLogger.LOG_FORMAT`. :param bool debug: Switches debug mode. Default: ``False``. .. deprecated:: 1.0 The usage of ``debug`` parameter in :meth:`Application.make_handler` is deprecated in favor of :attr:`Application.debug`. The :class:`Application`'s debug mode setting should be used as a single point to setup a debug mode. :param int max_line_size: Optional maximum header line size. Default: ``8190``. :param int max_headers: Optional maximum header size. Default: ``32768``. :param int max_field_size: Optional maximum header field size. Default: ``8190``. :param float lingering_time: maximum time during which the server reads and ignore additional data coming from the client when lingering close is on. Use ``0`` for disabling lingering on server channel closing. :param float lingering_timeout: maximum waiting time for more client data to arrive when lingering close is in effect You should pass result of the method as *protocol_factory* to :meth:`~asyncio.AbstractEventLoop.create_server`, e.g.:: loop = asyncio.get_event_loop() app = Application(loop=loop) # setup route table # app.router.add_route(...) await loop.create_server(app.make_handler(), '0.0.0.0', 8080) .. coroutinemethod:: startup() A :ref:`coroutine` that will be called along with the application's request handler. The purpose of the method is calling :attr:`on_startup` signal handlers. .. coroutinemethod:: shutdown() A :ref:`coroutine` that should be called on server stopping but before :meth:`finish()`. The purpose of the method is calling :attr:`on_shutdown` signal handlers. .. coroutinemethod:: cleanup() A :ref:`coroutine` that should be called on server stopping but after :meth:`shutdown`. The purpose of the method is calling :attr:`on_cleanup` signal handlers. .. coroutinemethod:: finish() A deprecated alias for :meth:`cleanup`. .. deprecated:: 0.21 .. method:: register_on_finish(self, func, *args, **kwargs): Register *func* as a function to be executed at termination. Any optional arguments that are to be passed to *func* must be passed as arguments to :meth:`register_on_finish`. It is possible to register the same function and arguments more than once. During the call of :meth:`finish` all functions registered are called in last in, first out order. *func* may be either regular function or :ref:`coroutine`, :meth:`finish` will un-yield (`await`) the later. .. deprecated:: 0.21 Use :attr:`on_cleanup` instead: ``app.on_cleanup.append(handler)``. .. note:: Application object has :attr:`router` attribute but has no ``add_route()`` method. The reason is: we want to support different router implementations (even maybe not url-matching based but traversal ones). For sake of that fact we have very trivial ABC for :class:`AbstractRouter`: it should have only :meth:`AbstractRouter.resolve` coroutine. No methods for adding routes or route reversing (getting URL by route name). All those are router implementation details (but, sure, you need to deal with that methods after choosing the router for your application). Server ^^^^^^ A protocol factory compatible with :meth:`~asyncio.AbstreactEventLoop.create_server`. .. class:: Server The class is responsible for creating HTTP protocol objects that can handle HTTP connections. .. attribute:: Server.connections List of all currently opened connections. .. attribute:: requests_count Amount of processed requests. .. versionadded:: 1.0 .. coroutinemethod:: Server.shutdown(timeout) A :ref:`coroutine` that should be called to close all opened connections. .. coroutinemethod:: Server.finish_connections(timeout) .. deprecated:: 1.2 A deprecated alias for :meth:`shutdown`. .. versionchanged:: 1.2 ``Server`` was called ``RequestHandlerFactory`` before ``aiohttp==1.2``. The rename has no deprecation period but it's safe: no user should instantiate the class by hands. Router ^^^^^^ For dispatching URLs to :ref:`handlers` :mod:`aiohttp.web` uses *routers*. Router is any object that implements :class:`AbstractRouter` interface. :mod:`aiohttp.web` provides an implementation called :class:`UrlDispatcher`. :class:`Application` uses :class:`UrlDispatcher` as :meth:`router` by default. .. class:: UrlDispatcher() Straightforward url-matching router, implements :class:`collections.abc.Mapping` for access to *named routes*. Before running :class:`Application` you should fill *route table* first by calling :meth:`add_route` and :meth:`add_static`. :ref:`Handler` lookup is performed by iterating on added *routes* in FIFO order. The first matching *route* will be used to call corresponding *handler*. If on route creation you specify *name* parameter the result is *named route*. *Named route* can be retrieved by ``app.router[name]`` call, checked for existence by ``name in app.router`` etc. .. seealso:: :ref:`Route classes ` .. method:: add_resource(path, *, name=None) Append a :term:`resource` to the end of route table. *path* may be either *constant* string like ``'/a/b/c'`` or *variable rule* like ``'/a/{var}'`` (see :ref:`handling variable paths `) :param str path: resource path spec. :param str name: optional resource name. :return: created resource instance (:class:`PlainResource` or :class:`DynamicResource`). .. method:: add_route(method, path, handler, *, \ name=None, expect_handler=None) Append :ref:`handler` to the end of route table. *path* may be either *constant* string like ``'/a/b/c'`` or *variable rule* like ``'/a/{var}'`` (see :ref:`handling variable paths `) Pay attention please: *handler* is converted to coroutine internally when it is a regular function. :param str method: HTTP method for route. Should be one of ``'GET'``, ``'POST'``, ``'PUT'``, ``'DELETE'``, ``'PATCH'``, ``'HEAD'``, ``'OPTIONS'`` or ``'*'`` for any method. The parameter is case-insensitive, e.g. you can push ``'get'`` as well as ``'GET'``. :param str path: route path. Should be started with slash (``'/'``). :param callable handler: route handler. :param str name: optional route name. :param coroutine expect_handler: optional *expect* header handler. :returns: new :class:`PlainRoute` or :class:`DynamicRoute` instance. .. method:: add_get(path, *args, **kwargs) Shortcut for adding a GET handler. Calls the :meth:`add_route` with \ ``method`` equals to ``'GET'``. .. versionadded:: 1.0 .. method:: add_post(path, *args, **kwargs) Shortcut for adding a POST handler. Calls the :meth:`add_route` with \ ``method`` equals to ``'POST'``. .. versionadded:: 1.0 .. method:: add_put(path, *args, **kwargs) Shortcut for adding a PUT handler. Calls the :meth:`add_route` with \ ``method`` equals to ``'PUT'``. .. versionadded:: 1.0 .. method:: add_patch(path, *args, **kwargs) Shortcut for adding a PATCH handler. Calls the :meth:`add_route` with \ ``method`` equals to ``'PATCH'``. .. versionadded:: 1.0 .. method:: add_delete(path, *args, **kwargs) Shortcut for adding a DELETE handler. Calls the :meth:`add_route` with \ ``method`` equals to ``'DELETE'``. .. versionadded:: 1.0 .. method:: add_static(prefix, path, *, name=None, expect_handler=None, \ chunk_size=256*1024, \ response_factory=StreamResponse, \ show_index=False, \ follow_symlinks=False) Adds a router and a handler for returning static files. Useful for serving static content like images, javascript and css files. On platforms that support it, the handler will transfer files more efficiently using the ``sendfile`` system call. In some situations it might be necessary to avoid using the ``sendfile`` system call even if the platform supports it. This can be accomplished by by setting environment variable ``AIOHTTP_NOSENDFILE=1``. If a gzip version of the static content exists at file path + ``.gz``, it will be used for the response. .. warning:: Use :meth:`add_static` for development only. In production, static content should be processed by web servers like *nginx* or *apache*. .. versionchanged:: 0.18.0 Transfer files using the ``sendfile`` system call on supported platforms. .. versionchanged:: 0.19.0 Disable ``sendfile`` by setting environment variable ``AIOHTTP_NOSENDFILE=1`` .. versionchanged:: 1.2.0 Send gzip version if file path + ``.gz`` exists. :param str prefix: URL path prefix for handled static files :param path: path to the folder in file system that contains handled static files, :class:`str` or :class:`pathlib.Path`. :param str name: optional route name. :param coroutine expect_handler: optional *expect* header handler. :param int chunk_size: size of single chunk for file downloading, 256Kb by default. Increasing *chunk_size* parameter to, say, 1Mb may increase file downloading speed but consumes more memory. .. versionadded:: 0.16 :param callable response_factory: factory to use to generate a new response, defaults to :class:`StreamResponse` and should expose a compatible API. .. versionadded:: 0.17 :param bool show_index: flag for allowing to show indexes of a directory, by default it's not allowed and HTTP/403 will be returned on directory access. :param bool follow_symlinks: flag for allowing to follow symlinks from a directory, by default it's not allowed and HTTP/404 will be returned on access. :returns: new :class:`StaticRoute` instance. .. method:: add_subapp(prefix, subapp) Register nested sub-application under given path *prefix*. In resolving process if request's path starts with *prefix* then further resolving is passed to *subapp*. :param str prefix: path's prefix for the resource. :param Application subapp: nested application attached under *prefix*. :returns: a :class:`PrefixedSubAppResource` instance. .. versionadded:: 1.1 .. coroutinemethod:: resolve(request) A :ref:`coroutine` that returns :class:`AbstractMatchInfo` for *request*. The method never raises exception, but returns :class:`AbstractMatchInfo` instance with: 1. :attr:`~AbstractMatchInfo.http_exception` assigned to :exc:`HTTPException` instance. 2. :attr:`~AbstractMatchInfo.handler` which raises :exc:`HTTPNotFound` or :exc:`HTTPMethodNotAllowed` on handler's execution if there is no registered route for *request*. *Middlewares* can process that exceptions to render pretty-looking error page for example. Used by internal machinery, end user unlikely need to call the method. .. note:: The method uses :attr:`Request.raw_path` for pattern matching against registered routes. .. method:: resources() The method returns a *view* for *all* registered resources. The view is an object that allows to: 1. Get size of the router table:: len(app.router.resources()) 2. Iterate over registered resources:: for resource in app.router.resources(): print(resource) 3. Make a check if the resources is registered in the router table:: route in app.router.resources() .. versionadded:: 0.21.1 .. method:: routes() The method returns a *view* for *all* registered routes. .. versionadded:: 0.18 .. method:: named_resources() Returns a :obj:`dict`-like :class:`types.MappingProxyType` *view* over *all* named **resources**. The view maps every named resource's **name** to the :class:`BaseResource` instance. It supports the usual :obj:`dict`-like operations, except for any mutable operations (i.e. it's **read-only**):: len(app.router.named_resources()) for name, resource in app.router.named_resources().items(): print(name, resource) "name" in app.router.named_resources() app.router.named_resources()["name"] .. versionadded:: 0.21 .. method:: named_routes() An alias for :meth:`named_resources` starting from aiohttp 0.21. .. versionadded:: 0.19 .. versionchanged:: 0.21 The method is an alias for :meth:`named_resources`, so it iterates over resources instead of routes. .. deprecated:: 0.21 Please use named **resources** instead of named **routes**. Several routes which belongs to the same resource shares the resource name. .. _aiohttp-web-resource: Resource ^^^^^^^^ Default router :class:`UrlDispatcher` operates with :term:`resource`\s. Resource is an item in *routing table* which has a *path*, an optional unique *name* and at least one :term:`route`. :term:`web-handler` lookup is performed in the following way: 1. Router iterates over *resources* one-by-one. 2. If *resource* matches to requested URL the resource iterates over own *routes*. 3. If route matches to requested HTTP method (or ``'*'`` wildcard) the route's handler is used as found :term:`web-handler`. The lookup is finished. 4. Otherwise router tries next resource from the *routing table*. 5. If the end of *routing table* is reached and no *resource* / *route* pair found the *router* returns special :class:`AbstractMatchInfo` instance with :attr:`AbstractMatchInfo.http_exception` is not ``None`` but :exc:`HTTPException` with either *HTTP 404 Not Found* or *HTTP 405 Method Not Allowed* status code. Registered :attr:`AbstractMatchInfo.handler` raises this exception on call. User should never instantiate resource classes but give it by :meth:`UrlDispatcher.add_resource` call. After that he may add a :term:`route` by calling :meth:`Resource.add_route`. :meth:`UrlDispatcher.add_route` is just shortcut for:: router.add_resource(path).add_route(method, handler) Resource with a *name* is called *named resource*. The main purpose of *named resource* is constructing URL by route name for passing it into *template engine* for example:: url = app.router['resource_name'].url_for().with_query({'a': 1, 'b': 2}) Resource classes hierarchy:: AbstractResource Resource PlainResource DynamicResource StaticResource .. class:: AbstractResource A base class for all resources. Inherited from :class:`collections.abc.Sized` and :class:`collections.abc.Iterable`. ``len(resource)`` returns amount of :term:`route`\s belongs to the resource, ``for route in resource`` allows to iterate over these routes. .. attribute:: name Read-only *name* of resource or ``None``. .. coroutinemethod:: resolve(method, path) Resolve resource by finding appropriate :term:`web-handler` for ``(method, path)`` combination. :param str method: requested HTTP method. :param str path: *path* part of request. :return: (*match_info*, *allowed_methods*) pair. *allowed_methods* is a :class:`set` or HTTP methods accepted by resource. *match_info* is either :class:`UrlMappingMatchInfo` if request is resolved or ``None`` if no :term:`route` is found. .. method:: get_info() A resource description, e.g. ``{'path': '/path/to'}`` or ``{'formatter': '/path/{to}', 'pattern': re.compile(r'^/path/(?P[a-zA-Z][_a-zA-Z0-9]+)$`` .. method:: url_for(*args, **kwargs) Construct an URL for route with additional params. *args* and **kwargs** depend on a parameters list accepted by inherited resource class. :return: :class:`~yarl.URL` -- resulting URL instance. .. versionadded:: 1.1 .. method:: url(**kwargs) Construct an URL for route with additional params. **kwargs** depends on a list accepted by inherited resource class parameters. :return: :class:`str` -- resulting URL string. .. deprecated:: 1.1 Use :meth:`url_for` instead. .. class:: Resource A base class for new-style resources, inherits :class:`AbstractResource`. .. method:: add_route(method, handler, *, expect_handler=None) Add a :term:`web-handler` to resource. :param str method: HTTP method for route. Should be one of ``'GET'``, ``'POST'``, ``'PUT'``, ``'DELETE'``, ``'PATCH'``, ``'HEAD'``, ``'OPTIONS'`` or ``'*'`` for any method. The parameter is case-insensitive, e.g. you can push ``'get'`` as well as ``'GET'``. The method should be unique for resource. :param callable handler: route handler. :param coroutine expect_handler: optional *expect* header handler. :returns: new :class:`ResourceRoute` instance. .. class:: PlainResource A resource, inherited from :class:`Resource`. The class corresponds to resources with plain-text matching, ``'/path/to'`` for example. .. method:: url_for() Returns a :class:`~yarl.URL` for the resource. .. versionadded:: 1.1 .. class:: DynamicResource A resource, inherited from :class:`Resource`. The class corresponds to resources with :ref:`variable ` matching, e.g. ``'/path/{to}/{param}'`` etc. .. method:: url_for(**params) Returns a :class:`~yarl.URL` for the resource. :param params: -- a variable substitutions for dynamic resource. E.g. for ``'/path/{to}/{param}'`` pattern the method should be called as ``resource.url_for(to='val1', param='val2')`` .. versionadded:: 1.1 .. class:: StaticResource A resource, inherited from :class:`Resource`. The class corresponds to resources for :ref:`static file serving `. .. method:: url_for(filename) Returns a :class:`~yarl.URL` for file path under resource prefix. :param filename: -- a file name substitution for static file handler. Accepts both :class:`str` and :class:`pathlib.Path`. E.g. an URL for ``'/prefix/dir/file.txt'`` should be generated as ``resource.url_for(filename='dir/file.txt')`` .. versionadded:: 1.1 .. class:: PrefixedSubAppResource A resource for serving nested applications. The class instance is returned by :class:`~aiohttp.web.UrlDispatcher.add_subapp` call. .. versionadded:: 1.1 .. method:: url_for(**kwargs) The call is not allowed, it raises :exc:`RuntimeError`. .. _aiohttp-web-route: Route ^^^^^ Route has *HTTP method* (wildcard ``'*'`` is an option), :term:`web-handler` and optional *expect handler*. Every route belong to some resource. Route classes hierarchy:: AbstractRoute ResourceRoute SystemRoute :class:`ResourceRoute` is the route used for resources, :class:`SystemRoute` serves URL resolving errors like *404 Not Found* and *405 Method Not Allowed*. .. class:: AbstractRoute Base class for routes served by :class:`UrlDispatcher`. .. attribute:: method HTTP method handled by the route, e.g. *GET*, *POST* etc. .. attribute:: handler :ref:`handler` that processes the route. .. attribute:: name Name of the route, always equals to name of resource which owns the route. .. attribute:: resource Resource instance which holds the route, ``None`` for :class:`SystemRoute`. .. method:: url_for(*args, **kwargs) Abstract method for constructing url handled by the route. Actually it's a shortcut for ``route.resource.url_for(...)``. .. coroutinemethod:: handle_expect_header(request) ``100-continue`` handler. .. class:: ResourceRoute The route class for handling different HTTP methods for :class:`Resource`. .. class:: SystemRoute The route class for handling URL resolution errors like like *404 Not Found* and *405 Method Not Allowed*. .. attribute:: status HTTP status code .. attribute:: reason HTTP status reason MatchInfo ^^^^^^^^^ After route matching web application calls found handler if any. Matching result can be accessible from handler as :attr:`Request.match_info` attribute. In general the result may be any object derived from :class:`AbstractMatchInfo` (:class:`UrlMappingMatchInfo` for default :class:`UrlDispatcher` router). .. class:: UrlMappingMatchInfo Inherited from :class:`dict` and :class:`AbstractMatchInfo`. Dict items are filled by matching info and is :term:`resource`\-specific. .. attribute:: expect_handler A coroutine for handling ``100-continue``. .. attribute:: handler A coroutine for handling request. .. attribute:: route :class:`Route` instance for url matching. View ^^^^ .. class:: View(request) Inherited from :class:`AbstractView`. Base class for class based views. Implementations should derive from :class:`View` and override methods for handling HTTP verbs like ``get()`` or ``post()``:: class MyView(View): async def get(self): resp = await get_response(self.request) return resp async def post(self): resp = await post_response(self.request) return resp app.router.add_route('*', '/view', MyView) The view raises *405 Method Not allowed* (:class:`HTTPMethodNowAllowed`) if requested web verb is not supported. :param request: instance of :class:`Request` that has initiated a view processing. .. attribute:: request Request sent to view's constructor, read-only property. Overridable coroutine methods: ``connect()``, ``delete()``, ``get()``, ``head()``, ``options()``, ``patch()``, ``post()``, ``put()``, ``trace()``. .. seealso:: :ref:`aiohttp-web-class-based-views` Utilities --------- .. class:: FileField A :class:`~collections.namedtuple` instance that is returned as multidict value by :meth:`Request.POST` if field is uploaded file. .. attribute:: name Field name .. attribute:: filename File name as specified by uploading (client) side. .. attribute:: file An :class:`io.IOBase` instance with content of uploaded file. .. attribute:: content_type *MIME type* of uploaded file, ``'text/plain'`` by default. .. seealso:: :ref:`aiohttp-web-file-upload` .. function:: run_app(app, *, host='0.0.0.0', port=None, loop=None, \ shutdown_timeout=60.0, ssl_context=None, \ print=print, backlog=128, \ access_log_format=None, \ access_log=aiohttp.log.access_logger) A utility function for running an application, serving it until keyboard interrupt and performing a :ref:`aiohttp-web-graceful-shutdown`. Suitable as handy tool for scaffolding aiohttp based projects. Perhaps production config will use more sophisticated runner but it good enough at least at very beginning stage. The function uses *app.loop* as event loop to run. :param app: :class:`Application` instance to run :param str host: host for HTTP server, ``'0.0.0.0'`` by default :param int port: port for HTTP server. By default is ``8080`` for plain text HTTP and ``8443`` for HTTP via SSL (when *ssl_context* parameter is specified). :param int shutdown_timeout: a delay to wait for graceful server shutdown before disconnecting all open client sockets hard way. A system with properly :ref:`aiohttp-web-graceful-shutdown` implemented never waits for this timeout but closes a server in a few milliseconds. :param ssl_context: :class:`ssl.SSLContext` for HTTPS server, ``None`` for HTTP connection. :param print: a callable compatible with :func:`print`. May be used to override STDOUT output or suppress it. :param int backlog: the number of unaccepted connections that the system will allow before refusing new connections (``128`` by default). :param access_log: :class:`logging.Logger` instance used for saving access logs. Use ``None`` for disabling logs for sake of speedup. :param access_log_format: access log format, see :ref:`aiohttp-logging-access-log-format-spec` for details. Constants --------- .. class:: ContentCoding An :class:`enum.Enum` class of available Content Codings. .. attribute:: deflate *DEFLATE compression* .. attribute:: gzip *GZIP compression* .. attribute:: identity *no compression* .. disqus:: :title: aiohttp server reference aiohttp-1.2.0/docs/multipart.rst0000664000175000017500000002565413025134363017545 0ustar travistravis00000000000000.. module:: aiohttp.multipart .. _aiohttp-multipart: Working with Multipart ====================== ``aiohttp`` supports a full featured multipart reader and writer. Both are designed with steaming processing in mind to avoid unwanted footprint which may be significant if you're dealing with large payloads, but this also means that most I/O operation are only possible to be executed a single time. Reading Multipart Responses --------------------------- Assume you made a request, as usual, and want to process the response multipart data:: async with aiohttp.request(...) as resp: pass First, you need to wrap the response with a :meth:`MultipartReader.from_response`. This needs to keep the implementation of :class:`MultipartReader` separated from the response and the connection routines which makes it more portable:: reader = aiohttp.MultipartReader.from_response(resp) Let's assume with this response you'd received some JSON document and multiple files for it, but you don't need all of them, just a specific one. So first you need to enter into a loop where the multipart body will be processed:: metadata = None filedata = None while True: part = await reader.next() The returned type depends on what the next part is: if it's a simple body part then you'll get :class:`BodyPartReader` instance here, otherwise, it will be another :class:`MultipartReader` instance for the nested multipart. Remember, that multipart format is recursive and supports multiple levels of nested body parts. When there are no more parts left to fetch, ``None`` value will be returned - that's the signal to break the loop:: if part is None: break Both :class:`BodyPartReader` and :class:`MultipartReader` provides access to body part headers: this allows you to filter parts by their attributes:: if part.headers[aiohttp.hdrs.CONTENT_TYPE] == 'application/json': metadata = await part.json() continue Nor :class:`BodyPartReader` or :class:`MultipartReader` instances doesn't read the whole body part data without explicitly asking for. :class:`BodyPartReader` provides a set of helpers methods to fetch popular content types in friendly way: - :meth:`BodyPartReader.text` for plain text data; - :meth:`BodyPartReader.json` for JSON; - :meth:`BodyPartReader.form` for `application/www-urlform-encode` Each of these methods automatically recognizes if content is compressed by using `gzip` and `deflate` encoding (while it respects `identity` one), or if transfer encoding is base64 or `quoted-printable` - in each case the result will get automatically decoded. But in case you need to access to raw binary data as it is, there are :meth:`BodyPartReader.read` and :meth:`BodyPartReader.read_chunk` coroutine methods as well to read raw binary data as it is all-in-single-shot or by chunks respectively. When you have to deal with multipart files, the :attr:`BodyPartReader.filename` property comes to help. It's a very smart helper which handles `Content-Disposition` handler right and extracts the right filename attribute from it:: if part.filename != 'secret.txt': continue If current body part doesn't matches your expectation and you want to skip it - just continue a loop to start a next iteration of it. Here is where magic happens. Before fetching the next body part ``await reader.next()`` it ensures that the previous one was read completely. If it wasn't, all its content sends to the void in term to fetch the next part. So you don't have to care about cleanup routines while you're within a loop. Once you'd found a part for the file you'd searched for, just read it. Let's handle it as it is without applying any decoding magic:: filedata = await part.read(decode=False) Later you may decide to decode the data. It's still simple and possible to do:: filedata = part.decode(filedata) Once you are done with multipart processing, just break a loop:: break Sending Multipart Requests -------------------------- :class:`MultipartWriter` provides an interface to build multipart payload from the Python data and serialize it into chunked binary stream. Since multipart format is recursive and supports deeply nesting, you can use ``with`` statement to design your multipart data closer to how it will be:: with aiohttp.MultipartWriter('mixed') as mpwriter: ... with aiohttp.MultipartWriter('related') as subwriter: ... mpwriter.append(subwriter) with aiohttp.MultipartWriter('related') as subwriter: ... with aiohttp.MultipartWriter('related') as subsubwriter: ... subwriter.append(subsubwriter) mpwriter.append(subwriter) with aiohttp.MultipartWriter('related') as subwriter: ... mpwriter.append(subwriter) The :meth:`MultipartWriter.append` is used to join new body parts into a single stream. It accepts various inputs and determines what default headers should be used for. For text data default `Content-Type` is :mimetype:`text/plain; charset=utf-8`:: mpwriter.append('hello') For binary data :mimetype:`application/octet-stream` is used:: mpwriter.append(b'aiohttp') You can always override these default by passing your own headers with the second argument:: mpwriter.append(io.BytesIO(b'GIF89a...'), {'CONTENT-TYPE': 'image/gif'}) For file objects `Content-Type` will be determined by using Python's `mimetypes`_ module and additionally `Content-Disposition` header will include the file's basename:: part = root.append(open(__file__, 'rb')) If you want to send a file with a different name, just handle the :class:`BodyPartWriter` instance which :meth:`MultipartWriter.append` will always return and set `Content-Disposition` explicitly by using the :meth:`BodyPartWriter.set_content_disposition` helper:: part.set_content_disposition('attachment', filename='secret.txt') Additionally, you may want to set other headers here:: part.headers[aiohttp.hdrs.CONTENT_ID] = 'X-12345' If you'd set `Content-Encoding`, it will be automatically applied to the data on serialization (see below):: part.headers[aiohttp.hdrs.CONTENT_ENCODING] = 'gzip' There are also :meth:`MultipartWriter.append_json` and :meth:`MultipartWriter.append_form` helpers which are useful to work with JSON and form urlencoded data, so you don't have to encode it every time manually:: mpwriter.append_json({'test': 'passed'}) mpwriter.append_form([('key', 'value')]) When it's done, to make a request just pass a root :class:`MultipartWriter` instance as :func:`aiohttp.client.request` `data` argument:: await aiohttp.post('http://example.com', data=mpwriter) Behind the scenes :meth:`MultipartWriter.serialize` will yield chunks of every part and if body part has `Content-Encoding` or `Content-Transfer-Encoding` they will be applied on streaming content. Please note, that on :meth:`MultipartWriter.serialize` all the file objects will be read until the end and there is no way to repeat a request without rewinding their pointers to the start. Hacking Multipart ----------------- The Internet is full of terror and sometimes you may find a server which implements multipart support in strange ways when an oblivious solution doesn't work. For instance, is server used `cgi.FieldStorage`_ then you have to ensure that no body part contains a `Content-Length` header:: for part in mpwriter: part.headers.pop(aiohttp.hdrs.CONTENT_LENGTH, None) On the other hand, some server may require to specify `Content-Length` for the whole multipart request. `aiohttp` doesn't do that since it sends multipart using chunked transfer encoding by default. To overcome this issue, you have to serialize a :class:`MultipartWriter` by our own in the way to calculate its size:: body = b''.join(mpwriter.serialize()) await aiohttp.post('http://example.com', data=body, headers=mpwriter.headers) Sometimes the server response may not be well formed: it may or may not contains nested parts. For instance, we request a resource which returns JSON documents with the files attached to it. If the document has any attachments, they are returned as a nested multipart. If it has not it responds as plain body parts: .. code-block:: none CONTENT-TYPE: multipart/mixed; boundary=--: --: CONTENT-TYPE: application/json {"_id": "foo"} --: CONTENT-TYPE: multipart/related; boundary=----: ----: CONTENT-TYPE: application/json {"_id": "bar"} ----: CONTENT-TYPE: text/plain CONTENT-DISPOSITION: attachment; filename=bar.txt bar! bar! bar! ----:-- --: CONTENT-TYPE: application/json {"_id": "boo"} --: CONTENT-TYPE: multipart/related; boundary=----: ----: CONTENT-TYPE: application/json {"_id": "baz"} ----: CONTENT-TYPE: text/plain CONTENT-DISPOSITION: attachment; filename=baz.txt baz! baz! baz! ----:-- --:-- Reading such kind of data in single stream is possible, but is not clean at all:: result = [] while True: part = await reader.next() if part is None: break if isinstance(part, aiohttp.MultipartReader): # Fetching files while True: filepart = await part.next() if filepart is None: break result[-1].append((await filepart.read())) else: # Fetching document result.append([(await part.json())]) Let's hack a reader in the way to return pairs of document and reader of the related files on each iteration:: class PairsMultipartReader(aiohttp.MultipartReader): # keep reference on the original reader multipart_reader_cls = aiohttp.MultipartReader async def next(self): """Emits a tuple of document object (:class:`dict`) and multipart reader of the followed attachments (if any). :rtype: tuple """ reader = await super().next() if self._at_eof: return None, None if isinstance(reader, self.multipart_reader_cls): part = await reader.next() doc = await part.json() else: doc = await reader.json() return doc, reader And this gives us a more cleaner solution:: reader = PairsMultipartReader.from_response(resp) result = [] while True: doc, files_reader = await reader.next() if doc is None: break files = [] while True: filepart = await files_reader.next() if file.part is None: break files.append((await filepart.read())) result.append((doc, files)) .. seealso:: Multipart API in :ref:`aiohttp-api` section. .. _cgi.FieldStorage: https://docs.python.org/3.4/library/cgi.html .. _mimetypes: https://docs.python.org/3.4/library/mimetypes.html .. disqus:: :title: aiohttp suppport for multipart encoding aiohttp-1.2.0/docs/third_party.rst0000664000175000017500000000471413025134363020047 0ustar travistravis00000000000000Third-Party libraries ===================== aiohttp is not the library for making HTTP requests and creating WEB server only. It is the grand basement for libraries built *on top* of aiohttp. This page is a list of these tools. Please feel free to add your open sourced library if it's not enlisted yet by making Pull Request to https://github.com/KeepSafe/aiohttp/ - Q. Why do you might want to include your awesome library into the list? - A. Just because the list increases your library visibility. People will have an easy way to find it. Officially supported -------------------- This list contains libraries which are supported by *aio-libs* team and located on https://github.com/aio-libs aiohttp extensions ^^^^^^^^^^^^^^^^^^ - `aiohttp-session `_ provides sessions for :mod:`aiohttp.web`. - `aiohttp-debugtoolbar `_ is a library for *debug toolbar* support for :mod:`aiohttp.web`. - `aiohttp-security `_ auth and permissions for :mod:`aiohttp.web`. Database drivers ^^^^^^^^^^^^^^^^ - `aiopg `_ PostgreSQL async driver. - `aiomysql `_ MySql async driver. - `aioredis `_ Redis async driver. Approved third-party libraries ------------------------------ The libraries are not part of ``aio-libs`` but they are proven to be very well written and highly recommended for usage. - `uvloop `_ Ultra fast implementation of asyncio event loop on top of ``libuv``. We are highly recommending to use it instead of standard ``asyncio``. Database drivers ^^^^^^^^^^^^^^^^ - `asyncpg `_ Another PostgreSQL async driver. It's much faster than ``aiopg`` but it is not drop-in replacement -- the API is different. Anyway please take a look on it -- the driver is really incredible fast. Others ------ The list of libs which are exists but not enlisted in former categories. They are may be perfect or not -- we don't know. Please add your library reference here first and after some time period ask to raise he status. - `aiohttp-cache `_ A cache system for aiohttp server. - `aiocache `_ Caching for asyncio with multiple backends (framework agnostic) aiohttp-1.2.0/docs/testing.rst0000664000175000017500000005454513025134363017202 0ustar travistravis00000000000000.. _aiohttp-testing: Testing ======= .. currentmodule:: aiohttp.test_utils Testing aiohttp web servers --------------------------- aiohttp provides plugin for pytest_ making writing web server tests extremely easy, it also provides :ref:`test framework agnostic utilities ` for testing with other frameworks such as :ref:`unittest `. Before starting to write your tests, you may also be interested on reading :ref:`how to write testable services` that interact with the loop. For using pytest plugin please install pytest-aiohttp_ library: .. code-block:: shell $ pip install pytest-aiohttp If you don't want to install *pytest-aiohttp* for some reason you may insert ``pytest_plugins = 'aiohttp.pytest_plugin'`` line into ``conftest.py`` instead for the same functionality. Provisional Status ~~~~~~~~~~~~~~~~~~ The module is a **provisional**. *aiohttp* has a year and half period for removing deprecated API (:ref:`aiohttp-backward-compatibility-policy`). But for :mod:`aiohttp.test_tools` the deprecation period could be reduced. Moreover we may break *backward compatibility* without *deprecation peroid* for some very strong reason. The Test Client and Servers ~~~~~~~~~~~~~~~~~~~~~~~~~~~ *aiohttp* test utils provides a scaffolding for testing aiohttp-based web servers. They are consist of two parts: running test server and making HTTP requests to this server. :class:`~aiohttp.test_utils.TestServer` runs :class:`aiohttp.web.Application` based server, :class:`~aiohttp.test_utils.RawTestServer` starts :class:`aiohttp.web.WebServer` low level server. For performing HTTP requests to these servers you have to create a test client: :class:`~aiohttp.test_utils.TestClient` instance. The client incapsulates :class:`aiohttp.ClientSession` by providing proxy methods to the client for common operations such as *ws_connect*, *get*, *post*, etc. Pytest ~~~~~~ The :data:`test_client` fixture available from pytest-aiohttp_ plugin allows you to create a client to make requests to test your app. A simple would be:: from aiohttp import web async def hello(request): return web.Response(text='Hello, world') async def test_hello(test_client, loop): app = web.Application(loop=loop) app.router.add_get('/', hello) client = await test_client(app) resp = await client.get('/') assert resp.status == 200 text = await resp.text() assert 'Hello, world' in text It also provides access to the app instance allowing tests to check the state of the app. Tests can be made even more succinct with a fixture to create an app test client:: import pytest from aiohttp import web async def previous(request): if request.method == 'POST': request.app['value'] = (await request.post())['value'] return web.Response(body=b'thanks for the data') return web.Response( body='value: {}'.format(request.app['value']).encode('utf-8')) @pytest.fixture def cli(loop, test_client): app = web.Application(loop=loop) app.router.add_get('/', hello) return loop.run_until_complete(test_client(app)) async def test_set_value(cli): resp = await cli.post('/', data={'value': 'foo'}) assert resp.status == 200 assert await resp.text() == 'thanks for the data' assert cli.app['value'] == 'foo' async def test_get_value(cli): cli.app['value'] = 'bar' resp = await cli.get('/') assert resp.status == 200 assert await resp.text() == 'value: bar' Pytest tooling has the following fixtures: .. data:: test_server(app, **kwargs) A fixture factory that creates :class:`~aiohttp.test_utils.TestServer`:: async def test_f(loop, test_server): app = web.Application(loop=loop) # fill route table server = await test_server(app) The server will be destroyed on exit from test function. *app* is the :class:`aiohttp.web.Application` used to start server. *kwargs* are parameters passed to :meth:`aiohttp.web.Application.make_handler` .. data:: test_client(app, **kwargs) test_client(server, **kwargs) test_client(raw_server, **kwargs) A fixture factory that creates :class:`~aiohttp.test_utils.TestClient` for access to tested server:: async def test_f(loop, test_client): app = web.Application(loop=loop) # fill route table client = await test_client(app) resp = await client.get('/') *client* and responses are cleaned up after test function finishing. The fixture accepts :class:`aiohttp.web.Application`, :class:`aiohttp.test_utils.TestServer` or :class:`aiohttp.test_utils.RawTestServer` instance. *kwargs* are parameters passed to :class:`aiohttp.test_utils.TestClient` constructor. .. data:: raw_test_server(handler, **kwargs) A fixture factory that creates :class:`~aiohttp.test_utils.RawTestServer` instance from given web handler. *handler* should be a coroutine which accepts a request and returns response, e.g.:: async def test_f(raw_test_server, test_client): async def handler(request): return web.Response(text="OK") raw_server = await raw_test_server(handler) client = await test_client(raw_server) resp = await client.get('/') .. _aiohttp-testing-unittest-example: .. _aiohttp-testing-unittest-style: Unittest ~~~~~~~~ To test applications with the standard library's unittest or unittest-based functionality, the AioHTTPTestCase is provided:: from aiohttp.test_utils import AioHTTPTestCase, unittest_run_loop from aiohttp import web class MyAppTestCase(AioHTTPTestCase): def get_app(self, loop): """Override the get_app method to return your application. """ # it's important to use the loop passed here. return web.Application(loop=loop) # the unittest_run_loop decorator can be used in tandem with # the AioHTTPTestCase to simplify running # tests that are asynchronous @unittest_run_loop async def test_example(self): request = await self.client.request("GET", "/") assert request.status == 200 text = await request.text() assert "Hello, world" in text # a vanilla example def test_example(self): async def test_get_route(): url = root + "/" resp = await self.client.request("GET", url, loop=loop) assert resp.status == 200 text = await resp.text() assert "Hello, world" in text self.loop.run_until_complete(test_get_route()) .. class:: AioHTTPTestCase A base class to allow for unittest web applications using aiohttp. Derived from :class:`unittest.TestCase` Provides the following: .. attribute:: client an aiohttp test client, :class:`TestClient` instance. .. attribute:: loop The event loop in which the application and server are running. .. attribute:: app The application returned by :meth:`get_app` (:class:`aiohttp.web.Application` instance). .. method:: get_app(loop) This method should be overridden to return the :class:`aiohttp.web.Application` object to test. :param loop: the event_loop to use :type loop: asyncio.AbstractEventLoop :return: :class:`aiohttp.web.Application` instance. .. method:: setUp() Standard test initialization method. .. method:: tearDown() Standard test finalization method. .. note:: The ``TestClient``'s methods are asynchronous: you have to execute function on the test client using asynchronous methods. A basic test class wraps every test method by :func:`unittest_run_loop` decorator:: class TestA(AioHTTPTestCase): @unittest_run_loop async def test_f(self): resp = await self.client.get('/') .. decorator:: unittest_run_loop: A decorator dedicated to use with asynchronous methods of an :class:`AioHTTPTestCase`. Handles executing an asynchronous function, using the :attr:`AioHTTPTestCase.loop` of the :class:`AioHTTPTestCase`. Faking request object --------------------- aiohttp provides test utility for creating fake :class:`aiohttp.web.Request` objects: :func:`aiohttp.test_utils.make_mocked_request`, it could be useful in case of simple unit tests, like handler tests, or simulate error conditions that hard to reproduce on real server:: from aiohttp import web from aiohttp.test_utils import make_mocked_request def handler(request): assert request.headers.get('token') == 'x' return web.Response(body=b'data') def test_handler(): req = make_mocked_request('GET', '/', headers={'token': 'x'}) resp = handler(req) assert resp.body == b'data' .. warning:: We don't recommend to apply :func:`~aiohttp.test_utils.make_mocked_request` everywhere for testing web-handler's business object -- please use test client and real networking via 'localhost' as shown in examples before. :func:`~aiohttp.test_utils.make_mocked_request` exists only for testing complex cases (e.g. emulating network errors) which are extremely hard or even impossible to test by conventional way. .. function:: make_mocked_request(method, path, headers=None, *, \ version=HttpVersion(1, 1), \ closing=False, \ app=None, \ reader=sentinel, \ writer=sentinel, \ transport=sentinel, \ payload=sentinel, \ sslcontext=None, \ secure_proxy_ssl_header=None) Creates mocked web.Request testing purposes. Useful in unit tests, when spinning full web server is overkill or specific conditions and errors are hard to trigger. :param method: str, that represents HTTP method, like; GET, POST. :type method: str :param path: str, The URL including *PATH INFO* without the host or scheme :type path: str :param headers: mapping containing the headers. Can be anything accepted by the multidict.CIMultiDict constructor. :type headers: dict, multidict.CIMultiDict, list of pairs :param version: namedtuple with encoded HTTP version :type version: aiohttp.protocol.HttpVersion :param closing: flag indicates that connection should be closed after response. :type closing: bool :param app: the aiohttp.web application attached for fake request :type app: aiohttp.web.Application :param reader: object for storing and managing incoming data :type reader: aiohttp.parsers.StreamParser :param writer: object for managing outcoming data :type wirter: aiohttp.parsers.StreamWriter :param transport: asyncio transport instance :type transport: asyncio.transports.Transport :param payload: raw payload reader object :type payload: aiohttp.streams.FlowControlStreamReader :param sslcontext: ssl.SSLContext object, for HTTPS connection :type sslcontext: ssl.SSLContext :param secure_proxy_ssl_header: A tuple representing a HTTP header/value combination that signifies a request is secure. :type secure_proxy_ssl_header: tuple :return: :class:`aiohttp.web.Request` object. .. _aiohttp-testing-writing-testable-services: .. _aiohttp-testing-framework-agnostic-utilities: Framework Agnostic Utilities ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ High level test creation:: from aiohttp.test_utils import TestClient, loop_context from aiohttp import request # loop_context is provided as a utility. You can use any # asyncio.BaseEventLoop class in it's place. with loop_context() as loop: app = _create_example_app(loop) with TestClient(app) as client: async def test_get_route(): nonlocal client resp = await client.get("/") assert resp.status == 200 text = await resp.text() assert "Hello, world" in text loop.run_until_complete(test_get_route()) If it's preferred to handle the creation / teardown on a more granular basis, the TestClient object can be used directly:: from aiohttp.test_utils import TestClient with loop_context() as loop: app = _create_example_app(loop) client = TestClient(app) loop.run_until_complete(client.start_server()) root = "http://127.0.0.1:{}".format(port) async def test_get_route(): resp = await client.get("/") assert resp.status == 200 text = await resp.text() assert "Hello, world" in text loop.run_until_complete(test_get_route()) loop.run_until_complete(client.close()) A full list of the utilities provided can be found at the :data:`api reference ` Writing testable services ------------------------- Some libraries like motor, aioes and others depend on the asyncio loop for executing the code. When running your normal program, these libraries pick the main event loop by doing ``asyncio.get_event_loop``. The problem during testing is that there is no main loop assigned because an independent loop for each test is created without assigning it as the main one. This raises a problem when those libraries try to find it. Luckily, the ones that are well written, allow passing the loop explicitly. Let's have a look at the aioes client signature:: def __init__(self, endpoints, *, loop=None, **kwargs) As you can see, there is an optional ``loop`` kwarg. Of course, we are not going to test directly the aioes client but our service that depends on it will. So, if we want our ``AioESService`` to be easily testable, we should define it as follows:: import asyncio from aioes import Elasticsearch class AioESService: def __init__(self, loop=None): self.es = Elasticsearch(["127.0.0.1:9200"], loop=loop) async def get_info(self): cluster_info = await self.es.info() print(cluster_info) if __name__ == "__main__": client = AioESService() loop = asyncio.get_event_loop() loop.run_until_complete(client.get_info()) Note that it is accepting an optional ``loop`` kwarg. For the normal flow of execution it won't affect because we can still call the service without passing the loop explicitly having a main loop available. The problem comes when you try to do a test like:: import pytest from main import AioESService class TestAioESService: async def test_get_info(self): cluster_info = await AioESService().get_info() assert isinstance(cluster_info, dict) If you try to run the test, it will fail with a similar error:: ... RuntimeError: There is no current event loop in thread 'MainThread'. If you check the stack trace, you will see aioes is complaining that there is no current event loop in the main thread. Pass explicit loop to solve it. If you rely on code which works with *implicit* loops only you may try to use hackish approach from :ref:`FAQ `. Testing API Reference --------------------- Test server ~~~~~~~~~~~ Runs given :class:`aiohttp.web.Application` instance on random TCP port. After creation the server is not started yet, use :meth:`~aiohttp.test_utils.TestServer.start_server` for actual server starting and :meth:`~aiohttp.test_utils.TestServer.close` for stopping/cleanup. Test server usually works in conjunction with :class:`aiohttp.test_utils.TestClient` which provides handy client methods for accessing to the server. .. class:: BaseTestServer(*, scheme='http', host='127.0.0.1') Base class for test servers. :param str scheme: HTTP scheme, non-protected ``"http"`` by default. :param str host: a host for TCP socket, IPv4 *local host* (``'127.0.0.1'``) by default. .. attribute:: scheme A *scheme* for tested application, ``'http'`` for non-protected run and ``'htttps'`` for TLS encrypted server. .. attribute:: host *host* used to start a test server. .. attribute:: port A random *port* used to start a server. .. attribute:: handler :class:`aiohttp.web.WebServer` used for HTTP requests serving. .. attribute:: server :class:`asyncio.AbstractServer` used for managing accepted connections. .. comethod:: start_server(**kwargs) Start a test server. .. comethod:: close() Stop and finish executed test server. .. method:: make_url(path) Return an *absolute* :class:`~yarl.URL` for given *path*. .. class:: RawTestServer(handler, *, \ loop=None, scheme="http", host='127.0.0.1') Low-level test server (derived from :class:`BaseTestServer`). :param handler: a coroutine for handling web requests. The handler should accept :class:`aiohttp.web.BaseRequest` and return a response instance, e.g. :class:`~aiohttp.web.StreamResponse` or :class:`~aiohttp.web.Response`. The handler could raise :class:`~aiohttp.web.HTTPException` as a signal for non-200 HTTP response. :param str scheme: HTTP scheme, non-protected ``"http"`` by default. :param str host: a host for TCP socket, IPv4 *local host* (``'127.0.0.1'``) by default. .. class:: TestServer(app, *, scheme="http", host='127.0.0.1') Test server (derived from :class:`BaseTestServer`) for starting :class:`~aiohttp.web.Application`. :param app: :class:`aiohttp.web.Application` instance to run. :param str scheme: HTTP scheme, non-protected ``"http"`` by default. :param str host: a host for TCP socket, IPv4 *local host* (``'127.0.0.1'``) by default. .. attribute:: app :class:`aiohttp.web.Application` instance to run. Test Client ~~~~~~~~~~~ .. class:: TestClient(app_or_server, *, \ scheme='http', host='127.0.0.1', \ cookie_jar=None, **kwargs) A test client used for making calls to tested server. :param app_or_server: :class:`BaseTestServer` instance for making client requests to it. If the parameter is :class:`aiohttp.web.Application` the tool creates :class:`TestServer` implicitly for serving the application. :param cookie_jar: an optional :class:`aiohttp.CookieJar` instance, may be useful with ``CookieJar(unsafe=True)`` option. :param str scheme: HTTP scheme, non-protected ``"http"`` by default. :param str host: a host for TCP socket, IPv4 *local host* (``'127.0.0.1'``) by default. .. attribute:: scheme A *scheme* for tested application, ``'http'`` for non-protected run and ``'htttps'`` for TLS encrypted server. .. attribute:: host *host* used to start a test server. .. attribute:: port A random *port* used to start a server. .. attribute:: server :class:`BaseTestServer` test server instance used in conjunction with client. .. attribute:: session An internal :class:`aiohttp.ClientSession`. Unlike the methods on the :class:`TestClient`, client session requests do not automatically include the host in the url queried, and will require an absolute path to the resource. .. comethod:: start_server(**kwargs) Start a test server. .. comethod:: close() Stop and finish executed test server. .. method:: make_url(path) Return an *absolute* :class:`~yarl.URL` for given *path*. .. comethod:: request(method, path, *args, **kwargs) Routes a request to tested http server. The interface is identical to :meth:`asyncio.ClientSession.request`, except the loop kwarg is overridden by the instance used by the test server. .. comethod:: get(path, *args, **kwargs) Perform an HTTP GET request. .. comethod:: post(path, *args, **kwargs) Perform an HTTP POST request. .. comethod:: options(path, *args, **kwargs) Perform an HTTP OPTIONS request. .. comethod:: head(path, *args, **kwargs) Perform an HTTP HEAD request. .. comethod:: put(path, *args, **kwargs) Perform an HTTP PUT request. .. comethod:: patch(path, *args, **kwargs) Perform an HTTP PATCH request. .. comethod:: delete(path, *args, **kwargs) Perform an HTTP DELETE request. .. comethod:: delete(path, *args, **kwargs) Initiate websocket connection. The api corresponds to :meth:`aiohttp.ClientSession.ws_connect`. Utilities ~~~~~~~~~ .. function:: make_mocked_coro(return_value) Creates a coroutine mock. Behaves like a coroutine which returns *return_value*. But it is also a mock object, you might test it as usual :class:`~unittest.mock.Mock`:: mocked = make_mocked_coro(1) assert 1 == await mocked(1, 2) mocked.assert_called_with(1, 2) :param return_value: A value that the the mock object will return when called. :returns: A mock object that behaves as a coroutine which returns *return_value* when called. .. function:: unused_port() Return an unused port number for IPv4 TCP protocol. :return int: ephemeral port number which could be reused by test server. .. function:: loop_context(loop_factory=) A contextmanager that creates an event_loop, for test purposes. Handles the creation and cleanup of a test loop. .. function:: setup_test_loop(loop_factory=) Create and return an :class:`asyncio.AbstractEventLoop` instance. The caller should also call teardown_test_loop, once they are done with the loop. .. function:: teardown_test_loop(loop) Teardown and cleanup an event_loop created by setup_test_loop. :param loop: the loop to teardown :type loop: asyncio.AbstractEventLoop .. _pytest: http://pytest.org/latest/ .. _pytest-aiohttp: https://pypi.python.org/pypi/pytest-aiohttp .. disqus:: :title: aiohttp testing aiohttp-1.2.0/docs/client.rst0000664000175000017500000005217013025134363016773 0ustar travistravis00000000000000.. _aiohttp-client: Client ====== .. module:: aiohttp .. currentmodule:: aiohttp Make a Request -------------- Begin by importing the aiohttp module:: import aiohttp Now, let's try to get a web-page. For example let's get GitHub's public time-line:: async with aiohttp.ClientSession() as session: async with session.get('https://api.github.com/events') as resp: print(resp.status) print(await resp.text()) Now, we have a :class:`ClientSession` called ``session`` and a :class:`ClientResponse` object called ``resp``. We can get all the information we need from the response. The mandatory parameter of :meth:`ClientSession.get` coroutine is an HTTP url. In order to make an HTTP POST request use :meth:`ClientSession.post` coroutine:: session.post('http://httpbin.org/post', data=b'data') Other HTTP methods are available as well:: session.put('http://httpbin.org/put', data=b'data') session.delete('http://httpbin.org/delete') session.head('http://httpbin.org/get') session.options('http://httpbin.org/get') session.patch('http://httpbin.org/patch', data=b'data') .. note:: Don't create a session per request. Most likely you need a session per application which performs all requests altogether. A session contains a connection pool inside, connection reusage and keep-alives (both are on by default) may speed up total performance. Passing Parameters In URLs -------------------------- You often want to send some sort of data in the URL's query string. If you were constructing the URL by hand, this data would be given as key/value pairs in the URL after a question mark, e.g. ``httpbin.org/get?key=val``. Requests allows you to provide these arguments as a :class:`dict`, using the ``params`` keyword argument. As an example, if you wanted to pass ``key1=value1`` and ``key2=value2`` to ``httpbin.org/get``, you would use the following code:: params = {'key1': 'value1', 'key2': 'value2'} async with session.get('http://httpbin.org/get', params=params) as resp: assert resp.url == 'http://httpbin.org/get?key2=value2&key1=value1' You can see that the URL has been correctly encoded by printing the URL. For sending data with multiple values for the same key :class:`MultiDict` may be used as well. It is also possible to pass a list of 2 item tuples as parameters, in that case you can specify multiple values for each key:: params = [('key', 'value1'), ('key', 'value2')] async with session.get('http://httpbin.org/get', params=params) as r: assert r.url == 'http://httpbin.org/get?key=value2&key=value1' You can also pass :class:`str` content as param, but beware -- content is not encoded by library. Note that ``+`` is not encoded:: async with session.get('http://httpbin.org/get', params='key=value+1') as r: assert r.url == 'http://httpbin.org/get?key=value+1' Response Content ---------------- We can read the content of the server's response. Consider the GitHub time-line again:: async with session.get('https://api.github.com/events') as resp: print(await resp.text()) will printout something like:: '[{"created_at":"2015-06-12T14:06:22Z","public":true,"actor":{... ``aiohttp`` will automatically decode the content from the server. You can specify custom encoding for the :meth:`~ClientResponse.text` method:: await resp.text(encoding='windows-1251') Binary Response Content ----------------------- You can also access the response body as bytes, for non-text requests:: print(await resp.read()) :: b'[{"created_at":"2015-06-12T14:06:22Z","public":true,"actor":{... The ``gzip`` and ``deflate`` transfer-encodings are automatically decoded for you. JSON Response Content --------------------- There's also a built-in JSON decoder, in case you're dealing with JSON data:: async with session.get('https://api.github.com/events') as resp: print(await resp.json()) In case that JSON decoding fails, :meth:`~ClientResponse.json` will raise an exception. It is possible to specify custom encoding and decoder functions for the :meth:`~ClientResponse.json` call. Streaming Response Content -------------------------- While methods :meth:`~ClientResponse.read`, :meth:`~ClientResponse.json` and :meth:`~ClientResponse.text` are very convenient you should use them carefully. All these methods load the whole response in memory. For example if you want to download several gigabyte sized files, these methods will load all the data in memory. Instead you can use the :attr:`~ClientResponse.content` attribute. It is an instance of the :class:`aiohttp.StreamReader` class. The ``gzip`` and ``deflate`` transfer-encodings are automatically decoded for you:: async with session.get('https://api.github.com/events') as resp: await resp.content.read(10) In general, however, you should use a pattern like this to save what is being streamed to a file:: with open(filename, 'wb') as fd: while True: chunk = await resp.content.read(chunk_size) if not chunk: break fd.write(chunk) It is not possible to use :meth:`~ClientResponse.read`, :meth:`~ClientResponse.json` and :meth:`~ClientResponse.text` after explicit reading from :attr:`~ClientResponse.content`. Releasing Response ------------------ Don't forget to release response after use. This will ensure explicit behavior and proper connection pooling. The easiest way to release response correctly is ``async with`` statement:: async with session.get(url) as resp: pass But explicit :meth:`~ClientResponse.release` call also may be used:: await resp.release() However it's not necessary if you use :meth:`~ClientResponse.read`, :meth:`~ClientResponse.json` and :meth:`~ClientResponse.text` methods. They do release connection internally but better don't rely on that behavior. Custom Headers -------------- If you need to add HTTP headers to a request, pass them in a :class:`dict` to the *headers* parameter. For example, if you want to specify the content-type for the previous example:: import json url = 'https://api.github.com/some/endpoint' payload = {'some': 'data'} headers = {'content-type': 'application/json'} await session.post(url, data=json.dumps(payload), headers=headers) Custom Cookies -------------- To send your own cookies to the server, you can use the *cookies* parameter of :class:`ClientSession` constructor:: url = 'http://httpbin.org/cookies' cookies = {'cookies_are': 'working'} async with ClientSession(cookies=cookies) as session: async with session.get(url) as resp: assert await resp.json() == { "cookies": {"cookies_are": "working"}} .. note:: ``httpbin.org/cookies`` endpoint returns request cookies in JSON-encoded body. To access session cookies see :attr:`ClientSession.cookie_jar`. More complicated POST requests ------------------------------ Typically, you want to send some form-encoded data -- much like an HTML form. To do this, simply pass a dictionary to the *data* argument. Your dictionary of data will automatically be form-encoded when the request is made:: payload = {'key1': 'value1', 'key2': 'value2'} async with session.post('http://httpbin.org/post', data=payload) as resp: print(await resp.text()) :: { ... "form": { "key2": "value2", "key1": "value1" }, ... } If you want to send data that is not form-encoded you can do it by passing a :class:`str` instead of a :class:`dict`. This data will be posted directly. For example, the GitHub API v3 accepts JSON-Encoded POST/PATCH data:: import json url = 'https://api.github.com/some/endpoint' payload = {'some': 'data'} async with session.post(url, data=json.dumps(payload)) as resp: ... POST a Multipart-Encoded File ----------------------------- To upload Multipart-encoded files:: url = 'http://httpbin.org/post' files = {'file': open('report.xls', 'rb')} await session.post(url, data=files) You can set the filename, content_type explicitly:: url = 'http://httpbin.org/post' data = FormData() data.add_field('file', open('report.xls', 'rb'), filename='report.xls', content_type='application/vnd.ms-excel') await session.post(url, data=data) If you pass a file object as data parameter, aiohttp will stream it to the server automatically. Check :class:`~aiohttp.streams.StreamReader` for supported format information. .. seealso:: :ref:`aiohttp-multipart` Streaming uploads ----------------- :mod:`aiohttp` supports multiple types of streaming uploads, which allows you to send large files without reading them into memory. As a simple case, simply provide a file-like object for your body:: with open('massive-body', 'rb') as f: await session.post('http://some.url/streamed', data=f) Or you can provide an :ref:`coroutine` that yields bytes objects:: @asyncio.coroutine def my_coroutine(): chunk = yield from read_some_data_from_somewhere() if not chunk: return yield chunk .. warning:: ``yield`` expression is forbidden inside ``async def``. .. note:: It is not a standard :ref:`coroutine` as it yields values so it cannot be used like ``yield from my_coroutine()``. :mod:`aiohttp` internally handles such coroutines. Also it is possible to use a :class:`~aiohttp.streams.StreamReader` object. Lets say we want to upload a file from another request and calculate the file SHA1 hash:: async def feed_stream(resp, stream): h = hashlib.sha256() while True: chunk = await resp.content.readany() if not chunk: break h.update(chunk) stream.feed_data(chunk) return h.hexdigest() resp = session.get('http://httpbin.org/post') stream = StreamReader() loop.create_task(session.post('http://httpbin.org/post', data=stream)) file_hash = await feed_stream(resp, stream) Because the response content attribute is a :class:`~aiohttp.streams.StreamReader`, you can chain get and post requests together:: r = await session.get('http://python.org') await session.post('http://httpbin.org/post', data=r.content) Uploading pre-compressed data ----------------------------- To upload data that is already compressed before passing it to aiohttp, call the request function with ``compress=False`` and set the used compression algorithm name (usually deflate or zlib) as the value of the ``Content-Encoding`` header:: async def my_coroutine(session, headers, my_data): data = zlib.compress(my_data) headers = {'Content-Encoding': 'deflate'} async with session.post('http://httpbin.org/post', data=data, headers=headers, compress=False): pass .. _aiohttp-client-session: Keep-Alive, connection pooling and cookie sharing ------------------------------------------------- :class:`~aiohttp.ClientSession` may be used for sharing cookies between multiple requests:: async with aiohttp.ClientSession() as session: await session.get( 'http://httpbin.org/cookies/set?my_cookie=my_value') filtered = session.cookie_jar.filter_cookies('http://httpbin.org') assert filtered['my_cookie'].value == 'my_value' async with session.get('http://httpbin.org/cookies') as r: json_body = await r.json() assert json_body['cookies']['my_cookie'] == 'my_value' You also can set default headers for all session requests:: async with aiohttp.ClientSession( headers={"Authorization": "Basic bG9naW46cGFzcw=="}) as session: async with session.get("http://httpbin.org/headers") as r: json_body = await r.json() assert json_body['headers']['Authorization'] == \ 'Basic bG9naW46cGFzcw==' :class:`~aiohttp.ClientSession` supports keep-alive requests and connection pooling out-of-the-box. .. _aiohttp-client-cookie-safety: Cookie safety ------------- By default :class:`~aiohttp.ClientSession` uses strict version of :class:`aiohttp.CookieJar`. :rfc:`2109` explicitly forbids cookie accepting from URLs with IP address instead of DNS name (e.g. `http://127.0.0.1:80/cookie`). It's good but sometimes for testing we need to enable support for such cookies. It should be done by passing `unsafe=True` to :class:`aiohttp.CookieJar` constructor:: jar = aiohttp.CookieJar(unsafe=True) session = aiohttp.ClientSession(cookie_jar=jar) Connectors ---------- To tweak or change *transport* layer of requests you can pass a custom *connector* to :class:`~aiohttp.ClientSession` and family. For example:: conn = aiohttp.TCPConnector() session = aiohttp.ClientSession(connector=conn) .. seealso:: :ref:`aiohttp-client-reference-connectors` section for more information about different connector types and configuration options. Limiting connection pool size ----------------------------- To limit amount of simultaneously opened connection to the same endpoint (``(host, port, is_ssl)`` triple) you can pass *limit* parameter to *connector*:: conn = aiohttp.TCPConnector(limit=30) The example limits amount of parallel connections to `30`. The default is `20`. If you explicitly want not to have limits to the same endpoint, pass `None`. For example:: conn = aiohttp.TCPConnector(limit=None) Resolving using custom nameservers ---------------------------------- In order to specify the nameservers to when resolving the hostnames, :term:`aiodns` is required:: from aiohttp.resolver import AsyncResolver resolver = AsyncResolver(nameservers=["8.8.8.8", "8.8.4.4"]) conn = aiohttp.TCPConnector(resolver=resolver) SSL control for TCP sockets --------------------------- :class:`~aiohttp.TCPConnector` constructor accepts mutually exclusive *verify_ssl* and *ssl_context* params. By default it uses strict checks for HTTPS protocol. Certification checks can be relaxed by passing ``verify_ssl=False``:: conn = aiohttp.TCPConnector(verify_ssl=False) session = aiohttp.ClientSession(connector=conn) r = await session.get('https://example.com') If you need to setup custom ssl parameters (use own certification files for example) you can create a :class:`ssl.SSLContext` instance and pass it into the connector:: sslcontext = ssl.create_default_context( cafile='/path/to/ca-bundle.crt') conn = aiohttp.TCPConnector(ssl_context=sslcontext) session = aiohttp.ClientSession(connector=conn) r = await session.get('https://example.com') You may also verify certificates via MD5, SHA1, or SHA256 fingerprint:: # Attempt to connect to https://www.python.org # with a pin to a bogus certificate: bad_md5 = b'\xa2\x06G\xad\xaa\xf5\xd8\\J\x99^by;\x06=' conn = aiohttp.TCPConnector(fingerprint=bad_md5) session = aiohttp.ClientSession(connector=conn) exc = None try: r = yield from session.get('https://www.python.org') except FingerprintMismatch as e: exc = e assert exc is not None assert exc.expected == bad_md5 # www.python.org cert's actual md5 assert exc.got == b'\xca;I\x9cuv\x8es\x138N$?\x15\xca\xcb' Note that this is the fingerprint of the DER-encoded certificate. If you have the certificate in PEM format, you can convert it to DER with e.g. ``openssl x509 -in crt.pem -inform PEM -outform DER > crt.der``. Tip: to convert from a hexadecimal digest to a binary byte-string, you can use :attr:`binascii.unhexlify`:: md5_hex = 'ca3b499c75768e7313384e243f15cacb' from binascii import unhexlify assert unhexlify(md5_hex) == b'\xca;I\x9cuv\x8es\x138N$?\x15\xca\xcb' Unix domain sockets ------------------- If your HTTP server uses UNIX domain sockets you can use :class:`~aiohttp.UnixConnector`:: conn = aiohttp.UnixConnector(path='/path/to/socket') session = aiohttp.ClientSession(connector=conn) Proxy support ------------- aiohttp supports proxy. You have to use :attr:`proxy`:: async with aiohttp.ClientSession() as session: async with session.get("http://python.org", proxy="http://some.proxy.com") as resp: print(resp.status) it also supports proxy authorization:: async with aiohttp.ClientSession() as session: proxy_auth = aiohttp.BasicAuth('user', 'pass') async with session.get("http://python.org", proxy="http://some.proxy.com", proxy_auth=proxy_auth) as resp: print(resp.status) Authentication credentials can be passed in proxy URL:: session.get("http://python.org", proxy="http://user:pass@some.proxy.com") Response Status Codes --------------------- We can check the response status code:: async with session.get('http://httpbin.org/get') as resp: assert resp.status == 200 Response Headers ---------------- We can view the server's response :attr:`ClientResponse.headers` using a :class:`CIMultiDictProxy`:: >>> resp.headers {'ACCESS-CONTROL-ALLOW-ORIGIN': '*', 'CONTENT-TYPE': 'application/json', 'DATE': 'Tue, 15 Jul 2014 16:49:51 GMT', 'SERVER': 'gunicorn/18.0', 'CONTENT-LENGTH': '331', 'CONNECTION': 'keep-alive'} The dictionary is special, though: it's made just for HTTP headers. According to `RFC 7230 `_, HTTP Header names are case-insensitive. It also supports multiple values for the same key as HTTP protocol does. So, we can access the headers using any capitalization we want:: >>> resp.headers['Content-Type'] 'application/json' >>> resp.headers.get('content-type') 'application/json' All headers converted from binary data using UTF-8 with ``surrogateescape`` option. That works fine on most cases but sometimes unconverted data is needed if a server uses nonstandard encoding. While these headers are malformed from :rfc:`7230` perspective they are may be retrieved by using :attr:`ClientResponse.raw_headers` property:: >>> resp.raw_headers ((b'SERVER', b'nginx'), (b'DATE', b'Sat, 09 Jan 2016 20:28:40 GMT'), (b'CONTENT-TYPE', b'text/html; charset=utf-8'), (b'CONTENT-LENGTH', b'12150'), (b'CONNECTION', b'keep-alive')) Response Cookies ---------------- If a response contains some Cookies, you can quickly access them:: url = 'http://example.com/some/cookie/setting/url' async with session.get(url) as resp: print(resp.cookies['example_cookie_name']) .. note:: Response cookies contain only values, that were in ``Set-Cookie`` headers of the **last** request in redirection chain. To gather cookies between all redirection requests please use :ref:`aiohttp.ClientSession ` object. Response History ---------------- If a request was redirected, it is possible to view previous responses using the :attr:`~ClientResponse.history` attribute:: >>> resp = await session.get('http://example.com/some/redirect/') >>> resp >>> resp.history (,) If no redirects occurred or ``allow_redirects`` is set to ``False``, history will be an empty sequence. .. _aiohttp-client-websockets: WebSockets ---------- :mod:`aiohttp` works with client websockets out-of-the-box. You have to use the :meth:`aiohttp.ClientSession.ws_connect` coroutine for client websocket connection. It accepts a *url* as a first parameter and returns :class:`ClientWebSocketResponse`, with that object you can communicate with websocket server using response's methods:: session = aiohttp.ClientSession() async with session.ws_connect('http://example.org/websocket') as ws: async for msg in ws: if msg.type == aiohttp.WSMsgType.TEXT: if msg.data == 'close cmd': await ws.close() break else: ws.send_str(msg.data + '/answer') elif msg.type == aiohttp.WSMsgType.CLOSED: break elif msg.type == aiohttp.WSMsgType.ERROR: break You **must** use the only websocket task for both reading (e.g. ``await ws.receive()`` or ``async for msg in ws:``) and writing but may have multiple writer tasks which can only send data asynchronously (by ``ws.send_str('data')`` for example). Timeouts -------- By default all IO operations have 5min timeout. The timeout may be overridden by passing ``timeout`` parameter into :meth:`ClientSession.get` and family:: aync with session.get('https://github.com', timeout=60) as r: ... ``None`` or ``0`` disables timeout check. The example wraps a client call in :func:`async_timeout.timeout` context manager, adding timeout for both connecting and response body reading procedures:: import async_timeout with async_timeout.timeout(0.001, loop=session.loop): async with session.get('https://github.com') as r: await r.text() .. disqus:: :title: aiohttp client usage aiohttp-1.2.0/docs/abc.rst0000664000175000017500000001101313025134363016231 0ustar travistravis00000000000000.. _aiohttp-abc: Abstract Base Classes ===================== .. module:: aiohttp .. currentmodule:: aiohttp Abstract routing ---------------- aiohttp has abstract classes for managing web interfaces. The most part of :mod:`aiohttp.web` is not intended to be inherited but few of them are. aiohttp.web is built on top of few concepts: *application*, *router*, *request* and *response*. *router* is a *pluggable* part: a library user may build a *router* from scratch, all other parts should work with new router seamlessly. :class:`AbstractRouter` has the only mandatory method: :meth:`AbstractRouter.resolve` coroutine. It must return an :class:`AbstractMatchInfo` instance. If the requested URL handler is found :meth:`AbstractMatchInfo.handler` is a :term:`web-handler` for requested URL and :attr:`AbstractMatchInfo.http_exception` is ``None``. Otherwise :attr:`AbstractMatchInfo.http_exception` is an instance of :exc:`~aiohttp.web.HTTPException` like *404: NotFound* or *405: Method Not Allowed*. :meth:`AbstractMatchInfo.handler` raises :attr:`~AbstractMatchInfo.http_exception` on call. .. class:: AbstractRouter Abstract router, :class:`aiohttp.web.Application` accepts it as *router* parameter and returns as :attr:`aiohttp.web.Application.router`. .. coroutinemethod:: resolve(request) Performs URL resolving. It's an abstract method, should be overridden in *router* implementation. :param request: :class:`aiohttp.web.Request` instance for resolving, the request has :attr:`aiohttp.web.Request.match_info` equals to ``None`` at resolving stage. :return: :class:`AbstractMatchInfo` instance. .. class:: AbstractMatchInfo Abstract *match info*, returned by :meth:`AbstractRouter.resolve` call. .. attribute:: http_exception :exc:`aiohttp.web.HTTPException` if no match was found, ``None`` otherwise. .. coroutinemethod:: handler(request) Abstract method performing :term:`web-handler` processing. :param request: :class:`aiohttp.web.Request` instance for resolving, the request has :attr:`aiohttp.web.Request.match_info` equals to ``None`` at resolving stage. :return: :class:`aiohttp.web.StreamResponse` or descendants. :raise: :class:`aiohttp.web.HTTPException` on error .. coroutinemethod:: expect_handler(request) Abstract method for handling *100-continue* processing. Abstract Class Based Views -------------------------- For *class based view* support aiohttp has abstract :class:`AbstractView` class which is *awaitable* (may be uses like ``await Cls()`` or ``yield from Cls()`` and has a *request* as an attribute. .. class:: AbstractView An abstract class, base for all *class based views* implementations. Methods ``__iter__`` and ``__await__`` should be overridden. .. attribute:: request :class:`aiohttp.web.Request` instance for performing the request. Abstract Cookie Jar ------------------- .. class:: AbstractCookieJar The cookie jar instance is available as :attr:`ClientSession.cookie_jar`. The jar contains :class:`~http.cookies.Morsel` items for storing internal cookie data. API provides a count of saved cookies:: len(session.cookie_jar) These cookies may be iterated over:: for cookie in session.cookie_jar: print(cookie.key) print(cookie["domain"]) An abstract class for cookie storage. Implements :class:`collections.abc.Iterable` and :class:`collections.abc.Sized`. .. method:: update_cookies(cookies, response_url=None) Update cookies returned by server in ``Set-Cookie`` header. :param cookies: a :class:`collections.abc.Mapping` (e.g. :class:`dict`, :class:`~http.cookies.SimpleCookie`) or *iterable* of *pairs* with cookies returned by server's response. :param str response_url: URL of response, ``None`` for *shared cookies*. Regular cookies are coupled with server's URL and are sent only to this server, shared ones are sent in every client request. .. method:: filter_cookies(request_url) Return jar's cookies acceptable for URL and available in ``Cookie`` header for sending client requests for given URL. :param str response_url: request's URL for which cookies are asked. :return: :class:`http.cookies.SimpleCookie` with filtered cookies for given URL. .. disqus:: :title: aiohttp abstact base classes aiohttp-1.2.0/docs/api.rst0000664000175000017500000001301113025134363016255 0ustar travistravis00000000000000.. _aiohttp-api: Helpers API =========== All public names from submodules ``errors``, ``multipart``, ``parsers``, ``protocol``, ``utils``, and ``wsgi`` are exported into ``aiohttp`` namespace. WebSocket utilities ------------------- .. module:: aiohttp .. currentmodule:: aiohttp .. class:: WSCloseCode An :class:`~enum.IntEnum` for keeping close message code. .. attribute:: OK A normal closure, meaning that the purpose for which the connection was established has been fulfilled. .. attribute:: GOING_AWAY An endpoint is "going away", such as a server going down or a browser having navigated away from a page. .. attribute:: PROTOCOL_ERROR An endpoint is terminating the connection due to a protocol error. .. attribute:: UNSUPPORTED_DATA An endpoint is terminating the connection because it has received a type of data it cannot accept (e.g., an endpoint that understands only text data MAY send this if it receives a binary message). .. attribute:: INVALID_TEXT An endpoint is terminating the connection because it has received data within a message that was not consistent with the type of the message (e.g., non-UTF-8 :rfc:`3629` data within a text message). .. attribute:: POLICY_VIOLATION An endpoint is terminating the connection because it has received a message that violates its policy. This is a generic status code that can be returned when there is no other more suitable status code (e.g., :attr:`~WSCloseCode.unsupported_data` or :attr:`~WSCloseCode.message_too_big`) or if there is a need to hide specific details about the policy. .. attribute:: MESSAGE_TOO_BIG An endpoint is terminating the connection because it has received a message that is too big for it to process. .. attribute:: MANDATORY_EXTENSION An endpoint (client) is terminating the connection because it has expected the server to negotiate one or more extension, but the server didn't return them in the response message of the WebSocket handshake. The list of extensions that are needed should appear in the /reason/ part of the Close frame. Note that this status code is not used by the server, because it can fail the WebSocket handshake instead. .. attribute:: INTERNAL_ERROR A server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request. .. attribute:: SERVICE_RESTART The service is restarted. a client may reconnect, and if it chooses to do, should reconnect using a randomized delay of 5-30s. .. attribute:: TRY_AGAIN_LATER The service is experiencing overload. A client should only connect to a different IP (when there are multiple for the target) or reconnect to the same IP upon user action. .. class:: WSMsgType An :class:`~enum.IntEnum` for describing :class:`WSMessage` type. .. attribute:: CONTINUATION A mark for continuation frame, user will never get the message with this type. .. attribute:: TEXT Text message, the value has :class:`str` type. .. attribute:: BINARY Binary message, the value has :class:`bytes` type. .. attribute:: PING Ping frame (sent by client peer). .. attribute:: PONG Pong frame, answer on ping. Sent by server peer. .. attribute:: CLOSE Close frame. .. attribute:: CLOSED FRAME Actually not frame but a flag indicating that websocket was closed. .. attribute:: ERROR Actually not frame but a flag indicating that websocket was received an error. .. class:: WSMessage Websocket message, returned by ``.receive()`` calls. .. attribute:: type Message type, :class:`WSMsgType` instance. .. attribute:: data Message payload. 1. :class:`str` for :attr:`WSMsgType.TEXT` messages. 2. :class:`bytes` for :attr:`WSMsgType.TEXT` messages. 3. :class:`WSCloseCode` for :attr:`WSMsgType.CLOSE` messages. 4. :class:`bytes` for :attr:`WSMsgType.PING` messages. 5. :class:`bytes` for :attr:`WSMsgType.PONG` messages. .. attribute:: extra Additional info, :class:`str`. Makes sense only for :attr:`WSMsgType.CLOSE` messages, contains optional message description. .. method:: json(*, loads=json.loads) Returns parsed JSON data. .. versionadded:: 0.22 :param loads: optional JSON decoder function. .. attribute:: tp Deprecated alias for :attr:`type`. .. deprecated:: 1.0 aiohttp.errors module --------------------- .. automodule:: aiohttp.errors :members: :undoc-members: :show-inheritance: aiohttp.helpers module ---------------------- .. automodule:: aiohttp.helpers :members: :undoc-members: :exclude-members: BasicAuth :show-inheritance: aiohttp.multipart module ------------------------ .. automodule:: aiohttp.multipart :members: :undoc-members: :show-inheritance: aiohttp.parsers module ---------------------- .. automodule:: aiohttp.parsers :members: :undoc-members: :show-inheritance: aiohttp.signals module ---------------------- .. automodule:: aiohttp.signals :members: :undoc-members: :show-inheritance: aiohttp.wsgi module ------------------- .. automodule:: aiohttp.wsgi :members: :undoc-members: :show-inheritance: .. disqus:: :title: aiohttp helpers api aiohttp-1.2.0/docs/whats_new_1_1.rst0000664000175000017500000001046413025134363020154 0ustar travistravis00000000000000========================= What's new in aiohttp 1.1 ========================= YARL and URL encoding ====================== Since aiohttp 1.1 the library uses :term:`yarl` for URL processing. New API ------- :class:`yarl.URL` gives handy methods for URL operations etc. Client API still accepts :class:`str` everywhere *url* is used, e.g. ``session.get('http://example.com')`` works as well as ``session.get(yarl.URL('http://example.com'))``. Internal API has been switched to :class:`yarl.URL`. :class:`aiohttp.CookieJar` accepts :class:`~yarl.URL` instances only. On server side has added :class:`web.Request.url` and :class:`web.Request.rel_url` properties for representing relative and absolute request's URL. URL using is the recommended way, already existed properties for retrieving URL parts are deprecated and will be eventually removed. Redirection web exceptions accepts :class:`yarl.URL` as *location* parameter. :class:`str` is still supported and will be supported forever. Reverse URL processing for *router* has been changed. The main API is :class:`aiohttp.web.Request.url_for(name, **kwargs)` which returns a :class:`yarl.URL` instance for named resource. It doesn't support *query args* but adding *args* is trivial: ``request.url_for('named_resource', param='a').with_query(arg='val')``. The method returns a *relative* URL, absolute URL may be constructed by ``request.url.join(request.url_for(...)`` call. URL encoding ------------ YARL encodes all non-ASCII symbols on :class:`yarl.URL` creation. Thus ``URL('https://www.python.org/путь')`` becomes ``'https://www.python.org/%D0%BF%D1%83%D1%82%D1%8C'``. On filling route table it's possible to use both non-ASCII and percent encoded paths:: app.router.add_get('/путь', handler) and:: app.router.add_get('/%D0%BF%D1%83%D1%82%D1%8C', handler) are the same. Internally ``'/путь'`` is converted into percent-encoding representation. Route matching also accepts both URL forms: raw and encoded by converting the route pattern to *canonical* (encoded) form on route registration. Sub-Applications ================ Sub applications are designed for solving the problem of the big monolithic code base. Let's assume we have a project with own business logic and tools like administration panel and debug toolbar. Administration panel is a separate application by its own nature but all toolbar URLs are served by prefix like ``/admin``. Thus we'll create a totally separate application named ``admin`` and connect it to main app with prefix:: admin = web.Application() # setup admin routes, signals and middlewares app.add_subapp('/admin/', admin) Middlewares and signals from ``app`` and ``admin`` are chained. It means that if URL is ``'/admin/something'`` middlewares from ``app`` are applied first and ``admin.middlewares`` are the next in the call chain. The same is going for :attr:`~aiohttp.web.Application.on_response_prepare` signal -- the signal is delivered to both top level ``app`` and ``admin`` if processing URL is routed to ``admin`` sub-application. Common signals like :attr:`~aiohttp.web.Application.on_startup`, :attr:`~aiohttp.web.Application.on_shutdown` and :attr:`~aiohttp.web.Application.on_cleanup` are delivered to all registered sub-applications. The passed parameter is sub-application instance, not top-level application. Third level sub-applications can be nested into second level ones -- there are no limitation for nesting level. Url reversing ------------- Url reversing for sub-applications should generate urls with proper prefix. But for getting URL sub-application's router should be used:: admin = web.Application() admin.add_get('/resource', handler, name='name') app.add_subapp('/admin/', admin) url = admin.router['name'].url_for() The generated ``url`` from example will have a value ``URL('/admin/resource')``. Application freezing ==================== Application can be used either as main app (``app.make_handler()``) or as sub-application -- not both cases at the same time. After connecting application by ``.add_subapp()`` call or starting serving web-server as toplevel application the application is **frozen**. It means that registering new routes, signals and middlewares is forbidden. Changing state (``app['name'] = 'value'``) of frozen application is deprecated and will be eventually removed. aiohttp-1.2.0/docs/aiohttp-icon.svg0000664000175000017500000014174613025134363020112 0ustar travistravis00000000000000 aiohttp-icon Created with Sketch. aiohttp-1.2.0/docs/faq.rst0000664000175000017500000002670013025134363016264 0ustar travistravis00000000000000Frequently Asked Questions ========================== .. contents:: :local: Are there any plans for @app.route decorator like in Flask? ----------------------------------------------------------- There are couple issues here: * This adds huge problem name "configuration as side effect of importing". * Route matching is order specific, it is very hard to maintain import order. * In semi large application better to have routes table defined in one place. For this reason feature will not be implemented. But if you really want to use decorators just derive from web.Application and add desired method. Has aiohttp the Flask Blueprint or Django App concept? ------------------------------------------------------ If you're planing to write big applications, maybe you must consider use nested applications. They acts as a Flask Blueprint or like the Django application concept. Using nested application you can add sub-applications to the main application. see: :ref:`aiohttp-web-nested-applications`. How to create route that catches urls with given prefix? --------------------------------------------------------- Try something like:: app.router.add_route('*', '/path/to/{tail:.+}', sink_handler) Where first argument, star, means catch any possible method (*GET, POST, OPTIONS*, etc), second matching ``url`` with desired prefix, third -- handler. Where to put my database connection so handlers can access it? -------------------------------------------------------------- :class:`aiohttp.web.Application` object supports :class:`dict` interface, and right place to store your database connections or any other resource you want to share between handlers. Take a look on following example:: async def go(request): db = request.app['db'] cursor = await db.cursor() await cursor.execute('SELECT 42') # ... return web.Response(status=200, text='ok') async def init_app(loop): app = Application(loop=loop) db = await create_connection(user='user', password='123') app['db'] = db app.router.add_get('/', go) return app Why the minimal supported version is Python 3.4.2 -------------------------------------------------- As of aiohttp **v0.18.0** we dropped support for Python 3.3 up to 3.4.1. The main reason for that is the :meth:`object.__del__` method, which is fully working since Python 3.4.1 and we need it for proper resource closing. The last Python 3.3, 3.4.0 compatible version of aiohttp is **v0.17.4**. This should not be an issue for most aiohttp users (for example `Ubuntu` 14.04.3 LTS provides python upgraded to 3.4.3), however libraries depending on aiohttp should consider this and either freeze aiohttp version or drop Python 3.3 support as well. As of aiohttp **v1.0.0** we dropped support for Python 3.4.1 up to 3.4.2+ also. The reason is: `loop.is_closed` appears in 3.4.2+ Again, it should be not an issue at 2016 Summer because all major distributions are switched to Python 3.5 now. How a middleware may store a data for using by web-handler later? ----------------------------------------------------------------- :class:`aiohttp.web.Request` supports :class:`dict` interface as well as :class:`aiohttp.web.Application`. Just put data inside *request*:: async def handler(request): request['unique_key'] = data See https://github.com/aio-libs/aiohttp_session code for inspiration, ``aiohttp_session.get_session(request)`` method uses ``SESSION_KEY`` for saving request specific session info. .. _aiohttp_faq_parallel_event_sources: How to receive an incoming events from different sources in parallel? --------------------------------------------------------------------- For example we have two event sources: 1. WebSocket for event from end user 2. Redis PubSub from receiving events from other parts of app for sending them to user via websocket. The most native way to perform it is creation of separate task for pubsub handling. Parallel :meth:`aiohttp.web.WebSocketResponse.receive` calls are forbidden, only the single task should perform websocket reading. But other tasks may use the same websocket object for sending data to peer:: async def handler(request): ws = web.WebSocketResponse() await ws.prepare(request) task = request.app.loop.create_task( read_subscription(ws, request.app['redis'])) try: async for msg in ws: # handle incoming messages # use ws.send_str() to send data back ... finally: task.cancel() async def read_subscriptions(ws, redis): channel, = await redis.subscribe('channel:1') try: async for msg in channel.iter(): answer = process message(msg) ws.send_str(answer) finally: await redis.unsubscribe('channel:1') .. _aiohttp_faq_terminating_websockets: How to programmatically close websocket server-side? ---------------------------------------------------- For example we have an application with two endpoints: 1. ``/echo`` a websocket echo server that authenticates the user somehow 2. ``/logout_user`` that when invoked needs to close all open websockets for that user. Keep in mind that you can only ``.close()`` a websocket from inside the handler task, and since the handler task is busy reading from the websocket, it can't react to other events. One simple solution is keeping a shared registry of websocket handler tasks for a user in the :class:`aiohttp.web.Application` instance and ``cancel()`` them in ``/logout_user`` handler:: async def echo_handler(request): ws = web.WebSocketResponse() user_id = authenticate_user(request) await ws.prepare(request) request.app['handlers'][user_id].add(asyncio.Task.current_task()) try: async for msg in ws: # handle incoming messages ... except asyncio.CancelledError: print('websocket cancelled') finally: request.app['handlers'][user_id].remove(asyncio.Task.current_task()) await ws.close() return ws async def logout_handler(request): user_id = authenticate_user(request) for task in request.app['handlers'][user_id]: task.cancel() # return response ... def main(): loop = asyncio.get_event_loop() app = aiohttp.web.Application(loop=loop) app.router.add_route('GET', '/echo', echo_handler) app.router.add_route('POST', '/logout', logout_handler) app['websockets'] = defaultdict(set) aiohttp.web.run_app(app, host='localhost', port=8080) How to make request from a specific IP address? ----------------------------------------------- If your system has several IP interfaces you may choose one which will be used used to bind socket locally:: conn = aiohttp.TCPConnector(local_addr=('127.0.0.1, 0), loop=loop) async with aiohttp.ClientSession(connector=conn) as session: ... .. seealso:: :class:`aiohttp.TCPConnector` and ``local_addr`` parameter. .. _aiohttp_faq_tests_and_implicit_loop: How to use aiohttp test features with code which works with implicit loop? -------------------------------------------------------------------------- Passing explicit loop everywhere is the recommended way. But sometimes, in case you have many nested non well-written services, this is impossible. There is a technique based on monkey-patching your low level service that depends on aioes, to inject the loop at that level. This way, you just need your ``AioESService`` with the loop in its signature. An example would be the following:: import pytest from unittest.mock import patch, MagicMock from main import AioESService, create_app class TestAcceptance: async def test_get(self, test_client, loop): with patch("main.AioESService", MagicMock( side_effect=lambda *args, **kwargs: AioESService(*args, **kwargs, loop=loop))): client = await test_client(create_app) resp = await client.get("/") assert resp.status == 200 Note how we are patching the ``AioESService`` with and instance of itself but adding the explicit loop as an extra (you need to load the loop fixture in your test signature). The final code to test all this (you will need a local instance of elasticsearch running):: import asyncio from aioes import Elasticsearch from aiohttp import web class AioESService: def __init__(self, loop=None): self.es = Elasticsearch(["127.0.0.1:9200"], loop=loop) async def get_info(self): return await self.es.info() class MyService: def __init__(self): self.aioes_service = AioESService() async def get_es_info(self): return await self.aioes_service.get_info() async def hello_aioes(request): my_service = MyService() cluster_info = await my_service.get_es_info() return web.Response(text="{}".format(cluster_info)) def create_app(loop=None): app = web.Application(loop=loop) app.router.add_route('GET', '/', hello_aioes) return app if __name__ == "__main__": web.run_app(create_app()) And the full tests file:: from unittest.mock import patch, MagicMock from main import AioESService, create_app class TestAioESService: async def test_get_info(self, loop): cluster_info = await AioESService("random_arg", loop=loop).get_info() assert isinstance(cluster_info, dict) class TestAcceptance: async def test_get(self, test_client, loop): with patch("main.AioESService", MagicMock( side_effect=lambda *args, **kwargs: AioESService(*args, **kwargs, loop=loop))): client = await test_client(create_app) resp = await client.get("/") assert resp.status == 200 Note how we are using the ``side_effect`` feature for injecting the loop to the ``AioESService.__init__`` call. The use of ``**args, **kwargs`` is mandatory in order to propagate the arguments being used by the caller. API stability and deprecation policy ------------------------------------ aiohttp tries to not break existing users code. Obsolete attributes and methods are marked as *deprecated* in documentation and raises :class:`DeprecationWarning` on usage. Deprecation period is usually a year and half. After the period is passed out deprecated code is be removed. Unfortunately we should break own rules if new functionality or bug fixing forces us to do it (for example proper cookies support on client side forced us to break backward compatibility twice). All *backward incompatible* changes are explicitly marked in :ref:`CHANGES ` chapter. How to enable gzip compression globally for the whole application? ------------------------------------------------------------------ It's impossible. Choosing what to compress and where don't apply such time consuming operation is very tricky matter. If you need global compression -- write own custom middleware. Or enable compression in NGINX (you are deploying aiohttp behind reverse proxy, isn't it). .. disqus:: :title: aiohttp FAQ aiohttp-1.2.0/docs/spelling_wordlist.txt0000664000175000017500000000362113025134363021265 0ustar travistravis00000000000000abc aiodns aioes aiohttp aiohttpdemo aiopg alives api app arg async asyncio auth autocalculated autodetection autogenerates autogeneration awaitable BaseEventLoop backend backends basename BasicAuth BodyPartReader builtin BytesIO cchardet cChardet charset charsetdetect chunked CIMultiDict ClientSession cls cmd Codings config Config configs contextmanager CookieJar coroutine Coroutine coroutines css ctor Ctrl cythonized DER dict Dict django Django dns DNSResolver Dup elasticsearch encodings env environ eof epoll fallback filename finalizers frontend getall gethostbyname github google gunicorn Gunicorn gzipped hackish highlevel hostnames HTTPException HttpProcessingError https incapsulates impl Indices infos inline io ip IP ipdb IPv ish iterable iterables Jinja javascript json keepalive keepalived keepalives keepaliving kwarg latin linux localhost login lookup lookups manylinux metadata middleware middlewares miltidict Mongo msg MsgType multidict multidicts Multidicts multipart Multipart Nagle namedtuple nameservers namespace nginx Nginx Nikolay nowait optimizations os outcoming Overridable Paolini param params parsers pathlib ping pluggable plugin Postgres poller pong pre programmatically proxied pubsub py pyenv pytest Pytest readonly readpayload rebase Redis Refactor refactored refactoring regex regexps regexs renderer renderers repo repr RequestContextManager requote resolvers reusage sa schemas sendfile serializable shourtcuts skipuntil SocketSocketTransport ssl SSLContext subclasses submodules subpackage subprotocol subprotocols subtype Supervisord supervisord Systemd Runit Svetlov symlink symlinks syscall syscalls TCP teardown Teardown TestClient Testsuite Tf timestamps toolbar toplevel tp tuples UI un unicode unittest Unittest unix unsets upstr url urldispatcher urlencoded urls utf utils uvloop vcvarsall waituntil websocket websockets Websockets wildcard Workflow ws wsgi WSMessage WSMsgType wss www aiohttp-1.2.0/docs/tutorial.rst0000664000175000017500000003101413025134363017352 0ustar travistravis00000000000000.. _aiohttp-tutorial: Server Tutorial =============== Are you going to learn *aiohttp* but don't where to start? We have example for you. Polls application is a great example for getting started with aiohttp. If you want the full source code in advance or for comparison, check out the `demo source`_. .. _demo source: https://github.com/KeepSafe/aiohttp/tree/master/demos/polls/ .. _aiohttp-tutorial-setup: Setup your environment ---------------------- First of all check you python version: .. code-block:: shell $ python -V Python 3.5.0 Tutorial requires Python 3.5.0 or newer. We’ll assume that you have already installed *aiohttp* library. You can check aiohttp is installed and which version by running the following command: .. code-block:: shell $ python -c 'import aiohttp; print(aiohttp.__version__)' 1.1.5 Project structure looks very similar to other python based web projects: .. code-block:: none . ├── README.rst └── polls ├── Makefile ├── README.rst ├── aiohttpdemo_polls │ ├── __init__.py │ ├── __main__.py │ ├── db.py │ ├── main.py │ ├── routes.py │ ├── templates │ ├── utils.py │ └── views.py ├── config │ └── polls.yaml ├── images │ └── example.png ├── setup.py ├── sql │ ├── create_tables.sql │ ├── install.sh │ └── sample_data.sql └── static └── style.css .. _aiohttp-tutorial-introduction: Getting started with aiohttp first app -------------------------------------- This tutorial based on Django polls tutorial. Application ----------- All aiohttp server is built around :class:`aiohttp.web.Application` instance. It is used for registering *startup*/*cleanup* signals, connecting routes etc. The following code creates an application:: import asyncio from aiohttp import web loop = asyncio.get_event_loop() app = web.Application(loop=loop) web.run_app(app, host='127.0.0.1', port=8080) Save it under ``aiohttpdemo_polls/main.py`` and start the server: .. code-block:: shell $ python main.py You'll see the following output on the command line: .. code-block:: shell ======== Running on http://127.0.0.1:8080 ======== (Press CTRL+C to quit) Open ``http://127.0.0.1:8080`` in browser or do .. code-block:: shell $ curl -X GET localhost:8080 Alas, for now both return only ``404: Not Found``. To show something more meaningful let's create a route and a view. .. _aiohttp-tutorial-views: Views ----- Let's start from first views. Create the file ``aiohttpdemo_polls/views.py`` with the following:: from aiohttp import web async def index(request): return web.Response(text='Hello Aiohttp!') This is the simplest view possible in Aiohttp. Now we should create a route for this ``index`` view. Put this into ``aiohttpdemo_polls/routes.py`` (it is a good practice to separate views, routes, models etc. You'll have more of each, and it is nice to have them in different places):: from views import index def setup_routes(app): app.router.add_get('/', index) Also, we should call ``setup_routes`` function somewhere, and the best place is in the ``main.py`` :: import asyncio from aiohttp import web from routes import setup_routes loop = asyncio.get_event_loop() app = web.Application(loop=loop) setup_routes(app) web.run_app(app, host='127.0.0.1', port=8080) Start server again. Now if we open browser we can see: .. code-block:: shell $ curl -X GET localhost:8080 Hello Aiohttp! Success! For now your working directory should look like this: .. code-block:: none . ├── .. └── polls ├── aiohttpdemo_polls │ ├── main.py │ ├── routes.py │ └── views.py .. _aiohttp-tutorial-config: Configuration files ------------------- aiohttp is configuration agnostic. It means the library doesn't require any configuration approach and doesn't have builtin support for any config schema. But please take into account these facts: 1. 99% of servers have configuration files. 2. Every product (except Python-based solutions like Django and Flask) doesn't store config files as part as source code. For example Nginx has own configuration files stored by default under ``/etc/nginx`` folder. Mongo pushes config as ``/etc/mongodb.conf``. 3. Config files validation is good idea, strong checks may prevent silly errors during product deployment. Thus we **suggest** to use the following approach: 1. Pushing configs as ``yaml`` files (``json`` or ``ini`` is also good but ``yaml`` is the best). 2. Loading ``yaml`` config from a list of predefined locations, e.g. ``./config/app_cfg.yaml``, ``/etc/app_cfg.yaml``. 3. Keeping ability to override config file by command line parameter, e.g. ``./run_app --config=/opt/config/app_cfg.yaml``. 4. Applying strict validation checks to loaded dict. `trafaret `_, `colander `_ or `JSON schema `_ are good candidates for such job. Load config and push into into application:: # load config from yaml file in current dir conf = load_config(str(pathlib.Path('.') / 'config' / 'polls.yaml')) app['config'] = conf .. _aiohttp-tutorial-database: Database -------- Setup ^^^^^ In this tutorial we will use the latest PostgreSQL database. You can install PostgreSQL using this instruction http://www.postgresql.org/download/ Database schema ^^^^^^^^^^^^^^^ We use SQLAlchemy to describe database schemas. For this tutorial we can use two simple models ``question`` and ``choice``:: import sqlalchemy as sa meta = sa.MetaData() question = sa.Table( 'question', meta, sa.Column('id', sa.Integer, nullable=False), sa.Column('question_text', sa.String(200), nullable=False), sa.Column('pub_date', sa.Date, nullable=False), # Indexes # sa.PrimaryKeyConstraint('id', name='question_id_pkey')) choice = sa.Table( 'choice', meta, sa.Column('id', sa.Integer, nullable=False), sa.Column('question_id', sa.Integer, nullable=False), sa.Column('choice_text', sa.String(200), nullable=False), sa.Column('votes', sa.Integer, server_default="0", nullable=False), # Indexes # sa.PrimaryKeyConstraint('id', name='choice_id_pkey'), sa.ForeignKeyConstraint(['question_id'], [question.c.id], name='choice_question_id_fkey', ondelete='CASCADE'), ) You can find below description of tables in database: First table is question: +---------------+ | question | +===============+ | id | +---------------+ | question_text | +---------------+ | pub_date | +---------------+ and second table is choice table: +---------------+ | choice | +===============+ | id | +---------------+ | choice_text | +---------------+ | votes | +---------------+ | question_id | +---------------+ Creating connection engine ^^^^^^^^^^^^^^^^^^^^^^^^^^ For making DB queries we need an engine instance. Assuming ``conf`` is a :class:`dict` with configuration info Postgres connection could be done by the following coroutine:: async def init_pg(app): conf = app['config'] engine = await aiopg.sa.create_engine( database=conf['database'], user=conf['user'], password=conf['password'], host=conf['host'], port=conf['port'], minsize=conf['minsize'], maxsize=conf['maxsize'], loop=app.loop) app['db'] = engine The best place for connecting to DB is :attr:`~aiohtp.web.Application.on_startup` signal:: app.on_startup.append(init_pg) Graceful shutdown ^^^^^^^^^^^^^^^^^ There is a good practice to close all resources on program exit. Let's close DB connection in :attr:`~aiohtp.web.Application.on_cleanup` signal:: async def close_pg(app): app['db'].close() await app['db'].wait_closed() app.on_cleanup.append(close_pg) .. _aiohttp-tutorial-templates: Templates --------- Let's add more useful views:: @aiohttp_jinja2.template('detail.html') async def poll(request): async with request['db'].acquire() as conn: question_id = request.match_info['question_id'] try: question, choices = await db.get_question(conn, question_id) except db.RecordNotFound as e: raise web.HTTPNotFound(text=str(e)) return { 'question': question, 'choices': choices } Templates are very convenient way for web page writing. We return a dict with page content, ``aiohttp_jinja2.template`` decorator processes it by jinja2 template renderer. For setting up template engine we need to install ``aiohttp_jinja2`` library first: .. code-block:: shell $ pip install aiohttp_jinja2 After installing we need to setup the library:: import aiohttp_jinja2 import jinja2 aiohttp_jinja2.setup( app, loader=jinja2.PackageLoader('aiohttpdemo_polls', 'templates')) In the tutorial we push template files under ``polls/aiohttpdemo_polls/templates`` folder. .. _aiohttp-tutorial-static: Static files ------------ Any web site has static files: images, JavaScript sources, CSS files etc. The best way to handle static in production is setting up reverse proxy like NGINX or using CDN services. But for development handling static files by aiohttp server is very convenient. Fortunately it can be done easy by single call:: app.router.add_static('/static/', path=str(project_root / 'static'), name='static') where ``project_root`` is the path to root folder. .. _aiohttp-tutorial-middlewares: Middlewares ----------- Middlewares are stacked around every web-handler. They are called *before* handler for pre-processing request and *after* getting response back for post-processing given response. Here we'll add a simple middleware for displaying pretty looking pages for *404 Not Found* and *500 Internal Error*. Middlewares could be registered in ``app`` by adding new middleware to ``app.middlewares`` list:: def setup_middlewares(app): error_middleware = error_pages({404: handle_404, 500: handle_500}) app.middlewares.append(error_middleware) Middleware itself is a factory which accepts *application* and *next handler* (the following middleware or *web-handler* in case of the latest middleware in the list). The factory returns *middleware handler* which has the same signature as regular *web-handler* -- it accepts *request* and returns *response*. Middleware for processing HTTP exceptions:: def error_pages(overrides): async def middleware(app, handler): async def middleware_handler(request): try: response = await handler(request) override = overrides.get(response.status) if override is None: return response else: return await override(request, response) except web.HTTPException as ex: override = overrides.get(ex.status) if override is None: raise else: return await override(request, ex) return middleware_handler return middleware Registered overrides are trivial Jinja2 template renderers:: async def handle_404(request, response): response = aiohttp_jinja2.render_template('404.html', request, {}) return response async def handle_500(request, response): response = aiohttp_jinja2.render_template('500.html', request, {}) return response .. seealso:: :ref:`aiohttp-web-middlewares` .. disqus:: :title: aiohttp server tutorial aiohttp-1.2.0/docs/web.rst0000664000175000017500000011765713025134363016306 0ustar travistravis00000000000000.. _aiohttp-web: Server Usage ============ .. currentmodule:: aiohttp.web Run a Simple Web Server ----------------------- In order to implement a web server, first create a :ref:`request handler `. A request handler is a :ref:`coroutine ` or regular function that accepts a :class:`Request` instance as its only parameter and returns a :class:`Response` instance:: from aiohttp import web async def hello(request): return web.Response(text="Hello, world") Next, create an :class:`Application` instance and register the request handler with the application's :class:`router ` on a particular *HTTP method* and *path*:: app = web.Application() app.router.add_get('/', hello) After that, run the application by :func:`run_app` call:: web.run_app(app) That's it. Now, head over to ``http://localhost:8080/`` to see the results. .. seealso:: :ref:`aiohttp-web-graceful-shutdown` section explains what :func:`run_app` does and how to implement complex server initialization/finalization from scratch. .. _aiohttp-web-cli: Command Line Interface (CLI) ---------------------------- :mod:`aiohttp.web` implements a basic CLI for quickly serving an :class:`Application` in *development* over TCP/IP: .. code-block:: shell $ python -m aiohttp.web -H localhost -P 8080 package.module:init_func ``package.module:init_func`` should be an importable :term:`callable` that accepts a list of any non-parsed command-line arguments and returns an :class:`Application` instance after setting it up:: def init_func(argv): app = web.Application() app.router.add_get("/", index_handler) return app .. _aiohttp-web-handler: Handler ------- A request handler can be any :term:`callable` that accepts a :class:`Request` instance as its only argument and returns a :class:`StreamResponse` derived (e.g. :class:`Response`) instance:: def handler(request): return web.Response() A handler **may** also be a :ref:`coroutine`, in which case :mod:`aiohttp.web` will ``await`` the handler:: async def handler(request): return web.Response() Handlers are setup to handle requests by registering them with the :attr:`Application.router` on a particular route (*HTTP method* and *path* pair) using methods like :class:`UrlDispatcher.add_get` and :class:`UrlDispatcher.add_post`:: app.router.add_get('/', handler) app.router.add_post('/post', post_handler) app.router.add_put('/put', put_handler) :meth:`~UrlDispatcher.add_route` also supports the wildcard *HTTP method*, allowing a handler to serve incoming requests on a *path* having **any** *HTTP method*:: app.router.add_route('*', '/path', all_handler) The *HTTP method* can be queried later in the request handler using the :attr:`Request.method` property. .. _aiohttp-web-resource-and-route: Resources and Routes -------------------- Internally *router* is a list of *resources*. Resource is an entry in *route table* which corresponds to requested URL. Resource in turn has at least one *route*. Route corresponds to handling *HTTP method* by calling *web handler*. :meth:`UrlDispatcher.add_get` / :meth:`UrlDispatcher.add_post` and family are plain shortcuts for :meth:`UrlDispatcher.add_route`. :meth:`UrlDispatcher.add_route` in turn is just a shortcut for pair of :meth:`UrlDispatcher.add_resource` and :meth:`Resource.add_route`:: resource = app.router.add_resource(path, name=name) route = resource.add_route(method, handler) return route .. seealso:: :ref:`aiohttp-router-refactoring-021` for more details .. versionadded:: 0.21.0 Introduce resources. .. _aiohttp-web-variable-handler: Variable Resources ^^^^^^^^^^^^^^^^^^ Resource may have *variable path* also. For instance, a resource with the path ``'/a/{name}/c'`` would match all incoming requests with paths such as ``'/a/b/c'``, ``'/a/1/c'``, and ``'/a/etc/c'``. A variable *part* is specified in the form ``{identifier}``, where the ``identifier`` can be used later in a :ref:`request handler ` to access the matched value for that *part*. This is done by looking up the ``identifier`` in the :attr:`Request.match_info` mapping:: async def variable_handler(request): return web.Response( text="Hello, {}".format(request.match_info['name'])) resource = app.router.add_resource('/{name}') resource.add_route('GET', variable_handler) By default, each *part* matches the regular expression ``[^{}/]+``. You can also specify a custom regex in the form ``{identifier:regex}``:: resource = app.router.add_resource(r'/{name:\d+}') .. note:: Regex should match against *percent encoded* URL (``request.rel_url_raw_path``). E.g. *space character* is encoded as ``%20``. According to `RFC 3986 `_ allowed in path symbols are:: allowed = unreserved / pct-encoded / sub-delims / ":" / "@" / "/" pct-encoded = "%" HEXDIG HEXDIG unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "=" .. _aiohttp-web-named-routes: Reverse URL Constructing using Named Resources ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Routes can also be given a *name*:: resource = app.router.add_resource('/root', name='root') Which can then be used to access and build a *URL* for that resource later (e.g. in a :ref:`request handler `):: >>> request.app.router['root'].url_for().with_query({"a": "b", "c": "d"}) URL('/root?a=b&c=d') A more interesting example is building *URLs* for :ref:`variable resources `:: app.router.add_resource(r'/{user}/info', name='user-info') In this case you can also pass in the *parts* of the route:: >>> request.app.router['user-info'].url_for(user='john_doe')\ ... .with_query("a=b") '/john_doe/info?a=b' Organizing Handlers in Classes ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ As discussed above, :ref:`handlers ` can be first-class functions or coroutines:: async def hello(request): return web.Response(text="Hello, world") app.router.add_get('/', hello) But sometimes it's convenient to group logically similar handlers into a Python *class*. Since :mod:`aiohttp.web` does not dictate any implementation details, application developers can organize handlers in classes if they so wish:: class Handler: def __init__(self): pass def handle_intro(self, request): return web.Response(text="Hello, world") async def handle_greeting(self, request): name = request.match_info.get('name', "Anonymous") txt = "Hello, {}".format(name) return web.Response(text=txt) handler = Handler() app.router.add_get('/intro', handler.handle_intro) app.router.add_get('/greet/{name}', handler.handle_greeting) .. _aiohttp-web-class-based-views: Class Based Views ^^^^^^^^^^^^^^^^^ :mod:`aiohttp.web` has support for django-style class based views. You can derive from :class:`View` and define methods for handling http requests:: class MyView(web.View): async def get(self): return await get_resp(self.request) async def post(self): return await post_resp(self.request) Handlers should be coroutines accepting self only and returning response object as regular :term:`web-handler`. Request object can be retrieved by :attr:`View.request` property. After implementing the view (``MyView`` from example above) should be registered in application's router:: app.router.add_route('*', '/path/to', MyView) Example will process GET and POST requests for */path/to* but raise *405 Method not allowed* exception for unimplemented HTTP methods. Resource Views ^^^^^^^^^^^^^^ *All* registered resources in a router can be viewed using the :meth:`UrlDispatcher.resources` method:: for resource in app.router.resources(): print(resource) Similarly, a *subset* of the resources that were registered with a *name* can be viewed using the :meth:`UrlDispatcher.named_resources` method:: for name, resource in app.router.named_resources().items(): print(name, resource) .. versionadded:: 0.18 :meth:`UrlDispatcher.routes` .. versionadded:: 0.19 :meth:`UrlDispatcher.named_routes` .. deprecated:: 0.21 Use :meth:`UrlDispatcher.named_resources` / :meth:`UrlDispatcher.resources` instead of :meth:`UrlDispatcher.named_routes` / :meth:`UrlDispatcher.routes`. Custom Routing Criteria ----------------------- Sometimes you need to register :ref:`handlers ` on more complex criteria than simply a *HTTP method* and *path* pair. Although :class:`UrlDispatcher` does not support any extra criteria, routing based on custom conditions can be accomplished by implementing a second layer of routing in your application. The following example shows custom routing based on the *HTTP Accept* header:: class AcceptChooser: def __init__(self): self._accepts = {} async def do_route(self, request): for accept in request.headers.getall('ACCEPT', []): acceptor = self._accepts.get(accept) if acceptor is not None: return (await acceptor(request)) raise HTTPNotAcceptable() def reg_acceptor(self, accept, handler): self._accepts[accept] = handler async def handle_json(request): # do json handling async def handle_xml(request): # do xml handling chooser = AcceptChooser() app.router.add_get('/', chooser.do_route) chooser.reg_acceptor('application/json', handle_json) chooser.reg_acceptor('application/xml', handle_xml) .. _aiohttp-web-static-file-handling: Static file handling -------------------- The best way to handle static files (images, JavaScripts, CSS files etc.) is using `Reverse Proxy`_ like `nginx`_ or `CDN`_ services. .. _Reverse Proxy: https://en.wikipedia.org/wiki/Reverse_proxy .. _nginx: https://nginx.org/ .. _CDN: https://en.wikipedia.org/wiki/Content_delivery_network But for development it's very convenient to handle static files by aiohttp server itself. To do it just register a new static route by :meth:`UrlDispatcher.add_static` call:: app.router.add_static('/prefix', path_to_static_folder) When a directory is accessed within a static route then the server responses to client with ``HTTP/403 Forbidden`` by default. Displaying folder index instead could be enabled with ``show_index`` parameter set to ``True``:: app.router.add_static('/prefix', path_to_static_folder, show_index=True) When a symlink from the static directory is accessed, the server responses to client with ``HTTP/404 Not Found`` by default. To allow the server to follow symlinks, parameter ``follow_symlinks`` should be set to ``True``:: app.router.add_static('/prefix', path_to_static_folder, follow_symlinks=True) Template Rendering ------------------ :mod:`aiohttp.web` does not support template rendering out-of-the-box. However, there is a third-party library, :mod:`aiohttp_jinja2`, which is supported by the *aiohttp* authors. Using it is rather simple. First, setup a *jinja2 environment* with a call to :func:`aiohttp_jinja2.setup`:: app = web.Application(loop=self.loop) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('/path/to/templates/folder')) After that you may use the template engine in your :ref:`handlers `. The most convenient way is to simply wrap your handlers with the :func:`aiohttp_jinja2.template` decorator:: @aiohttp_jinja2.template('tmpl.jinja2') def handler(request): return {'name': 'Andrew', 'surname': 'Svetlov'} If you prefer the `Mako`_ template engine, please take a look at the `aiohttp_mako`_ library. .. _Mako: http://www.makotemplates.org/ .. _aiohttp_mako: https://github.com/aio-libs/aiohttp_mako JSON Response ------------- It is a common case to return JSON data in response, :mod:`aiohttp.web` provides a shortcut for returning JSON -- :func:`aiohttp.web.json_response`:: def handler(request): data = {'some': 'data'} return web.json_response(data) The shortcut method returns :class:`aiohttp.web.Response` instance so you can for example set cookies before returning it from handler. User Sessions ------------- Often you need a container for storing user data across requests. The concept is usually called a *session*. :mod:`aiohttp.web` has no built-in concept of a *session*, however, there is a third-party library, :mod:`aiohttp_session`, that adds *session* support:: import asyncio import time import base64 from cryptography import fernet from aiohttp import web from aiohttp_session import setup, get_session, session_middleware from aiohttp_session.cookie_storage import EncryptedCookieStorage async def handler(request): session = await get_session(request) last_visit = session['last_visit'] if 'last_visit' in session else None text = 'Last visited: {}'.format(last_visit) return web.Response(text=text) def make_app(): app = web.Application() # secret_key must be 32 url-safe base64-encoded bytes fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) setup(app, EncryptedCookieStorage(secret_key)) app.router.add_route('GET', '/', handler) return app web.run_app(make_app()) .. _aiohttp-web-expect-header: *Expect* Header --------------- :mod:`aiohttp.web` supports *Expect* header. By default it sends ``HTTP/1.1 100 Continue`` line to client, or raises :exc:`HTTPExpectationFailed` if header value is not equal to "100-continue". It is possible to specify custom *Expect* header handler on per route basis. This handler gets called if *Expect* header exist in request after receiving all headers and before processing application's :ref:`aiohttp-web-middlewares` and route handler. Handler can return *None*, in that case the request processing continues as usual. If handler returns an instance of class :class:`StreamResponse`, *request handler* uses it as response. Also handler can raise a subclass of :exc:`HTTPException`. In this case all further processing will not happen and client will receive appropriate http response. .. note:: A server that does not understand or is unable to comply with any of the expectation values in the Expect field of a request MUST respond with appropriate error status. The server MUST respond with a 417 (Expectation Failed) status if any of the expectations cannot be met or, if there are other problems with the request, some other 4xx status. http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.20 If all checks pass, the custom handler *must* write a *HTTP/1.1 100 Continue* status code before returning. The following example shows how to setup a custom handler for the *Expect* header:: async def check_auth(request): if request.version != aiohttp.HttpVersion11: return if request.headers.get('EXPECT') != '100-continue': raise HTTPExpectationFailed(text="Unknown Expect: %s" % expect) if request.headers.get('AUTHORIZATION') is None: raise HTTPForbidden() request.transport.write(b"HTTP/1.1 100 Continue\r\n\r\n") async def hello(request): return web.Response(body=b"Hello, world") app = web.Application() app.router.add_get('/', hello, expect_handler=check_auth) .. _aiohttp-web-forms: HTTP Forms ---------- HTTP Forms are supported out of the box. If form's method is ``"GET"`` (``
``) use :attr:`Request.rel_url.query` for getting form data. For accessing to form data with ``"POST"`` method use :meth:`Request.post` or :meth:`Request.multipart`. :meth:`Request.post` accepts both ``'application/x-www-form-urlencoded'`` and ``'multipart/form-data'`` form's data encoding (e.g. ````) but :meth:`Request.multipart` is especially effective for uploading large files (:ref:`aiohttp-web-file-upload`). Values submitted by the following form: .. code-block:: html
could be accessed as:: async def do_login(request): data = await request.post() login = data['login'] password = data['password'] .. _aiohttp-web-file-upload: File Uploads ------------ :mod:`aiohttp.web` has built-in support for handling files uploaded from the browser. First, make sure that the HTML ``
`` element has its *enctype* attribute set to ``enctype="multipart/form-data"``. As an example, here is a form that accepts an MP3 file: .. code-block:: html
Then, in the :ref:`request handler ` you can access the file input field as a :class:`FileField` instance. :class:`FileField` is simply a container for the file as well as some of its metadata:: async def store_mp3_handler(request): # WARNING: don't do that if you plan to receive large files! data = await request.post() mp3 = data['mp3'] # .filename contains the name of the file in string format. filename = mp3.filename # .file contains the actual file data that needs to be stored somewhere. mp3_file = data['mp3'].file content = mp3_file.read() return web.Response(body=content, headers=MultiDict( {'CONTENT-DISPOSITION': mp3_file}) You might be noticed a big warning in example above. The general issue is that :meth:`Request.post` reads whole payload in memory. That's may hurt with :abbr:`OOM (Out Of Memory)` error. To avoid this, for multipart uploads, you should use :meth:`Request.multipart` which returns :ref:`multipart reader ` back:: async def store_mp3_handler(request): reader = await request.multipart() # /!\ Don't forget to validate your inputs /!\ mp3 = await reader.next() filename = mp3.filename # You cannot rely on Content-Length if transfer is chunked. size = 0 with open(os.path.join('/spool/yarrr-media/mp3/', filename), 'wb') as f: while True: chunk = await mp3.read_chunk() # 8192 bytes by default. if not chunk: break size += len(chunk) f.write(chunk) return web.Response(text='{} sized of {} successfully stored' ''.format(filename, size)) .. _aiohttp-web-websockets: WebSockets ---------- :mod:`aiohttp.web` supports *WebSockets* out-of-the-box. To setup a *WebSocket*, create a :class:`WebSocketResponse` in a :ref:`request handler ` and then use it to communicate with the peer:: async def websocket_handler(request): ws = web.WebSocketResponse() await ws.prepare(request) async for msg in ws: if msg.type == aiohttp.WSMsgType.TEXT: if msg.data == 'close': await ws.close() else: ws.send_str(msg.data + '/answer') elif msg.type == aiohttp.WSMsgType.ERROR: print('ws connection closed with exception %s' % ws.exception()) print('websocket connection closed') return ws .. _aiohttp-web-websocket-read-same-task: Reading from the *WebSocket* (``await ws.receive()``) and closing it (``await ws.close()``) **must only** be done inside the request handler *task*; however, writing (``ws.send_str(...)``) to the *WebSocket* and canceling the handler task may be delegated to other tasks. See also :ref:`FAQ section `. *aiohttp.web* creates an implicit :class:`asyncio.Task` for handling every incoming request. .. note:: While :mod:`aiohttp.web` itself only supports *WebSockets* without downgrading to *LONG-POLLING*, etc., our team supports SockJS_, an aiohttp-based library for implementing SockJS-compatible server code. .. _SockJS: https://github.com/aio-libs/sockjs .. warning:: Parallel reads from websocket are forbidden, there is no possibility to call :meth:`aiohttp.web.WebSocketResponse.receive` or :meth:`aiohttp.web.WebSocketResponse.close` from two tasks. See :ref:`FAQ section ` for instructions how to solve the problem. .. _aiohttp-web-exceptions: Exceptions ---------- :mod:`aiohttp.web` defines a set of exceptions for every *HTTP status code*. Each exception is a subclass of :class:`~HTTPException` and relates to a single HTTP status code. The exceptions are also a subclass of :class:`Response`, allowing you to either ``raise`` or ``return`` them in a :ref:`request handler ` for the same effect. The following snippets are the same:: async def handler(request): return aiohttp.web.HTTPFound('/redirect') and:: async def handler(request): raise aiohttp.web.HTTPFound('/redirect') Each exception class has a status code according to :rfc:`2068`: codes with 100-300 are not really errors; 400s are client errors, and 500s are server errors. HTTP Exception hierarchy chart:: Exception HTTPException HTTPSuccessful * 200 - HTTPOk * 201 - HTTPCreated * 202 - HTTPAccepted * 203 - HTTPNonAuthoritativeInformation * 204 - HTTPNoContent * 205 - HTTPResetContent * 206 - HTTPPartialContent HTTPRedirection * 300 - HTTPMultipleChoices * 301 - HTTPMovedPermanently * 302 - HTTPFound * 303 - HTTPSeeOther * 304 - HTTPNotModified * 305 - HTTPUseProxy * 307 - HTTPTemporaryRedirect * 308 - HTTPPermanentRedirect HTTPError HTTPClientError * 400 - HTTPBadRequest * 401 - HTTPUnauthorized * 402 - HTTPPaymentRequired * 403 - HTTPForbidden * 404 - HTTPNotFound * 405 - HTTPMethodNotAllowed * 406 - HTTPNotAcceptable * 407 - HTTPProxyAuthenticationRequired * 408 - HTTPRequestTimeout * 409 - HTTPConflict * 410 - HTTPGone * 411 - HTTPLengthRequired * 412 - HTTPPreconditionFailed * 413 - HTTPRequestEntityTooLarge * 414 - HTTPRequestURITooLong * 415 - HTTPUnsupportedMediaType * 416 - HTTPRequestRangeNotSatisfiable * 417 - HTTPExpectationFailed * 421 - HTTPMisdirectedRequest * 426 - HTTPUpgradeRequired * 428 - HTTPPreconditionRequired * 429 - HTTPTooManyRequests * 431 - HTTPRequestHeaderFieldsTooLarge * 451 - HTTPUnavailableForLegalReasons HTTPServerError * 500 - HTTPInternalServerError * 501 - HTTPNotImplemented * 502 - HTTPBadGateway * 503 - HTTPServiceUnavailable * 504 - HTTPGatewayTimeout * 505 - HTTPVersionNotSupported * 506 - HTTPVariantAlsoNegotiates * 510 - HTTPNotExtended * 511 - HTTPNetworkAuthenticationRequired All HTTP exceptions have the same constructor signature:: HTTPNotFound(*, headers=None, reason=None, body=None, text=None, content_type=None) If not directly specified, *headers* will be added to the *default response headers*. Classes :class:`HTTPMultipleChoices`, :class:`HTTPMovedPermanently`, :class:`HTTPFound`, :class:`HTTPSeeOther`, :class:`HTTPUseProxy`, :class:`HTTPTemporaryRedirect` have the following constructor signature:: HTTPFound(location, *, headers=None, reason=None, body=None, text=None, content_type=None) where *location* is value for *Location HTTP header*. :class:`HTTPMethodNotAllowed` is constructed by providing the incoming unsupported method and list of allowed methods:: HTTPMethodNotAllowed(method, allowed_methods, *, headers=None, reason=None, body=None, text=None, content_type=None) .. _aiohttp-web-data-sharing: Data Sharing aka No Singletons Please ------------------------------------- :mod:`aiohttp.web` discourages the use of *global variables*, aka *singletons*. Every variable should have its own context that is *not global*. So, :class:`aiohttp.web.Application` and :class:`aiohttp.web.Request` support a :class:`collections.abc.MutableMapping` interface (i.e. they are dict-like objects), allowing them to be used as data stores. For storing *global-like* variables, feel free to save them in an :class:`~.Application` instance:: app['my_private_key'] = data and get it back in the :term:`web-handler`:: async def handler(request): data = request.app['my_private_key'] Variables that are only needed for the lifetime of a :class:`~.Request`, can be stored in a :class:`~.Request`:: async def handler(request): request['my_private_key'] = "data" ... This is mostly useful for :ref:`aiohttp-web-middlewares` and :ref:`aiohttp-web-signals` handlers to store data for further processing by the next handlers in the chain. To avoid clashing with other *aiohttp* users and third-party libraries, please choose a unique key name for storing data. If your code is published on PyPI, then the project name is most likely unique and safe to use as the key. Otherwise, something based on your company name/url would be satisfactory (i.e. ``org.company.app``). .. _aiohttp-web-middlewares: Middlewares ----------- :mod:`aiohttp.web` provides a powerful mechanism for customizing :ref:`request handlers` via *middlewares*. *Middlewares* are setup by providing a sequence of *middleware factories* to the keyword-only ``middlewares`` parameter when creating an :class:`Application`:: app = web.Application(middlewares=[middleware_factory_1, middleware_factory_2]) A *middleware factory* is simply a coroutine that implements the logic of a *middleware*. For example, here's a trivial *middleware factory*:: async def middleware_factory(app, handler): async def middleware_handler(request): return await handler(request) return middleware_handler Every *middleware factory* should accept two parameters, an :class:`app ` instance and a *handler*, and return a new handler. The *handler* passed in to a *middleware factory* is the handler returned by the **next** *middleware factory*. The last *middleware factory* always receives the :ref:`request handler ` selected by the router itself (by :meth:`UrlDispatcher.resolve`). *Middleware factories* should return a new handler that has the same signature as a :ref:`request handler `. That is, it should accept a single :class:`Request` instance and return a :class:`Response`, or raise an exception. Internally, a single :ref:`request handler ` is constructed by applying the middleware chain to the original handler in reverse order, and is called by the :class:`RequestHandler` as a regular *handler*. Since *middleware factories* are themselves coroutines, they may perform extra ``await`` calls when creating a new handler, e.g. call database etc. *Middlewares* usually call the inner handler, but they may choose to ignore it, e.g. displaying *403 Forbidden page* or raising :exc:`HTTPForbidden` exception if user has no permissions to access the underlying resource. They may also render errors raised by the handler, perform some pre- or post-processing like handling *CORS* and so on. Example ^^^^^^^ A common use of middlewares is to implement custom error pages. The following example will render 404 errors using a JSON response, as might be appropriate a JSON REST service:: import json from aiohttp import web def json_error(message): return web.Response( body=json.dumps({'error': message}).encode('utf-8'), content_type='application/json') async def error_middleware(app, handler): async def middleware_handler(request): try: response = await handler(request) if response.status == 404: return json_error(response.message) return response except web.HTTPException as ex: if ex.status == 404: return json_error(ex.reason) raise return middleware_handler app = web.Application(middlewares=[error_middleware]) .. _aiohttp-web-signals: Signals ------- .. versionadded:: 0.18 Although :ref:`middlewares ` can customize :ref:`request handlers` before or after a :class:`Response` has been prepared, they can't customize a :class:`Response` **while** it's being prepared. For this :mod:`aiohttp.web` provides *signals*. For example, a middleware can only change HTTP headers for *unprepared* responses (see :meth:`~aiohttp.web.StreamResponse.prepare`), but sometimes we need a hook for changing HTTP headers for streamed responses and WebSockets. This can be accomplished by subscribing to the :attr:`~aiohttp.web.Application.on_response_prepare` signal:: async def on_prepare(request, response): response.headers['My-Header'] = 'value' app.on_response_prepare.append(on_prepare) Signal handlers should not return a value but may modify incoming mutable parameters. .. warning:: Signals API has provisional status, meaning it may be changed in future releases. Signal subscription and sending will most likely be the same, but signal object creation is subject to change. As long as you are not creating new signals, but simply reusing existing ones, you will not be affected. .. _aiohttp-web-nested-applications: Nested applications ------------------- Sub applications are designed for solving the problem of the big monolithic code base. Let's assume we have a project with own business logic and tools like administration panel and debug toolbar. Administration panel is a separate application by its own nature but all toolbar URLs are served by prefix like ``/admin``. Thus we'll create a totally separate application named ``admin`` and connect it to main app with prefix by :meth:`~aiohttp.web.UrlDispatcher.add_subapp`:: admin = web.Application() # setup admin routes, signals and middlewares app.router.add_subapp('/admin/', admin) Middlewares and signals from ``app`` and ``admin`` are chained. It means that if URL is ``'/admin/something'`` middlewares from ``app`` are applied first and ``admin.middlewares`` are the next in the call chain. The same is going for :attr:`~aiohttp.web.Application.on_response_prepare` signal -- the signal is delivered to both top level ``app`` and ``admin`` if processing URL is routed to ``admin`` sub-application. Common signals like :attr:`~aiohttp.web.Application.on_startup`, :attr:`~aiohttp.web.Application.on_shutdown` and :attr:`~aiohttp.web.Application.on_cleanup` are delivered to all registered sub-applications. The passed parameter is sub-application instance, not top-level application. Third level sub-applications can be nested into second level ones -- there are no limitation for nesting level. Url reversing for sub-applications should generate urls with proper prefix. But for getting URL sub-application's router should be used:: admin = web.Application() admin.router.add_get('/resource', handler, name='name') app.router.add_subapp('/admin/', admin) url = admin.router['name'].url_for() The generated ``url`` from example will have a value ``URL('/admin/resource')``. .. _aiohttp-web-flow-control: Flow control ------------ :mod:`aiohttp.web` has sophisticated flow control for underlying TCP sockets write buffer. The problem is: by default TCP sockets use `Nagle's algorithm `_ for output buffer which is not optimal for streaming data protocols like HTTP. Web server response may have one of the following states: 1. **CORK** (:attr:`~StreamResponse.tcp_cork` is ``True``). Don't send out partial TCP/IP frames. All queued partial frames are sent when the option is cleared again. Optimal for sending big portion of data since data will be sent using minimum frames count. If OS doesn't support **CORK** mode (neither ``socket.TCP_CORK`` nor ``socket.TCP_NOPUSH`` exists) the mode is equal to *Nagle's enabled* one. The most widespread OS without **CORK** support is *Windows*. 2. **NODELAY** (:attr:`~StreamResponse.tcp_nodelay` is ``True``). Disable the Nagle algorithm. This means that small data pieces are always sent as soon as possible, even if there is only a small amount of data. Optimal for transmitting short messages. 3. Nagle's algorithm enabled (both :attr:`~StreamResponse.tcp_cork` and :attr:`~StreamResponse.tcp_nodelay` are ``False``). Data is buffered until there is a sufficient amount to send out. Avoid using this mode for sending HTTP data until you have no doubts. By default streaming data (:class:`StreamResponse`), regular responses (:class:`Response` and http exceptions derived from it) and websockets (:class:`WebSocketResponse`) use **NODELAY** mode, static file handlers work in **CORK** mode. To manual mode switch :meth:`~StreamResponse.set_tcp_cork` and :meth:`~StreamResponse.set_tcp_nodelay` methods can be used. It may be helpful for better streaming control for example. .. _aiohttp-web-graceful-shutdown: Graceful shutdown ------------------ Stopping *aiohttp web server* by just closing all connections is not always satisfactory. The problem is: if application supports :term:`websocket`\s or *data streaming* it most likely has open connections at server shutdown time. The *library* has no knowledge how to close them gracefully but developer can help by registering :attr:`Application.on_shutdown` signal handler and call the signal on *web server* closing. Developer should keep a list of opened connections (:class:`Application` is a good candidate). The following :term:`websocket` snippet shows an example for websocket handler:: app = web.Application() app['websockets'] = [] async def websocket_handler(request): ws = web.WebSocketResponse() await ws.prepare(request) request.app['websockets'].append(ws) try: async for msg in ws: ... finally: request.app['websockets'].remove(ws) return ws Signal handler may look like:: async def on_shutdown(app): for ws in app['websockets']: await ws.close(code=WSCloseCode.GOING_AWAY, message='Server shutdown') app.on_shutdown.append(on_shutdown) Proper finalization procedure has three steps: 1. Stop accepting new client connections by :meth:`asyncio.Server.close` and :meth:`asyncio.Server.wait_closed` calls. 2. Fire :meth:`Application.shutdown` event. 3. Close accepted connections from clients by :meth:`Server.shutdown` call with reasonable small delay. 4. Call registered application finalizers by :meth:`Application.cleanup`. The following code snippet performs proper application start, run and finalizing. It's pretty close to :func:`run_app` utility function:: loop = asyncio.get_event_loop() handler = app.make_handler() f = loop.create_server(handler, '0.0.0.0', 8080) srv = loop.run_until_complete(f) print('serving on', srv.sockets[0].getsockname()) try: loop.run_forever() except KeyboardInterrupt: pass finally: srv.close() loop.run_until_complete(srv.wait_closed()) loop.run_until_complete(app.shutdown()) loop.run_until_complete(handler.shutdown(60.0)) loop.run_until_complete(app.cleanup()) loop.close() .. _aiohttp-web-background-tasks: Background tasks ----------------- Sometimes there's a need to perform some asynchronous operations just after application start-up. Even more, in some sophisticated systems there could be a need to run some background tasks in the event loop along with the application's request handler. Such as listening to message queue or other network message/event sources (e.g. ZeroMQ, Redis Pub/Sub, AMQP, etc.) to react to received messages within the application. For example the background task could listen to ZeroMQ on :data:`zmq.SUB` socket, process and forward retrieved messages to clients connected via WebSocket that are stored somewhere in the application (e.g. in the :obj:`application['websockets']` list). To run such short and long running background tasks aiohttp provides an ability to register :attr:`Application.on_startup` signal handler(s) that will run along with the application's request handler. For example there's a need to run one quick task and two long running tasks that will live till the application is alive. The appropriate background tasks could be registered as an :attr:`Application.on_startup` signal handlers as shown in the example below:: async def listen_to_redis(app): try: sub = await aioredis.create_redis(('localhost', 6379), loop=app.loop) ch, *_ = await sub.subscribe('news') async for msg in ch.iter(encoding='utf-8'): # Forward message to all connected websockets: for ws in app['websockets']: ws.send_str('{}: {}'.format(ch.name, msg)) except asyncio.CancelledError: pass finally: await sub.unsubscribe(ch.name) await sub.quit() async def start_background_tasks(app): app['redis_listener'] = app.loop.create_task(listen_to_redis(app)) async def cleanup_background_tasks(app): app['redis_listener'].cancel() await app['redis_listener'] app = web.Application() app.on_startup.append(start_background_tasks) app.on_cleanup.append(cleanup_background_tasks) web.run_app(app) The task :func:`listen_to_redis` will run forever. To shut it down correctly :attr:`Application.on_cleanup` signal handler may be used to send a cancellation to it. Handling error pages -------------------- Pages like *404 Not Found* and *500 Internal Error* could be handled by custom middleware, see :ref:`aiohttp-tutorial-middlewares` for details. Swagger support --------------- `aiohttp-swagger `_ is a library that allow to add Swagger documentation and embed the Swagger-UI into your :mod:`aiohttp.web` project. CORS support ------------ :mod:`aiohttp.web` itself does not support `Cross-Origin Resource Sharing `_, but there is an aiohttp plugin for it: `aiohttp_cors `_. Debug Toolbar ------------- aiohttp_debugtoolbar_ is a very useful library that provides a debugging toolbar while you're developing an :mod:`aiohttp.web` application. Install it via ``pip``: .. code-block:: shell $ pip install aiohttp_debugtoolbar After that attach the :mod:`aiohttp_debugtoolbar` middleware to your :class:`aiohttp.web.Application` and call :func:`aiohttp_debugtoolbar.setup`:: import aiohttp_debugtoolbar from aiohttp_debugtoolbar import toolbar_middleware_factory app = web.Application(loop=loop, middlewares=[toolbar_middleware_factory]) aiohttp_debugtoolbar.setup(app) The toolbar is ready to use. Enjoy!!! .. _aiohttp_debugtoolbar: https://github.com/aio-libs/aiohttp_debugtoolbar .. disqus:: :title: aiohttp server usage aiohttp-1.2.0/docs/deployment.rst0000664000175000017500000002103513025134363017671 0ustar travistravis00000000000000========================= aiohttp server deployment ========================= There are several options for aiohttp server deployment: * Standalone server * Running a pool of backend servers behind of :term:`nginx`, HAProxy or other *reverse proxy server* * Using :term:`gunicorn` behind of *reverse proxy* Every method has own benefits and disadvantages. .. _aiohttp-deployment-standalone: Standalone ========== Just call :func:`aiohttp.web.run_app` function passing :class:`aiohttp.web.Application` instance. The method is very simple and could be the best solution in some trivial cases. But it doesn't utilize all CPU cores. For running multiple aiohttp server instances use *reverse proxies*. .. _aiohttp-deployment-nginx-supervisord: Nginx+supervisord ================= Running aiohttp servers behind :term:`nginx` makes several advantages. At first, nginx is the perfect frontend server. It may prevent many attacks based on malformed http protocol etc. Second, running several aiohttp instances behind nginx allows to utilize all CPU cores. Third, nginx serves static files much faster than built-in aiohttp static file support. But this way requires more complex configuration. Nginx configuration -------------------- Here is short extraction about writing Nginx configuration file. It doesn't cover all available Nginx options. For full reference read `Nginx tutorial `_ and `official Nginx documentation `_. First configure HTTP server itself: .. code-block:: nginx http { server { listen 80; client_max_body_size 4G; server example.com; location / { proxy_set_header Host $http_host; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_redirect off; proxy_buffering off; proxy_pass http://aiohttp; } location /static { # path for static files root /path/to/app/static; } } } This config listens on port ``80`` for server named ``example.com`` and redirects everything to ``aiohttp`` backend group. Also it serves static files from ``/path/to/app/static`` path as ``example.com/static``. Next we need to configure *aiohttp upstream group*: .. code-block:: nginx http { upstream aiohttp { fail_timeout=0 means we always retry an upstream even if it failed # to return a good HTTP response # TCP servers server 127.0.0.1:8081 fail_timeout=0; server 127.0.0.1:8082 fail_timeout=0; server 127.0.0.1:8083 fail_timeout=0; server 127.0.0.1:8084 fail_timeout=0; } } All HTTP requests for ``http://example.com`` except ones for ``http://example.com/static`` will be redirected to ``127.0.0.1:8081``, ``127.0.0.1:8082``, ``127.0.0.1:8083`` or ``127.0.0.1:8084`` *backend proxies*. By default Nginx uses round-robin algorithm for backend selection. .. note:: Nginx is not the only existing *reverse proxy server* but the most popular one. Alternatives like HAProxy may be used as well. Supervisord ----------- After configuring Nginx we need to start our aiohttp backends. Better to use some tool for starting them automatically after system reboot or backend crash. There are very many ways to do it: Supervisord, Upstart, Systemd, Gaffer, Circus, Runit etc. Here we'll use `Supervisord `_ for example:: [program:aiohttp_1] cmd=/path/to/aiohttp_example.py 8081 user=nobody autostart=true autorestart=true [program:aiohttp_2] cmd=/path/to/aiohttp_example.py 8082 user=nobody autostart=true autorestart=true [program:aiohttp_3] cmd=/path/to/aiohttp_example.py 8083 user=nobody autostart=true autorestart=true [program:aiohttp_4] cmd=/path/to/aiohttp_example.py 8084 user=nobody autostart=true autorestart=true The config will run four aiohttp server instances, ports are specified by command line. aiohttp server -------------- The last step is preparing aiohttp server for working with supervisord. Assuming we have properly configured :class:`aiohttp.web.Application` and port is specified by command line the task is trivial:: # aiohttp_example.py import argparse from aiohttp import web parser = argparse.ArgumentParser(description="aiohttp server example") parser.add_argument('port', type=int) if __name__ == '__main__': app = web.Application() # configure app args = parser.parse_args() web.run_app(app, port=args.port) For real use cases we perhaps need to configure other things like logging etc. but it's out of scope of the topic. .. _aiohttp-deployment-gunicorn: Nginx+Gunicorn ============== aiohttp can be deployed using `Gunicorn `_, which is based on a pre-fork worker model. Gunicorn launches your app as worker processes for handling incoming requests. In opposite to deployment with :ref:`bare Nginx ` the solution doesn't need to manually run several aiohttp processes and use tool like supervisord for monitoring it. But nothing is for free: running aiohttp application under gunicorn is slightly slower. Prepare environment ------------------- You firstly need to setup your deployment environment. This example is based on `Ubuntu` 14.04. Create a directory for your application:: >> mkdir myapp >> cd myapp `Ubuntu` has a bug in pyenv, so to create virtualenv you need to do some extra manipulation:: >> pyvenv-3.4 --without-pip venv >> source venv/bin/activate >> curl https://bootstrap.pypa.io/get-pip.py | python >> deactivate >> source venv/bin/activate Now that the virtual environment is ready, we'll proceed to install aiohttp and gunicorn:: >> pip install gunicorn >> pip install -e git+https://github.com/KeepSafe/aiohttp.git#egg=aiohttp Application ----------- Lets write a simple application, which we will save to file. We'll name this file *my_app_module.py*:: from aiohttp import web def index(request): return web.Response(text="Welcome home!") my_web_app = web.Application() my_web_app.router.add_get('/', index) Start Gunicorn -------------- When `Running Gunicorn `_, you provide the name of the module, i.e. *my_app_module*, and the name of the app, i.e. *my_web_app*, along with other `Gunicorn Settings `_ provided as command line flags or in your config file. In this case, we will use: * the *'--bind'* flag to set the server's socket address; * the *'--worker-class'* flag to tell Gunicorn that we want to use a custom worker subclass instead of one of the Gunicorn default worker types; * you may also want to use the *'--workers'* flag to tell Gunicorn how many worker processes to use for handling requests. (See the documentation for recommendations on `How Many Workers? `_) The custom worker subclass is defined in *aiohttp.worker.GunicornWebWorker* and should be used instead of the *gaiohttp* worker provided by Gunicorn, which supports only aiohttp.wsgi applications:: >> gunicorn my_app_module:my_web_app --bind localhost:8080 --worker-class aiohttp.worker.GunicornWebWorker [2015-03-11 18:27:21 +0000] [1249] [INFO] Starting gunicorn 19.3.0 [2015-03-11 18:27:21 +0000] [1249] [INFO] Listening at: http://127.0.0.1:8080 (1249) [2015-03-11 18:27:21 +0000] [1249] [INFO] Using worker: aiohttp.worker.GunicornWebWorker [2015-03-11 18:27:21 +0000] [1253] [INFO] Booting worker with pid: 1253 Gunicorn is now running and ready to serve requests to your app's worker processes. .. note:: If you want to use an alternative asyncio event loop `uvloop `_, you can use the ``aiohttp.worker.GunicornUVLoopWebWorker`` worker class. More information ---------------- The Gunicorn documentation recommends deploying Gunicorn behind an Nginx proxy server. See the `official documentation `_ for more information about suggested nginx configuration. Logging configuration --------------------- ``aiohttp`` and ``gunicorn`` use different format for specifying access log. By default aiohttp uses own defaults:: '%a %l %u %t "%r" %s %b "%{Referrer}i" "%{User-Agent}i"' For more information please read :ref:`Format Specification for Accees Log `. .. disqus:: :title: aiohttp deployment with gunicorn aiohttp-1.2.0/docs/logging.rst0000664000175000017500000001103113025134363017132 0ustar travistravis00000000000000.. _aiohttp-logging: Logging ======= .. currentmodule:: aiohttp *aiohttp* uses standard :mod:`logging` for tracking the library activity. We have the following loggers enumerated by names: - ``'aiohttp.access'`` - ``'aiohttp.client'`` - ``'aiohttp.internal'`` - ``'aiohttp.server'`` - ``'aiohttp.web'`` - ``'aiohttp.websocket'`` You may subscribe to these loggers for getting logging messages. The page does not provide instructions for logging subscribing while the most friendly method is :func:`logging.config.dictConfig` for configuring whole loggers in your application. Access logs ----------- Access log by default is switched on and uses ``'aiohttp.access'`` logger name. The log may be controlled by :meth:`aiohttp.web.Application.make_handler` call. Pass *access_log* parameter with value of :class:`logging.Logger` instance to override default logger. .. note:: Use ``app.make_handler(access_log=None)`` for disabling access logs. Other parameter called *access_log_format* may be used for specifying log format (see below). .. _aiohttp-logging-access-log-format-spec: Format specification ^^^^^^^^^^^^^^^^^^^^ The library provides custom micro-language to specifying info about request and response: +--------------+---------------------------------------------------------+ | Option | Meaning | +==============+=========================================================+ | ``%%`` | The percent sign | +--------------+---------------------------------------------------------+ | ``%a`` | Remote IP-address | | | (IP-address of proxy if using reverse proxy) | +--------------+---------------------------------------------------------+ | ``%t`` | Time when the request was started to process | +--------------+---------------------------------------------------------+ | ``%P`` | The process ID of the child that serviced the request | +--------------+---------------------------------------------------------+ | ``%r`` | First line of request | +--------------+---------------------------------------------------------+ | ``%s`` | Response status code | +--------------+---------------------------------------------------------+ | ``%b`` | Size of response in bytes, excluding HTTP headers | +--------------+---------------------------------------------------------+ | ``%O`` | Bytes sent, including headers | +--------------+---------------------------------------------------------+ | ``%T`` | The time taken to serve the request, in seconds | +--------------+---------------------------------------------------------+ | ``%Tf`` | The time taken to serve the request, in seconds | | | with fraction in %.06f format | +--------------+---------------------------------------------------------+ | ``%D`` | The time taken to serve the request, in microseconds | +--------------+---------------------------------------------------------+ | ``%{FOO}i`` | ``request.headers['FOO']`` | +--------------+---------------------------------------------------------+ | ``%{FOO}o`` | ``response.headers['FOO']`` | +--------------+---------------------------------------------------------+ | ``%{FOO}e`` | ``os.environ['FOO']`` | +--------------+---------------------------------------------------------+ Default access log format is:: '%a %l %u %t "%r" %s %b "%{Referrer}i" "%{User-Agent}i"' .. note:: When `Gunicorn `_ is used for :ref:`deployment ` its default access log format will be automatically replaced with the default aiohttp's access log format. If Gunicorn's option access_logformat_ is specified explicitly it should use aiohttp's format specification. Error logs ---------- *aiohttp.web* uses logger named ``'aiohttp.server'`` to store errors given on web requests handling. The log is enabled by default. To use different logger name please specify *logger* parameter (:class:`logging.Logger` instance) on performing :meth:`aiohttp.web.Application.make_handler` call. .. _access_logformat: http://docs.gunicorn.org/en/stable/settings.html#access-log-format .. disqus:: :title: aiohttp logging aiohttp-1.2.0/docs/server.rst0000664000175000017500000001100513025134363017013 0ustar travistravis00000000000000.. _aiohttp-server: Deprecated Low-level Server =========================== .. currentmodule:: aiohttp.server .. note:: This topic describes the low-level HTTP support. For high-level interface please take a look on :mod:`aiohttp.web`. .. deprecated:: 1.2 The module has been deprecated and will be eventually removed. Use :ref:`aiohttp-web-lowlevel` instead. The new solution provides much more user friendly API. Run a basic server ------------------ Start implementing the basic server by inheriting the :class:`ServerHttpProtocol` object. Your class should implement the only method :meth:`ServerHttpProtocol.handle_request` which must be a coroutine to handle requests asynchronously:: from urllib.parse import urlparse, parse_qsl import aiohttp import aiohttp.server from aiohttp import MultiDict import asyncio class HttpRequestHandler(aiohttp.server.ServerHttpProtocol): async def handle_request(self, message, payload): response = aiohttp.Response( self.writer, 200, http_version=message.version ) response.add_header('Content-Type', 'text/html') response.add_header('Content-Length', '18') response.send_headers() response.write(b'

It Works!

') await response.write_eof() The next step is to create a loop and register your handler within a server. :exc:`KeyboardInterrupt` exception handling is necessary so you can stop your server with Ctrl+C at any time:: if __name__ == '__main__': loop = asyncio.get_event_loop() f = loop.create_server( lambda: HttpRequestHandler(debug=True, keep_alive=75), '0.0.0.0', '8080') srv = loop.run_until_complete(f) print('serving on', srv.sockets[0].getsockname()) try: loop.run_forever() except KeyboardInterrupt: pass Headers ------- Data is passed to the handler in the ``message``, while request body is passed in ``payload`` param. HTTP headers are accessed through ``headers`` member of the message. To check what the current method of the request is use the ``method`` member of the ``message``. It should be one of ``GET``, ``POST``, ``PUT`` or ``DELETE`` strings. Handling GET params ------------------- Currently aiohttp does not provide automatic parsing of incoming GET params. However aiohttp does provide a nice :class:`MulitiDict` wrapper for already parsed params:: from urllib.parse import urlparse, parse_qsl from aiohttp import MultiDict class HttpRequestHandler(aiohttp.server.ServerHttpProtocol): async def handle_request(self, message, payload): response = aiohttp.Response( self.writer, 200, http_version=message.version ) get_params = MultiDict(parse_qsl(urlparse(message.path).query)) print("Passed in GET", get_params) Sending pre-compressed data --------------------------- To include data in the response that is already compressed, do not call `enable_compression`. Instead, set the `Content-Encoding` header explicitly:: @asyncio.coroutine def handler(request): headers = {'Content-Encoding': 'gzip'} deflated_data = zlib.compress(b'mydata') return web.Response(body=deflated_data, headers=headers) Handling POST data ------------------ POST data is accessed through the ``payload.read()`` generator method. If you have form data in the request body, you can parse it in the same way as GET params:: from urllib.parse import urlparse, parse_qsl from aiohttp import MultiDict class HttpRequestHandler(aiohttp.server.ServerHttpProtocol): async def handle_request(self, message, payload): response = aiohttp.Response( self.writer, 200, http_version=message.version ) data = await payload.read() post_params = MultiDict(parse_qsl(data)) print("Passed in POST", post_params) SSL --- To use asyncio's SSL support, just pass an SSLContext object to the :meth:`asyncio.AbstractEventLoop.create_server` method of the loop:: import ssl sslcontext = ssl.SSLContext(ssl.PROTOCOL_SSLv23) sslcontext.load_cert_chain('sample.crt', 'sample.key') loop = asyncio.get_event_loop() loop.create_server(lambda: handler, "0.0.0.0", "8080", ssl=sslcontext) Reference --------- .. automodule:: aiohttp.server :members: :undoc-members: :show-inheritance: .. disqus:: :title: aiohttp low-level server aiohttp-1.2.0/docs/streams.rst0000664000175000017500000000715613025134363017177 0ustar travistravis00000000000000.. module:: aiohttp.streams .. _aiohttp-streams: Streaming API ============= .. module:: aiohttp .. currentmodule:: aiohttp ``aiohttp`` uses streams for retrieving *BODIES*: :attr:`aiohttp.web.Request.content` and :attr:`aiohttp.ClientResponse.content` are properties with stream API. .. class:: StreamReader The reader from incoming stream. User should never instantiate streams manually but use existing :attr:`aiohttp.web.Request.content` and :attr:`aiohttp.ClientResponse.content` properties for accessing raw BODY data. Reading Methods --------------- .. comethod:: StreamReader.read(n=-1) Read up to *n* bytes. If *n* is not provided, or set to ``-1``, read until EOF and return all read bytes. If the EOF was received and the internal buffer is empty, return an empty bytes object. :param int n: how many bytes to read, ``-1`` for the whole stream. :return bytes: the given data .. comethod:: StreamReader.readany() Read next data portion for the stream. Returns immediately if internal buffer has a data. :return bytes: the given data .. comethod:: StreamReader.readexactly(n) Read exactly *n* bytes. Raise an :exc:`asyncio.IncompleteReadError` if the end of the stream is reached before *n* can be read, the :attr:`asyncio.IncompleteReadError.partial` attribute of the exception contains the partial read bytes. :param int n: how many bytes to read. :return bytes: the given data .. comethod:: StreamReader.readline() Read one line, where “line” is a sequence of bytes ending with ``\n``. If EOF is received, and ``\n`` was not found, the method will return the partial read bytes. If the EOF was received and the internal buffer is empty, return an empty bytes object. :return bytes: the given line Asynchronous Iteration Support ------------------------------ Stream reader supports asynchronous iteration over BODY. By default it iterates over lines:: async for line in response.content: print(line) Also there are methods for iterating over data chunks with maximum size limit and over any available data. .. comethod:: StreamReader.iter_chunked(n) :async-for: Iterates over data chunks with maximum size limit:: async for data in response.content.iter_chunked(1024): print(data) .. comethod:: StreamReader.iter_any(n) :async-for: Iterates over data chunks in order of intaking them into the stream:: async for data in response.content.iter_any(): print(data) Helpers ------- .. method:: StreamReader.exception() Get the exception occurred on data reading. .. method:: is_eof() Return ``True`` if EOF was reached. Internal buffer may be not empty at the moment. .. seealso:: :meth:`StreamReader.at_eof()` .. method:: StreamReader.at_eof() Return ``True`` if the buffer is empty and EOF was reached. .. method:: StreamReader.read_nowait(n=None) Returns data from internal buffer if any, empty bytes object otherwise. Raises :exc:`RuntimeError` if other coroutine is waiting for stream. :param int n: how many bytes to read, ``-1`` for the whole internal buffer. :return bytes: the given data .. method:: StreamReader.unread_data(data) Rollback reading some data from stream, inserting it to buffer head. :param bytes data: data to push back into the stream. .. warning:: The method doesn't wake up waiters. E.g. :meth:`~StreamReader.read()` will not be resumed. .. comethod:: wait_eof() Wait for EOF. The given data may be accessible by upcoming read calls. .. disqus:: :title: aiohttp streaming api aiohttp-1.2.0/docs/new_router.rst0000664000175000017500000000554613025134363017713 0ustar travistravis00000000000000.. _aiohttp-router-refactoring-021: Router refactoring in 0.21 ========================== Rationale --------- First generation (v1) of router has mapped ``(method, path)`` pair to :term:`web-handler`. Mapping is named **route**. Routes used to have unique names if any. The main mistake with the design is coupling the **route** to ``(method, path)`` pair while really URL construction operates with **resources** (**location** is a synonym). HTTP method is not part of URI but applied on sending HTTP request only. Having different **route names** for the same path is confusing. Moreover **named routes** constructed for the same path should have unique non overlapping names which is cumbersome is certain situations. From other side sometimes it's desirable to bind several HTTP methods to the same web handler. For *v1* router it can be solved by passing '*' as HTTP method. Class based views require '*' method also usually. Implementation -------------- The change introduces **resource** as first class citizen:: resource = router.add_resource('/path/{to}', name='name') *Resource* has a **path** (dynamic or constant) and optional **name**. The name is **unique** in router context. *Resource* has **routes**. *Route* corresponds to *HTTP method* and :term:`web-handler` for the method:: route = resource.add_route('GET', handler) User still may use wildcard for accepting all HTTP methods (maybe we will add something like ``resource.add_wildcard(handler)`` later). Since **names** belongs to **resources** now ``app.router['name']`` returns a **resource** instance instead of :class:`aiohttp.web.Route`. **resource** has ``.url()`` method, so ``app.router['name'].url(parts={'a': 'b'}, query={'arg': 'param'})`` still works as usual. The change allows to rewrite static file handling and implement nested applications as well. Decoupling of *HTTP location* and *HTTP method* makes life easier. Backward compatibility ---------------------- The refactoring is 99% compatible with previous implementation. 99% means all example and the most of current code works without modifications but we have subtle API backward incompatibles. ``app.router['name']`` returns a :class:`aiohttp.web.BaseResource` instance instead of :class:`aiohttp.web.Route` but resource has the same ``resource.url(...)`` most useful method, so end user should feel no difference. ``route.match(...)`` is **not** supported anymore, use :meth:`aiohttp.web.AbstractResource.resolve` instead. ``app.router.add_route(method, path, handler, name='name')`` now is just shortcut for:: resource = app.router.add_resource(path, name=name) route = resource.add_route(method, handler) return route ``app.router.register_route(...)`` is still supported, it creates :class:`aiohttp.web.ResourceAdapter` for every call (but it's deprecated now). .. disqus:: :title: aiohttp router refactoring notes aiohttp-1.2.0/docs/contributing.rst0000664000175000017500000000017213025134363020217 0ustar travistravis00000000000000.. _aiohttp-contributing: .. include:: ../CONTRIBUTING.rst .. disqus:: :title: instructions for aiohttp contributors aiohttp-1.2.0/docs/aiohttp-icon.ico0000664000175000017500000000627613025134363020063 0ustar travistravis00000000000000  ( @vsIGXGSA\UGE^JN_lJG[V_U>:EBTDUgofU98yxPI@ALXAUol>@@oMHC84TaHVkoBNHNvZHA>?[fLS]\ORLRp[NSUIoN7CVbufSJ;YQKah__T5HaXk[]mS^B{Jkg_~=<^Y>NhBLQXNVeH>GOHcOXQMH_DAKtjdH^I67>45QiZP>I\7>63JgUY=j`b[dR@gvcGOcHKC8WTakLf_\seID86?CAUsSNn}phJfl\dkUnuD=53LKHRh}al[]hUkvDOHBBDIIFFKRtvMNDv.>vzHLW\>CD09Dp__bbaalmM@:WOB9=]ej[GE=27obb``_^]MrHDI4ZrdSJ?92=drB;gBCA=Q`@=ADFEQTDgNNACYO>AEXpX7=?Hj}?aiohttp-1.2.0/docs/client_reference.rst0000664000175000017500000013552313025134363021015 0ustar travistravis00000000000000.. _aiohttp-client-reference: Client Reference ================ .. module:: aiohttp .. currentmodule:: aiohttp Client Session -------------- Client session is the recommended interface for making HTTP requests. Session encapsulates a *connection pool* (*connector* instance) and supports keepalives by default. Unless you are connecting to a large, unknown number of different servers over the lifetime of your application, it is suggested you use a single session for the lifetime of your application to benefit from connection pooling. Usage example:: import aiohttp import asyncio async def fetch(client): async with client.get('http://python.org') as resp: assert resp.status == 200 return await resp.text() async def main(loop): async with aiohttp.ClientSession(loop=loop) as client: html = await fetch(client) print(html) loop = asyncio.get_event_loop() loop.run_until_complete(main(loop)) .. versionadded:: 0.17 The client session supports the context manager protocol for self closing. .. class:: ClientSession(*, connector=None, loop=None, cookies=None, \ headers=None, skip_auto_headers=None, \ auth=None, \ version=aiohttp.HttpVersion11, \ cookie_jar=None) The class for creating client sessions and making requests. :param aiohttp.connector.BaseConnector connector: BaseConnector sub-class instance to support connection pooling. :param loop: :ref:`event loop` used for processing HTTP requests. If *loop* is ``None`` the constructor borrows it from *connector* if specified. :func:`asyncio.get_event_loop` is used for getting default event loop otherwise. :param dict cookies: Cookies to send with the request (optional) :param headers: HTTP Headers to send with the request (optional). May be either *iterable of key-value pairs* or :class:`~collections.abc.Mapping` (e.g. :class:`dict`, :class:`~aiohttp.CIMultiDict`). :param skip_auto_headers: set of headers for which autogeneration should be skipped. *aiohttp* autogenerates headers like ``User-Agent`` or ``Content-Type`` if these headers are not explicitly passed. Using ``skip_auto_headers`` parameter allows to skip that generation. Note that ``Content-Length`` autogeneration can't be skipped. Iterable of :class:`str` or :class:`~aiohttp.upstr` (optional) :param aiohttp.BasicAuth auth: an object that represents HTTP Basic Authorization (optional) :param version: supported HTTP version, ``HTTP 1.1`` by default. .. versionadded:: 0.21 :param cookie_jar: Cookie Jar, :class:`AbstractCookieJar` instance. By default every session instance has own private cookie jar for automatic cookies processing but user may redefine this behavior by providing own jar implementation. One example is not processing cookies at all when working in proxy mode. .. versionadded:: 0.22 .. versionchanged:: 1.0 ``.cookies`` attribute was dropped. Use :attr:`cookie_jar` instead. .. attribute:: closed ``True`` if the session has been closed, ``False`` otherwise. A read-only property. .. attribute:: connector :class:`aiohttp.connector.BaseConnector` derived instance used for the session. A read-only property. .. attribute:: cookie_jar The session cookies, :class:`~aiohttp.AbstractCookieJar` instance. Gives access to cookie jar's content and modifiers. A read-only property. .. versionadded:: 1.0 .. attribute:: loop A loop instance used for session creation. A read-only property. .. comethod:: request(method, url, *, params=None, data=None,\ headers=None, skip_auto_headers=None, \ auth=None, allow_redirects=True,\ max_redirects=10, encoding='utf-8',\ version=HttpVersion(major=1, minor=1),\ compress=None, chunked=None, expect100=False,\ read_until_eof=True,\ proxy=None, proxy_auth=None,\ timeout=5*60) :async-with: :coroutine: Performs an asynchronous HTTP request. Returns a response object. :param str method: HTTP method :param url: Request URL, :class:`str` or :class:`~yarl.URL`. :param params: Mapping, iterable of tuple of *key*/*value* pairs or string to be sent as parameters in the query string of the new request. Ignored for subsequent redirected requests (optional) Allowed values are: - :class:`collections.abc.Mapping` e.g. :class:`dict`, :class:`aiohttp.MultiDict` or :class:`aiohttp.MultiDictProxy` - :class:`collections.abc.Iterable` e.g. :class:`tuple` or :class:`list` - :class:`str` with preferably url-encoded content (**Warning:** content will not be encoded by *aiohttp*) :param data: Dictionary, bytes, or file-like object to send in the body of the request (optional) :param dict headers: HTTP Headers to send with the request (optional) :param skip_auto_headers: set of headers for which autogeneration should be skipped. *aiohttp* autogenerates headers like ``User-Agent`` or ``Content-Type`` if these headers are not explicitly passed. Using ``skip_auto_headers`` parameter allows to skip that generation. Iterable of :class:`str` or :class:`~aiohttp.upstr` (optional) :param aiohttp.BasicAuth auth: an object that represents HTTP Basic Authorization (optional) :param bool allow_redirects: If set to ``False``, do not follow redirects. ``True`` by default (optional). :param aiohttp.protocol.HttpVersion version: Request HTTP version (optional) :param bool compress: Set to ``True`` if request has to be compressed with deflate encoding. ``None`` by default (optional). :param int chunked: Set to chunk size for chunked transfer encoding. ``None`` by default (optional). :param bool expect100: Expect 100-continue response from server. ``False`` by default (optional). :param bool read_until_eof: Read response until EOF if response does not have Content-Length header. ``True`` by default (optional). :param proxy: Proxy URL, :class:`str` or :class:`~yarl.URL` (optional) :param aiohttp.BasicAuth proxy_auth: an object that represents proxy HTTP Basic Authorization (optional) :param int timeout: a timeout for IO operations, 5min by default. Use ``None`` or ``0`` to disable timeout checks. :return ClientResponse: a :class:`client response ` object. .. versionadded:: 1.0 Added ``proxy`` and ``proxy_auth`` parameters. Added ``timeout`` parameter. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. comethod:: get(url, *, allow_redirects=True, **kwargs) :async-with: :coroutine: Perform a ``GET`` request. In order to modify inner :meth:`request` parameters, provide `kwargs`. :param url: Request URL, :class:`str` or :class:`~yarl.URL` :param bool allow_redirects: If set to ``False``, do not follow redirects. ``True`` by default (optional). :return ClientResponse: a :class:`client response ` object. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. comethod:: post(url, *, data=None, **kwargs) :async-with: :coroutine: Perform a ``POST`` request. In order to modify inner :meth:`request` parameters, provide `kwargs`. :param url: Request URL, :class:`str` or :class:`~yarl.URL` :param data: Dictionary, bytes, or file-like object to send in the body of the request (optional) :return ClientResponse: a :class:`client response ` object. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. comethod:: put(url, *, data=None, **kwargs) :async-with: :coroutine: Perform a ``PUT`` request. In order to modify inner :meth:`request` parameters, provide `kwargs`. :param url: Request URL, :class:`str` or :class:`~yarl.URL` :param data: Dictionary, bytes, or file-like object to send in the body of the request (optional) :return ClientResponse: a :class:`client response ` object. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. comethod:: delete(url, **kwargs) :async-with: :coroutine: Perform a ``DELETE`` request. In order to modify inner :meth:`request` parameters, provide `kwargs`. :param url: Request URL, :class:`str` or :class:`~yarl.URL` :return ClientResponse: a :class:`client response ` object. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. comethod:: head(url, *, allow_redirects=False, **kwargs) :async-with: :coroutine: Perform a ``HEAD`` request. In order to modify inner :meth:`request` parameters, provide `kwargs`. :param url: Request URL, :class:`str` or :class:`~yarl.URL` :param bool allow_redirects: If set to ``False``, do not follow redirects. ``False`` by default (optional). :return ClientResponse: a :class:`client response ` object. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. comethod:: options(url, *, allow_redirects=True, **kwargs) :async-with: :coroutine: Perform an ``OPTIONS`` request. In order to modify inner :meth:`request` parameters, provide `kwargs`. :param url: Request URL, :class:`str` or :class:`~yarl.URL` :param bool allow_redirects: If set to ``False``, do not follow redirects. ``True`` by default (optional). :return ClientResponse: a :class:`client response ` object. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. comethod:: patch(url, *, data=None, **kwargs) :async-with: :coroutine: Perform a ``PATCH`` request. In order to modify inner :meth:`request` parameters, provide `kwargs`. :param url: Request URL, :class:`str` or :class:`~yarl.URL` :param data: Dictionary, bytes, or file-like object to send in the body of the request (optional) :return ClientResponse: a :class:`client response ` object. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. comethod:: ws_connect(url, *, protocols=(), timeout=10.0,\ auth=None,\ autoclose=True,\ autoping=True,\ origin=None, \ proxy=None, proxy_auth=None) :async-with: :coroutine: Create a websocket connection. Returns a :class:`ClientWebSocketResponse` object. :param url: Websocket server url, :class:`str` or :class:`~yarl.URL` :param tuple protocols: Websocket protocols :param float timeout: Timeout for websocket read. 10 seconds by default :param aiohttp.BasicAuth auth: an object that represents HTTP Basic Authorization (optional) :param bool autoclose: Automatically close websocket connection on close message from server. If `autoclose` is False them close procedure has to be handled manually :param bool autoping: automatically send `pong` on `ping` message from server :param str origin: Origin header to send to server :param str proxy: Proxy URL, :class:`str` or :class:`~yarl.URL` (optional) :param aiohttp.BasicAuth proxy_auth: an object that represents proxy HTTP Basic Authorization (optional) .. versionadded:: 0.16 Add :meth:`ws_connect`. .. versionadded:: 0.18 Add *auth* parameter. .. versionadded:: 0.19 Add *origin* parameter. .. versionadded:: 1.0 Added ``proxy`` and ``proxy_auth`` parameters. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. comethod:: close() Close underlying connector. Release all acquired resources. .. versionchanged:: 0.21 The method is converted into coroutine (but technically returns a future for keeping backward compatibility during transition period). .. method:: detach() Detach connector from session without closing the former. Session is switched to closed state anyway. Basic API --------- While we encourage :class:`ClientSession` usage we also provide simple coroutines for making HTTP requests. Basic API is good for performing simple HTTP requests without keepaliving, cookies and complex connection stuff like properly configured SSL certification chaining. .. coroutinefunction:: request(method, url, *, params=None, data=None, \ headers=None, cookies=None, auth=None, \ allow_redirects=True, max_redirects=10, \ encoding='utf-8', \ version=HttpVersion(major=1, minor=1), \ compress=None, chunked=None, expect100=False, \ connector=None, loop=None,\ read_until_eof=True) Perform an asynchronous HTTP request. Return a response object (:class:`ClientResponse` or derived from). :param str method: HTTP method :param url: Requested URL, :class:`str` or :class:`~yarl.URL` :param dict params: Parameters to be sent in the query string of the new request (optional) :param data: Dictionary, bytes, or file-like object to send in the body of the request (optional) :param dict headers: HTTP Headers to send with the request (optional) :param dict cookies: Cookies to send with the request (optional) :param aiohttp.BasicAuth auth: an object that represents HTTP Basic Authorization (optional) :param bool allow_redirects: If set to ``False``, do not follow redirects. ``True`` by default (optional). :param aiohttp.protocol.HttpVersion version: Request HTTP version (optional) :param bool compress: Set to ``True`` if request has to be compressed with deflate encoding. ``False`` instructs aiohttp to not compress data even if the Content-Encoding header is set. Use it when sending pre-compressed data. ``None`` by default (optional). :param int chunked: Set to chunk size for chunked transfer encoding. ``None`` by default (optional). :param bool expect100: Expect 100-continue response from server. ``False`` by default (optional). :param aiohttp.connector.BaseConnector connector: BaseConnector sub-class instance to support connection pooling. :param bool read_until_eof: Read response until EOF if response does not have Content-Length header. ``True`` by default (optional). :param loop: :ref:`event loop` used for processing HTTP requests. If param is ``None``, :func:`asyncio.get_event_loop` is used for getting default event loop, but we strongly recommend to use explicit loops everywhere. (optional) :return ClientResponse: a :class:`client response ` object. Usage:: import aiohttp async def fetch(): async with aiohttp.request('GET', 'http://python.org/') as resp: assert resp.status == 200 print(await resp.text()) .. deprecated:: 0.21 Use :meth:`ClientSession.request`. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. coroutinefunction:: get(url, **kwargs) Perform a GET request. :param url: Requested URL, :class:`str` or :class:`~yarl.URL`. :param \*\*kwargs: Optional arguments that :func:`request` takes. :return: :class:`ClientResponse` or derived from .. deprecated:: 0.21 Use :meth:`ClientSession.get`. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. coroutinefunction:: options(url, **kwargs) Perform an OPTIONS request. :param url: Requested URL, :class:`str` or :class:`~yarl.URL`. :param \*\*kwargs: Optional arguments that :func:`request` takes. :return: :class:`ClientResponse` or derived from .. deprecated:: 0.21 Use :meth:`ClientSession.options`. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. coroutinefunction:: head(url, **kwargs) Perform a HEAD request. :param url: Requested URL, :class:`str` or :class:`~yarl.URL`. :param \*\*kwargs: Optional arguments that :func:`request` takes. :return: :class:`ClientResponse` or derived from .. deprecated:: 0.21 Use :meth:`ClientSession.head`. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. coroutinefunction:: delete(url, **kwargs) Perform a DELETE request. :param url: Requested URL, :class:`str` or :class:`~yarl.URL`. :param \*\*kwargs: Optional arguments that :func:`request` takes. :return: :class:`ClientResponse` or derived from .. deprecated:: 0.21 Use :meth:`ClientSession.delete`. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. coroutinefunction:: post(url, *, data=None, **kwargs) Perform a POST request. :param url: Requested URL, :class:`str` or :class:`~yarl.URL`. :param \*\*kwargs: Optional arguments that :func:`request` takes. :return: :class:`ClientResponse` or derived from .. deprecated:: 0.21 Use :meth:`ClientSession.post`. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. coroutinefunction:: put(url, *, data=None, **kwargs) Perform a PUT request. :param url: Requested URL, :class:`str` or :class:`~yarl.URL`. :param \*\*kwargs: Optional arguments that :func:`request` takes. :return: :class:`ClientResponse` or derived from .. deprecated:: 0.21 Use :meth:`ClientSession.put`. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. coroutinefunction:: patch(url, *, data=None, **kwargs) Perform a PATCH request. :param url: Requested URL, :class:`str` or :class:`~yarl.URL`. :param \*\*kwargs: Optional arguments that :func:`request` takes. :return: :class:`ClientResponse` or derived from .. deprecated:: 0.21 Use :meth:`ClientSession.patch`. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. coroutinefunction:: ws_connect(url, *, protocols=(), \ timeout=10.0, connector=None, auth=None,\ autoclose=True, autoping=True, loop=None,\ origin=None, headers=None) This function creates a websocket connection, checks the response and returns a :class:`ClientWebSocketResponse` object. In case of failure it may raise a :exc:`~aiohttp.errors.WSServerHandshakeError` exception. :param url: Websocket server url, :class:`str` or :class:`~yarl.URL` :param tuple protocols: Websocket protocols :param float timeout: Timeout for websocket read. 10 seconds by default :param obj connector: object :class:`TCPConnector` :param bool autoclose: Automatically close websocket connection on close message from server. If `autoclose` is False them close procedure has to be handled manually :param bool autoping: Automatically send `pong` on `ping` message from server :param aiohttp.helpers.BasicAuth auth: BasicAuth named tuple that represents HTTP Basic Authorization (optional) :param loop: :ref:`event loop` used for processing HTTP requests. If param is ``None`` :func:`asyncio.get_event_loop` used for getting default event loop, but we strongly recommend to use explicit loops everywhere. :param str origin: Origin header to send to server :param headers: :class:`dict`, :class:`CIMultiDict` or :class:`CIMultiDictProxy` for providing additional headers for websocket handshake request. .. versionadded:: 0.18 Add *auth* parameter. .. versionadded:: 0.19 Add *origin* parameter. .. versionadded:: 0.20 Add *headers* parameter. .. deprecated:: 0.21 Use :meth:`ClientSession.ws_connect`. .. versionchanged:: 1.1 URLs may be either :class:`str` or :class:`~yarl.URL` .. _aiohttp-client-reference-connectors: Connectors ---------- Connectors are transports for aiohttp client API. There are standard connectors: 1. :class:`TCPConnector` for regular *TCP sockets* (both *HTTP* and *HTTPS* schemes supported). 2. :class:`ProxyConnector` for connecting via HTTP proxy (deprecated). 3. :class:`UnixConnector` for connecting via UNIX socket (it's used mostly for testing purposes). All connector classes should be derived from :class:`BaseConnector`. By default all *connectors* except :class:`ProxyConnector` support *keep-alive connections* (behavior is controlled by *force_close* constructor's parameter). BaseConnector ^^^^^^^^^^^^^ .. class:: BaseConnector(*, conn_timeout=None, keepalive_timeout=30, \ limit=20, \ force_close=False, loop=None) Base class for all connectors. :param float conn_timeout: timeout for connection establishing (optional). Values ``0`` or ``None`` mean no timeout. :param float keepalive_timeout: timeout for connection reusing after releasing (optional). Values ``0``. For disabling *keep-alive* feature use ``force_close=True`` flag. :param int limit: limit for simultaneous connections to the same endpoint. Endpoints are the same if they are have equal ``(host, port, is_ssl)`` triple. If *limit* is ``None`` the connector has no limit. :param bool force_close: do close underlying sockets after connection releasing (optional). :param loop: :ref:`event loop` used for handling connections. If param is ``None``, :func:`asyncio.get_event_loop` is used for getting default event loop, but we strongly recommend to use explicit loops everywhere. (optional) .. versionchanged:: 1.0 ``limit`` changed from unlimited (``None``) to 20. Expect a max of up to 20 connections to the same endpoint, if it is not specified. For limitless connections, pass `None` explicitly. .. attribute:: closed Read-only property, ``True`` if connector is closed. .. attribute:: force_close Read-only property, ``True`` if connector should ultimately close connections on releasing. .. versionadded:: 0.16 .. attribute:: limit The limit for simultaneous connections to the same endpoint. Endpoints are the same if they are have equal ``(host, port, is_ssl)`` triple. If *limit* is ``None`` the connector has no limit (default). Read-only property. .. versionadded:: 0.16 .. comethod:: close() Close all opened connections. .. versionchanged:: 0.21 The method is converted into coroutine (but technically returns a future for keeping backward compatibility during transition period). .. comethod:: connect(request) Get a free connection from pool or create new one if connection is absent in the pool. The call may be paused if :attr:`limit` is exhausted until used connections returns to pool. :param aiohttp.client.ClientRequest request: request object which is connection initiator. :return: :class:`Connection` object. .. comethod:: _create_connection(req) Abstract method for actual connection establishing, should be overridden in subclasses. TCPConnector ^^^^^^^^^^^^ .. class:: TCPConnector(*, verify_ssl=True, fingerprint=None,\ use_dns_cache=True, \ family=0, \ ssl_context=None, conn_timeout=None, \ keepalive_timeout=30, limit=None, \ force_close=False, loop=None, local_addr=None, resolver=None) Connector for working with *HTTP* and *HTTPS* via *TCP* sockets. The most common transport. When you don't know what connector type to use, use a :class:`TCPConnector` instance. :class:`TCPConnector` inherits from :class:`BaseConnector`. Constructor accepts all parameters suitable for :class:`BaseConnector` plus several TCP-specific ones: :param bool verify_ssl: Perform SSL certificate validation for *HTTPS* requests (enabled by default). May be disabled to skip validation for sites with invalid certificates. :param bytes fingerprint: Pass the SHA256 digest of the expected certificate in DER format to verify that the certificate the server presents matches. Useful for `certificate pinning `_. Note: use of MD5 or SHA1 digests is insecure and deprecated. .. versionadded:: 0.16 :param bool use_dns_cache: use internal cache for DNS lookups, ``True`` by default. Enabling an option *may* speedup connection establishing a bit but may introduce some *side effects* also. .. versionadded:: 0.17 .. versionchanged:: 1.0 The default is changed to ``True`` :param aiohttp.abc.AbstractResolver resolver: Custom resolver instance to use. ``aiohttp.DefaultResolver`` by default (asynchronous if ``aiodns>=1.1`` is installed). Custom resolvers allow to resolve hostnames differently than the way the host is configured. .. versionadded:: 0.22 .. versionchanged:: 1.0 The resolver is ``aiohttp.AsyncResolver`` now if :term:`aiodns` is installed. :param bool resolve: alias for *use_dns_cache* parameter. .. deprecated:: 0.17 :param int family: TCP socket family, both IPv4 and IPv6 by default. For *IPv4* only use :const:`socket.AF_INET`, for *IPv6* only -- :const:`socket.AF_INET6`. .. versionchanged:: 0.18 *family* is `0` by default, that means both IPv4 and IPv6 are accepted. To specify only concrete version please pass :const:`socket.AF_INET` or :const:`socket.AF_INET6` explicitly. :param ssl.SSLContext ssl_context: ssl context used for processing *HTTPS* requests (optional). *ssl_context* may be used for configuring certification authority channel, supported SSL options etc. :param tuple local_addr: tuple of ``(local_host, local_port)`` used to bind socket locally if specified. .. versionadded:: 0.21 .. attribute:: verify_ssl Check *ssl certifications* if ``True``. Read-only :class:`bool` property. .. attribute:: ssl_context :class:`ssl.SSLContext` instance for *https* requests, read-only property. .. attribute:: family *TCP* socket family e.g. :const:`socket.AF_INET` or :const:`socket.AF_INET6` Read-only property. .. attribute:: dns_cache Use quick lookup in internal *DNS* cache for host names if ``True``. Read-only :class:`bool` property. .. versionadded:: 0.17 .. attribute:: resolve Alias for :attr:`dns_cache`. .. deprecated:: 0.17 .. attribute:: cached_hosts The cache of resolved hosts if :attr:`dns_cache` is enabled. Read-only :class:`types.MappingProxyType` property. .. versionadded:: 0.17 .. attribute:: resolved_hosts Alias for :attr:`cached_hosts` .. deprecated:: 0.17 .. attribute:: fingerprint MD5, SHA1, or SHA256 hash of the expected certificate in DER format, or ``None`` if no certificate fingerprint check required. Read-only :class:`bytes` property. .. versionadded:: 0.16 .. method:: clear_dns_cache(self, host=None, port=None) Clear internal *DNS* cache. Remove specific entry if both *host* and *port* are specified, clear all cache otherwise. .. versionadded:: 0.17 .. method:: clear_resolved_hosts(self, host=None, port=None) Alias for :meth:`clear_dns_cache`. .. deprecated:: 0.17 ProxyConnector ^^^^^^^^^^^^^^ .. class:: ProxyConnector(proxy, *, proxy_auth=None, \ conn_timeout=None, \ keepalive_timeout=30, limit=None, \ force_close=True, loop=None) HTTP Proxy connector. Use :class:`ProxyConnector` for sending *HTTP/HTTPS* requests through *HTTP proxy*. :class:`ProxyConnector` is inherited from :class:`TCPConnector`. .. deprecated:: 1.0 Use :meth:`ClientSession.request` with :attr:`proxy` and :attr:`proxy_auth` parameters. Usage:: conn = ProxyConnector(proxy="http://some.proxy.com") session = ClientSession(connector=conn) async with session.get('http://python.org') as resp: assert resp.status == 200 Constructor accepts all parameters suitable for :class:`TCPConnector` plus several proxy-specific ones: :param str proxy: URL for proxy :class:`str` or :class:`~yarl.URL`, e.g. ``URL("http://some.proxy.com")``. :param aiohttp.BasicAuth proxy_auth: basic authentication info used for proxies with authorization. .. note:: :class:`ProxyConnector` in opposite to all other connectors **doesn't** support *keep-alives* by default (:attr:`force_close` is ``True``). .. versionchanged:: 0.16 *force_close* parameter changed to ``True`` by default. .. attribute:: proxy Proxy *URL*, read-only :class:`~yarl.URL` property. .. versionchanged:: 1.1 The attribute type was changed from :class:`str` to :class:`~yarl.URL`. .. attribute:: proxy_auth Proxy authentication info, read-only :class:`BasicAuth` property or ``None`` for proxy without authentication. .. versionadded:: 0.16 UnixConnector ^^^^^^^^^^^^^ .. class:: UnixConnector(path, *, \ conn_timeout=None, \ keepalive_timeout=30, limit=None, \ force_close=False, loop=None) Unix socket connector. Use :class:`ProxyConnector` for sending *HTTP/HTTPS* requests through *UNIX Sockets* as underlying transport. UNIX sockets are handy for writing tests and making very fast connections between processes on the same host. :class:`UnixConnector` is inherited from :class:`BaseConnector`. Usage:: conn = UnixConnector(path='/path/to/socket') session = ClientSession(connector=conn) async with session.get('http://python.org') as resp: ... Constructor accepts all parameters suitable for :class:`BaseConnector` plus UNIX-specific one: :param str path: Unix socket path .. attribute:: path Path to *UNIX socket*, read-only :class:`str` property. Connection ^^^^^^^^^^ .. class:: Connection Encapsulates single connection in connector object. End user should never create :class:`Connection` instances manually but get it by :meth:`BaseConnector.connect` coroutine. .. attribute:: closed :class:`bool` read-only property, ``True`` if connection was closed, released or detached. .. attribute:: loop Event loop used for connection .. method:: close() Close connection with forcibly closing underlying socket. .. method:: release() Release connection back to connector. Underlying socket is not closed, the connection may be reused later if timeout (30 seconds by default) for connection was not expired. .. method:: detach() Detach underlying socket from connection. Underlying socket is not closed, next :meth:`close` or :meth:`release` calls don't return socket to free pool. Response object --------------- .. class:: ClientResponse Client response returned be :meth:`ClientSession.request` and family. User never creates the instance of ClientResponse class but gets it from API calls. :class:`ClientResponse` supports async context manager protocol, e.g.:: resp = await client_session.get(url) async with resp: assert resp.status == 200 After exiting from ``async with`` block response object will be *released* (see :meth:`release` coroutine). .. versionadded:: 0.18 Support for ``async with``. .. attribute:: version Response's version, :class:`HttpVersion` instance. .. attribute:: status HTTP status code of response (:class:`int`), e.g. ``200``. .. attribute:: reason HTTP status reason of response (:class:`str`), e.g. ``"OK"``. .. attribute:: method Request's method (:class:`str`). .. attribute:: url URL of request (:class:`str`). .. deprecated:: 1.1 .. attribute:: url_obj URL of request (:class:`~yarl.URL`). .. versionadded:: 1.1 .. attribute:: connection :class:`Connection` used for handling response. .. attribute:: content Payload stream, contains response's BODY (:class:`StreamReader`). Reading from the stream raises :exc:`aiohttp.ClientDisconnectedError` if the response object is closed before read calls. .. attribute:: cookies HTTP cookies of response (*Set-Cookie* HTTP header, :class:`~http.cookies.SimpleCookie`). .. attribute:: headers A case-insensitive multidict proxy with HTTP headers of response, :class:`CIMultiDictProxy`. .. attribute:: raw_headers HTTP headers of response as unconverted bytes, a sequence of ``(key, value)`` pairs. .. attribute:: content_type Read-only property with *content* part of *Content-Type* header. .. note:: Returns value is ``'application/octet-stream'`` if no Content-Type header present in HTTP headers according to :rfc:`2616`. To make sure Content-Type header is not present in the server reply, use :attr:`headers` or :attr:`raw_headers`, e.g. ``'CONTENT-TYPE' not in resp.headers``. .. attribute:: charset Read-only property that specifies the *encoding* for the request's BODY. The value is parsed from the *Content-Type* HTTP header. Returns :class:`str` like ``'utf-8'`` or ``None`` if no *Content-Type* header present in HTTP headers or it has no charset information. .. attribute:: history A :class:`~collections.abc.Sequence` of :class:`ClientResponse` objects of preceding requests if there were redirects, an empty sequence otherwise. .. method:: close() Close response and underlying connection. For :term:`keep-alive` support see :meth:`release`. .. comethod:: read() Read the whole response's body as :class:`bytes`. Close underlying connection if data reading gets an error, release connection otherwise. :return bytes: read *BODY*. .. seealso:: :meth:`close`, :meth:`release`. .. comethod:: release() Finish response processing, release underlying connection and return it into free connection pool for re-usage by next upcoming request. .. method:: raise_for_status() Raise an HttpProcessingError if the response status is 400 or higher. Do nothing for success responses (less than 400). .. comethod:: text(encoding=None) Read response's body and return decoded :class:`str` using specified *encoding* parameter. If *encoding* is ``None`` content encoding is autocalculated using :term:`cchardet` or :term:`chardet` as fallback if *cchardet* is not available. Close underlying connection if data reading gets an error, release connection otherwise. :param str encoding: text encoding used for *BODY* decoding, or ``None`` for encoding autodetection (default). :return str: decoded *BODY* .. comethod:: json(encoding=None, loads=json.loads) Read response's body as *JSON*, return :class:`dict` using specified *encoding* and *loader*. If *encoding* is ``None`` content encoding is autocalculated using :term:`cchardet` or :term:`chardet` as fallback if *cchardet* is not available. Close underlying connection if data reading gets an error, release connection otherwise. :param str encoding: text encoding used for *BODY* decoding, or ``None`` for encoding autodetection (default). :param callable loads: :func:`callable` used for loading *JSON* data, :func:`json.loads` by default. :return: *BODY* as *JSON* data parsed by *loads* parameter or ``None`` if *BODY* is empty or contains white-spaces only. ClientWebSocketResponse ----------------------- To connect to a websocket server :func:`aiohttp.ws_connect` or :meth:`aiohttp.ClientSession.ws_connect` coroutines should be used, do not create an instance of class :class:`ClientWebSocketResponse` manually. .. class:: ClientWebSocketResponse() Class for handling client-side websockets. .. attribute:: closed Read-only property, ``True`` if :meth:`close` has been called of :const:`~aiohttp.WSMsgType.CLOSE` message has been received from peer. .. attribute:: protocol Websocket *subprotocol* chosen after :meth:`start` call. May be ``None`` if server and client protocols are not overlapping. .. method:: exception() Returns exception if any occurs or returns None. .. method:: ping(message=b'') Send :const:`~aiohttp.WSMsgType.PING` to peer. :param message: optional payload of *ping* message, :class:`str` (converted to *UTF-8* encoded bytes) or :class:`bytes`. .. method:: send_str(data) Send *data* to peer as :const:`~aiohttp.WSMsgType.TEXT` message. :param str data: data to send. :raise TypeError: if data is not :class:`str` .. method:: send_bytes(data) Send *data* to peer as :const:`~aiohttp.WSMsgType.BINARY` message. :param data: data to send. :raise TypeError: if data is not :class:`bytes`, :class:`bytearray` or :class:`memoryview`. .. method:: send_json(data, *, dumps=json.loads) Send *data* to peer as JSON string. :param data: data to send. :param callable dumps: any :term:`callable` that accepts an object and returns a JSON string (:func:`json.dumps` by default). :raise RuntimeError: if connection is not started or closing :raise ValueError: if data is not serializable object :raise TypeError: if value returned by ``dumps(data)`` is not :class:`str` .. comethod:: close(*, code=1000, message=b'') A :ref:`coroutine` that initiates closing handshake by sending :const:`~aiohttp.WSMsgType.CLOSE` message. It waits for close response from server. It add timeout to `close()` call just wrap call with `asyncio.wait()` or `asyncio.wait_for()`. :param int code: closing code :param message: optional payload of *pong* message, :class:`str` (converted to *UTF-8* encoded bytes) or :class:`bytes`. .. comethod:: receive() A :ref:`coroutine` that waits upcoming *data* message from peer and returns it. The coroutine implicitly handles :const:`~aiohttp.WSMsgType.PING`, :const:`~aiohttp.WSMsgType.PONG` and :const:`~aiohttp.WSMsgType.CLOSE` without returning the message. It process *ping-pong game* and performs *closing handshake* internally. :return: :class:`~aiohttp.WSMessage`, `tp` is a type from :class:`~aiohttp.WSMsgType` enumeration. .. coroutinemethod:: receive_str() A :ref:`coroutine` that calls :meth:`receive` but also asserts the message type is :const:`~aiohttp.WSMsgType.TEXT`. :return str: peer's message content. :raise TypeError: if message is :const:`~aiohttp.WSMsgType.BINARY`. .. coroutinemethod:: receive_bytes() A :ref:`coroutine` that calls :meth:`receive` but also asserts the message type is :const:`~aiohttp.WSMsgType.BINARY`. :return bytes: peer's message content. :raise TypeError: if message is :const:`~aiohttp.WSMsgType.TEXT`. .. coroutinemethod:: receive_json(*, loads=json.loads) A :ref:`coroutine` that calls :meth:`receive_str` and loads the JSON string to a Python dict. :param callable loads: any :term:`callable` that accepts :class:`str` and returns :class:`dict` with parsed JSON (:func:`json.loads` by default). :return dict: loaded JSON content :raise TypeError: if message is :const:`~aiohttp.WSMsgType.BINARY`. :raise ValueError: if message is not valid JSON. Utilities --------- BasicAuth ^^^^^^^^^ .. class:: BasicAuth(login, password='', encoding='latin1') HTTP basic authentication helper. :param str login: login :param str password: password :param str encoding: encoding (`'latin1'` by default) Should be used for specifying authorization data in client API, e.g. *auth* parameter for :meth:`ClientSession.request`. .. classmethod:: decode(auth_header, encoding='latin1') Decode HTTP basic authentication credentials. :param str auth_header: The ``Authorization`` header to decode. :param str encoding: (optional) encoding ('latin1' by default) :return: decoded authentication data, :class:`BasicAuth`. .. method:: encode() Encode credentials into string suitable for ``Authorization`` header etc. :return: encoded authentication data, :class:`str`. CookieJar ^^^^^^^^^ .. class:: CookieJar(unsafe=False, loop=None) The cookie jar instance is available as :attr:`ClientSession.cookie_jar`. The jar contains :class:`~http.cookies.Morsel` items for storing internal cookie data. API provides a count of saved cookies:: len(session.cookie_jar) These cookies may be iterated over:: for cookie in session.cookie_jar: print(cookie.key) print(cookie["domain"]) The class implements :class:`collections.abc.Iterable`, :class:`collections.abc.Sized` and :class:`aiohttp.AbstractCookieJar` interfaces. Implements cookie storage adhering to RFC 6265. :param bool unsafe: (optional) Whether to accept cookies from IPs. :param bool loop: an :ref:`event loop` instance. See :class:`aiohttp.abc.AbstractCookieJar` .. method:: update_cookies(cookies, response_url=None) Update cookies returned by server in ``Set-Cookie`` header. :param cookies: a :class:`collections.abc.Mapping` (e.g. :class:`dict`, :class:`~http.cookies.SimpleCookie`) or *iterable* of *pairs* with cookies returned by server's response. :param str response_url: URL of response, ``None`` for *shared cookies*. Regular cookies are coupled with server's URL and are sent only to this server, shared ones are sent in every client request. .. method:: filter_cookies(request_url) Return jar's cookies acceptable for URL and available in ``Cookie`` header for sending client requests for given URL. :param str response_url: request's URL for which cookies are asked. :return: :class:`http.cookies.SimpleCookie` with filtered cookies for given URL. .. method:: save(file_path) Write a pickled representation of cookies into the file at provided path. :param file_path: Path to file where cookies will be serialized, :class:`str` or :class:`pathlib.Path` instance. .. method:: load(file_path) Load a pickled representation of cookies from the file at provided path. :param file_path: Path to file from where cookies will be imported, :class:`str` or :class:`pathlib.Path` instance. .. disqus:: :title: aiohttp client reference aiohttp-1.2.0/docs/_static/0000775000175000017500000000000013025135427016406 5ustar travistravis00000000000000aiohttp-1.2.0/docs/_static/aiohttp-icon-64x64.png0000664000175000017500000001765613025134363022320 0ustar travistravis00000000000000PNG  IHDR@@iqbKGD pHYs B(xtIME 1;IDATx͛i]uks=w|YI !! 2cvc:$TTWIꊡOIoᆨ^v5gϞݽs GV}"pu1Ƙ8_j>|ٳg+JO_} _׊}}}T*\./rE}bn|j̣Ǐ?Tj[3#Diz#lؿ%7nH LBZ =BM Cҏ ]C@ Wa]@$,Ce$3 !.#{m`h:!ijkϝ={{}9DO}S߾}dd7 gL9H4Px\NP|0 "0<+PBrEpk 0qe"?r<0>O<㏷ rzhM7N)ULj$I^#*DZ6gll[o۷ϼO>{^R=68yoT@b@ EӆtP݈TX<2 qI  JS *d*hQ:%rGFFvp }_ r~kJlxGh{UHq4._B.C_v ;o^l @)  EAYD  n{Q p###3 =3w4}>h=aeWijbZ >1\:"X X]H.Bq>[ uhمzh]^K/| P宻@ԩS~?\{\2{l!(_ tut3e$#p9oAku\XeY i Ibj-,@#tK~kmsqqyCpw|FDr7C^{\<iK`H`zEd`77$;KpQ?@y+]x7sלCm_#A#Ţ!lL%V\~.M?K&5‰}4N>RTV?~ȑc x衇׿/r|CwMo[x I[>M ao(.!WE//wIGv}ť]Z/CΦO\Z2~4'pW) *W5fp lyHD C8AǥmLs4&©#ްq_(.,l{0.3::?>u||W~wAW[c/36 #W i jC qg%+AeP\W?A $MCЅ^KhaXC] Q?sۭ@ge2jn Yp͕W^yp`ooUvqf,vR Wl=1s{qH4=8z`*DHFh~dtwMyH븠)nu 3;yz?D#8qc әGoiCVPILE7\5P.VVk{ @u``8Y|OB J#A*![.DzbO]W2@)Dž0׎ E8I@p6@er57b0 71k7qr\T8!jE~{sq 7lذX,4%gKglgyAQ×`OYkys:9M&|B I#Ç,ĬzJ&L l2uX~]# n=/ | w}5k(%^pe|/ݸjkg,zCΪ$ˈҸ 1o}xc`lU,b H}` mN,'EѶT iTTƉ/mMg P܋ug!Wx#-H7&7.{|11-$i XT{Iۋ!j1.@X7߈KS@jk5o 6n-"z+ (J|Xل~\&86Eo&|ͿR ؤ3)Dյz?.{ H%B=f%$nSjw@+0Wnܻ#.bhkQqt"DC:5a墋.f@4GQٙӜ' C*爓e(UvH0^CL냠eR^ 7zX cנ:0s鿐x?;wbNZj`fr\IijGѨIDj~D‰]8uRz ȇac-lgYQcT%/:6o I5*rCrXc4ˁpH!A(o-C˄A$PFw%^E=Hю1tWQLmʕҬrJ &ae:*|^vED%@ z4w;Hu*G%!x?XCzgN ɕ , C+<PBŘ)LBu6AAQ#c( iꋢ\Y\ Y%TaBA+.,HAE)鴂\/qҦt| H؏<2|%nUHZ|. EGۭeRIP9=[E:CrkA"b^1&(%y\x.0 S"JCu#.=o*IW] ABuBRn7DyJQ 퓘qA E6*ŵ;w@;\<rٓ)pv;]CeDpIv9Ng |\K>u~ #iu~wOt…ւZVuajc\ 1 |9xA>TiV|g?wW]g~0RxgUݳgPA\oQLC~w{B2 Ȗ.A|SlV.<&@ 5 #HF$PAPR(I3`UPu4Gx.8?sHq=vf̍SJ4c-],$~AB&似]ـ\ 蝿5t+ng4Kf B gL4>G/B\4TF͇U8(n"Mtd^RcLzZbooAK!P8q;P? E$@:C(![-e8jXadx/ [%H6iӗOgw5(:)~$X¥tt7x}/87xcSm뉹+ @.Pa$LM,㳉 0D*4>hMz^թ]ҳģ}I2{?ԧ>w?8g|Lh4_?p*=oiKZ|52-_D}q7U{*!mc"so3RyjVb_,5^@+(_P:daa۷=OA,m/#׷4M_z>ܽgjJ)toƇN8yk-m3~ ]U'*x.|b!Bt|QZ t 8y$4 N֬khw)Z=}׮??vtLZ:v۟LL:@ec#'H?^YeɮWTmWR=?vil5eKk ]p-7KۺugXD̏5(944&&&/K~Rta4G:Fcj'Hyؙl"!J[|9_y3~D.SGH%$nȄ^SJaf8дP~sfii? ԣ(J4Fe[7on"a[{5GM?zA$ˤj(:ꁤv^ϊQ9?>88 `aݺu~iQ555o{ccc 4gh} J)U8iCPF*!˕ށz\z&+"RވۏTCagƒ2+\1omذׁ͛'Ow;v9t|< Ǿ=tT8TL>ǧHa;/L +^X> ;E<84t}\H) :H[ЙHwKHŰ_ E}%:\D#г``/ֺho~Ō]$o桡՞݅B0ީfqKfl\& aUХܗ۝sss?^:~c_W_5p'?Mwy֭ۻ\.o-KBt\{l+5q܏"4?u!x!khZ~/H$X4߰IENDB`aiohttp-1.2.0/docs/_static/aiohttp-icon-96x96.png0000664000175000017500000011332413025134363022317 0ustar travistravis00000000000000PNG  IHDR``{gAMA asRGB cHRMz&u0`:pQ<bKGD X pHYsHHFk>IDATxwi"3 9$(I "D sDL DPQAP,9gI;u=yu {Vתu׽_9qUWUvݮ{[լ3:Ut4UTnoWuRwT-uKRUVVVU-R???W5WU&n&7Mzy:OU5_UըQV=KJ lcۀwywA/ҋ"%Diff`֛f="Sdf^3jBQntPJ)yy@5Q ppp(Q@`tԗ dlV+ v Y"Kjj5r!D9 (n]u9?ɟO5550Q5Q`5Y (k5 VXA <+Ar%WrA<ȍNLd"A{jO ըF1cHM`eff:Kg,'= V5U +++bwjn5ɒ,n&nR/;@ %*ԝ[-{kuTTTpN 3יk5 DH Mh/&6 t]`&f2xxx& r\"cpN 5h ))..Q (L/Wɫlw;^d/Aف!55FjS~M^eq`3_j s#@/Yg<,X}A޵>#|'5\D?vݠtO=:n=o@^ /Xg3ZVF0@C(G9 c<`w;#-pwww5j 7XC7CO/+n/LCWd.|io&?*ZU3AS@M睁PkG%^s``RMpeeVo V,K#GAN|o7߃Zn-$hhh<'r-rb... %%% d&3!,, sss@I3io m?6, C2|@2rזw}dAd} ~{hX%T{AN ='g4e#?ofL_w'u!eS00:_v̻-`}\ok` TZ / or?}܏܏܏ ''KR```cp; }\W\q,g92]uBb[b[bҐ sB$IE{GL ;CKG_xUwppV L`>!I{hNl6P]7@/;k*q45V?PȽfP(ENWƠ&UUNw^p wn WyJ[k7 Uٵ` 9ۀ\2Ī@*@mm-$&'&'&}}}=|VN+'y6_uT3L=1'[$[$[@!\1\1\d̒YG\Gg uA@Bkq7gM:•;GAK_! Ĭ$A*T{ukh&hm {/螴[L;=XKt>V.s YJcsʚ!}Yf6e9ʧx=Vޠ7 x'Npototo<?6,9^tnM.AALLLi  rԾ(~9IqkC @  =z?n,` a0gm6xxx?NNNNR]\B(e?CMfPOȘ\p*{F>~zI,b,r x+d_ ?i [PzĜ<HO$D94A+n e {ܔ$.^ͺvмoV9vM tZU !.h")Y_Y5JQ'PdS Gof?m ŷ~k"gT MZ7[zх`OV?]cݸwOaCCC!$ vN5AJ0R[ p<C!//φ5+P6۵S.Tt߮BÚם֘ߦ`PcKy !Vt]hf.~ Ip"* AOy{ƐƋ֕9k8pinv@oK=)U*B烕[eY٤Π5}?}oP>輏Д|ǀl^V@&-y QXhv痀K--ŋ~ Q:%Aڔ̑ {o靠m6=(, lt x9HD"H<!셽>>>XXX\ks`+X6dOhMj3y=Gm t32.Z;;Ȼ5w %ݑAb'?mk22 HHv  HDhқuR.aXx:3(T$>t:?SB }9kj=껁+1r?_/]î?,,,Nl/㽱Xo,ލ{xxҷoIV=Us}WG >= YFs,z& (՗&EkjUuIK[ʝ(poҊގ@Eho5=ܖ>熺vh`jQ#ۛ ȁ@GhamPZ׍^ L. *Z {@ +M;P?f%?|ݩȣߴSFs5ԳΏ_GUԵ̴A2@D$k=nզx/ZgBƳk^Hϵi\rRHC)S6Vsss\k]]] ѦѦѦ']3gG{NR&]l[h6|Z#y;, ILҕ֎x^rj) ֮:IG ].dWy;N=ºw[ |b rno>90귏LZ H+K(-^7̮okT- w./[J݀PD$&GW*Ĩ8n.Ǜ'̻YBA5xYU$, R 4}LHfe[ + vh0tdLjEAβg}0 PTo¿=Ӟi.R.(u''' Z-'{;wFoUNz(?ڞfzϷ_J fs=HJc˒A]3tV $l%~b piRC7.@6n58?Eˡ1 =84t.,j^ MJ.H6bKMRߛRgkDN ꚏRZ-A@ba!V`IEh7{,4aLׂ:խ5 YϟXwGPnԍ+2Lɰk+ӝc?._fff?#?BF*U%/= eĦo1ȘOY,L>6@992 tJ4 )gJߩy, 3d傖0 qƇvk]A .+2P8i /f٨*7A4$@\C!\@@>,9j A=R&NS1[1 TqcAi_8p~dr.J@ٚpꯟ3&>%WP4?K,3PK- --̜uc;s\s3fU: {cNKZemX_8{o <ϯg~-9gԢN;[ GITݻ(Ts>\ͨQ04}zA-_9?mQ:̀_~ ɗ [.+}I.ܧ/o}x(sI4Mʯd룛}T'G'Rr}4w,Hn?&@rCy'W,| hH+0D?ɹL]w9d6ί(p,I,͂&MJsss>|"'@.Y# 9ioCBPpi!CV0UPofl3ÝIV);(K]9P P+mxQZ#>T6d󊆁}׃X? Rt;NWZB/qxio|~do?]%J#e;mzSo\zr:`/WWB^(ThU &`ԃ@VN,7P-)]:OVCt45<31ZM5iP}@6^~X-M_KCڼyilp`ff### 9#9vgnmp =;auyZl@%W_Hˇ}v2L2xKte[|~zLgN d@U>R~ g]V2x8\+ HS+@[IOſ t96J d8T)=LW5Ee%˻$x?#(M4 = g/y=:D*.a ::hA[(2Zv7yvDZEZEZAththt(XVg"俾 M7:3tfL#xIA:BiU.=e`=U D< rRח{0gJ̻Js[Qܛo>9fzmأop~Hz|[ !wυk+~z;$.^0ċ$љ?/9+WS6mu*!y ]띳cE]:lB>DH @Y[66%!UrZz9ݲp$Է8/[GփFڃ@7ۥ_;AKeW// ĨM?4 wಢwv<fǑm뗂5>řiGv J\NF|333!i ,e)KP81KRA:Yi-m&}[]iCy,0,Mc//0*PML z=SY i/s< s1eӄdx,5ț [zx`^ٵyKbpA@.QJC5!m?/7m}sm=0l/"/E^⏺DDDEu}v]u1$Oޟ /n\åU7Bg}op+xݣc@PjɃ1^ v}YbB4_j Fyȑg3kQw5x(ӆ%'.2H"R m9=3/f_\T\q0Sﺪt>^ީU.AFT}JծL~: )MßA;;3AJWSzWO_D},'WMK6 ~n?q?zgyRtP:tR$`JJN¹8sEvpyG/5؊c+3K8X̒Vy=9s;/+LـavN#AN-v@>dFvNAU=v3;hv[F"rb'K4̕v&|cV'+'u>HC Xp2 7jLpA#*ܻ Ru!БeOs}=2-FeAC@ U핯Kh\yӚlz> ʀ 觵g C@ڱƄ $LR4tm0<KVI$kyPd:#i-!^:B=Hv|C/$Lݾ,0=Ů] Q(k`-[4?" 4@H% "ENmew]:Ӆ~I)cEZ,ѿpE-A] ^7$x(u!G]eI ;|%kve#!'@l++9`/~kA] orLg@ sn"tm( nX68Q8*kw&\Sx:7A|(sP6MWkU灩ycSo6e'[߅z, M77 p1pz~N>а:taN-mmgo1؍L}c1 gkA8ρ̒E} p>,kAS}egm>2hl&&&P|A@rNrNrɡ Ћ^w%%%'bp0 brǦvQ*>0!䱢OWy'ED`wVj35ɶRS:.u3VO,pP2-tNSzmOgNLMMwA`O'pN]|a&f"D~ oNߜ혵d_oPHim4>r# ns{2Y()SXs#6 HO`)e D7uڑmTWOTAuFb Zؘ~#yMפO?5R40gW^z;/iU:'98]+W v?$P/ =r胺GÁ97 OX@C 2t5d cs}6' 9pFvO 31 D5ӫL- T,HJKLOφFf2G/x6h?xE`lYq!܀ '_Ї>B%!cMƚ5tdӣ_%Oo޹d.ٟ?mm@Y_;XU&)a\@Y&N @ P7Iݤf@V1 ueu2@:Vt_td d9Go=/Jh. `G4n_ &o 9R1 AR*լ v*@cXpaE| k<Мs@$o"hƪ>U~ՍXy2zrt<~Ibxo7:[7g5<՝ fNg; #󧯋S:@^gӑ?&AI- MHk[ 5 %?YE]x&X${q8pag۳@W0%oVs A+ 5 5 5&1IcяuAy߁SPRP>K; ~ .HyF2&M=K8r5ə'A.񌊠^NZ!HZMZ$lze3klˋ=<4Ik`N{P7r֠IzZgKƚxt9`{U? %@P5 `n9n_kC; )g\!X<+ܧvx}10?C>p8D`Z,;?ï? | n8Z1`~'{1+WI5Hv8OlW'Lm {բ-5\{tp0>Pk{?;HHWx}~ 1O?u2`6QQQ'hpk}Wx~C!$''Cȕ+$t_rÑA;ƃ{KfB蒒o}- En(Ʀ)w RQy80癋@lw#L*O\AF'Ƽv>j:e3݉+ ̈X, F8Cĝc@-]r<=b݉Cz9(!T:5[|PJ}5ܿ0PH*U+L5e_/7rfSUЄ:zW!R @7m$^{zpzwS||J@n8q.ʲʀzh&u5~Ⱥ.i^u|0xz.Ώ~t~i.K$#)pf/A ֬ jd5=S@)L^a-3߃}RBYW|}PHn(\8`;===,K%$L$,7ݺ*n fYKsћ%t_* P3ËGl5@..t6 :7yVQwxؖYRݱ@[P7 CMyi%! #EJuR5M(mh$ZѠ.E{co l.`)?,-374jn(e6l~ùU=~[bUR8,[)WI/qEO^KӦ'冶duogZ v'Jp@f- ȰV hd,ꄖGPQ;?-z`#*<V#Pg(#ݑH...ǡПfnf+ 'cҳҳB;Rvx유 ,4S > wI-=kf|w3!wW):' (i&ۤ=ȣ[\XxtyAvrMy!d**r@5z+X}9`uuOy46DHZ[?~1X+Vwfk\Ό7pi3+JX,0겻 _``7_P 쥁 $jc/d ogͦN"yPYT2:7 c=4/ߏrW4fA3͵ޯ8Ci?ˌk=/*.~L $1v13O%RlXlwJ. w]ު55 cccOJ9g9g9g;rłopg3 p~ d;qYȂqx|MkhO$1k4! ]Xc@kn h},xf^Hw*ӧRK<}YP!^wJt>ӽ :2mQB,r%w+x{{zϡЉ,Лɛ`ifx+J i ع;3[ɽ TVMw2 ƬyEą 0i+iYckǙozz?+ |o|'x&~@DyԞ J &b{h<ѭTAS!MSKz֢kf ? X~4WV%Jā_)v'3k DeӃ@R1:Y@Hc D@H22Fhs MGC,,q : zIٍnp$6EZvnbLHR0{C?w38$8$8 /s\Y?9@+xk5`>4!P7P7P/_~Eڼ.ZրR)Xe w2I*mZǁ3}EPjg?TVn ;4EeҤuH x]$6~%gs1h>,+ N| $(˷ !yC Adh@ tdwo r}j<\+@[9kLyB\@Mj){ P@ GϏu-t ~o?BeɪeAo6=`xKUrJ`i{3Ooϫhť<{v`d<c@_4uv1U&@,]"ޕꠥTf-T.d  U<+ժCMVVV0#3GGGyOV6~ X[[]b'żfX7G3k4|'A=_hf@sӯBB`biAW<+Ϊ5x L`R)o'+^ knz> 7ՠ~ˀb}^@"LVâEG}k AIiCXN|t*[ϔy",x_@ӯ5YVBadjri R NۨN0T 60aGZ\y9N~/ F֗m$DtR"2.Y>dݥ!֭༑ %CTo {v p3c#s6}%ZVmi~~~1yL_zެ7?NYKu)xս^up:Sqqo, S~_XO@ kTPJ7u3nI̹ij~sn=8e?ְ&񫇀9ȅw"] V@Z7.W\j>h4LP3] q %]厓$yl#J{irXc@Ą@#XG6Q`MEAƆAz׫Tdl. VO07Z@s_qMgA*,A3Ϛ v@1kS?c^l ęGS MJ ϫ 6;pL ܎ƟdW);'[@&{ l8+/زwۻ 'LYbЗe}ro9 ?~p~AW*1Ιҙ 9h VVegvd9v_ߖ~o$~xl.T9b-rƀ׹=b`_Ν@ZYz@RH`$0Y ! ejʞC`Yuo:o]: ^kAA84$a'4zlnt.wHa RdLƂU{,v:xJ ThA?8g3 7MjR R*0L3 2,6bp;۝~~sgά܊X[dtC:,K; \납9%㍟t_n`=pQY-r^.PShcPZ@cFV@,sN|ɱ_JŔh2$ }GNzH}o@瀘HrPФ'vp;9 03 h[H~W@zdiߍ.T2 i;DFZb;?{Io6,Xn^W:~:[6En`$77ɩy&`=^F_&B˒{}jly{oK4X_gxsfH2YMgFar¿џO10V{=|u>xTMkbVfjbkbkb+)Sr.]O>=mr8v== .H$X2o,rYn1`x^=[+ @0@Ii^,藵[@N1Jp]d2Py vBT $]$Pu>P " 9)^|wF+?Al $p_xhR #p26~V\m=g`5 =T~}h,9p-ՠ*E`~̯H>th^gmur_ UU~m{ksܥX$wڹ,0zh~#~;gg+:S P`\-Bc Y($90^u[ejo(Pp^,Jn)jρd#Z`5 `6>> :AjRy- ]" owgPvrIȡxuՐ5+kV, GxGb^1Ŭ [9%>%`~ҹI),I și NK Zмp7 -fCʢݧ!}OիAn0k58ۊd= #8PedN/WyG-wT/7#s;p@$Xn'Jw?oA]pGG@}ʒg0Xi~ (>.L9X߾ֹa:duYSv8vxk:¢~'n5-rۜr8]ۏ/92Z ҶVx etok`~nxs 4_δ:mr)1>(ٺħ&&oYc`@6XXgQ~p-={"L/w/@EY@ 9pxٻu;꒷ 3YzWـg5 ^MG=r8@c>5ַϭ j%OZzԵebā䣠 0˕VLMCṀҢ\|a9%JHAff[uc:o6MyVvŠ)v<m{Y*ZOW8+ >\WV} PR1ejL<햁@Ișy$שd }w%{ oI!bOoK* -k57ME1 kDL[VAZHXڥ}2;"?^ьK1#;A%ˎ} ZM:Z]];l990x3fYnOXI5wyD;\*܆șU@`A \gM_biF+.yłA*w"AaIyw\A}mv._MzMLSz]5# ("E !Ox/> `UzJ/3A= 69ƙi(/Ku g_@vI=5U{ ][__ u] ^۫]CɐM uJb96Ki4gcglMu7Z6\.3O<X`ח.Hš(w4EIȢ`={t^cR٧Aj'_H#jr ,}!HVrNiX@;ហ[=p%xS@| R 7MrA9(Aoқ>~*V Lg:ԡ1n ʴz? 15@ nHlԥAd_[A)qd=MZeC@f$ݩo=_r<~w+ t3ŧ*6c>!K<gD3ݠQnS0$W_$9 ru໌AK=0ʲ큍ѕ>]rö1R6| 6̨ rsYЏS U@-e8Eꃵͺ'8K>?z(w-:2eM5`r䴼B Kd5PU;dWKj-9)X;t7 dpzigZ?>*M7_© K,&7"H}JŠ?(Hg:.cȕe=v5 U p-4Ooud%#++a3 :W\Nl|i~zķ@z"|t^v,A4`U[u>)z9멦`tE;zޭǀ8-UlcKK+=H|NPӆ#'T|Pg@u\lB@yJ{)@'fF8SJGI%*0Ҙ@bn a4 Rķ[R~Q8RkC֝k$[rOt.#{ RaS {t/ 2kolްkE? ƁUVծ5A%m蝟(RZC@Kk>`iyaQVwr}ZX 4j˶л@; _۽ըF5y$<++/M8^:֪jz7lP8#F0p0iol[- ^|Avgu,ly]/- :@WiPVA]PK-mZ-@XbmA}{җ#O& 2Dқ&$*9hu]6H˼ ¾tޑk1 tvt(7q.}?6xH0 UA]^g#N~}:?\wy@:w6| ݭX$8l do_|6MeV>=w ~G>? d~MY#HEЄ)WvPz)z@F;R+4Dh;U+N]Y iWVZ92ٹ._򃻏oaE+Z yDU*+rR޶Ҭ뀇xA;!|k56˥ ycSUgR$"@o5,X﵈ T@rHƩ夸( 8OK܋A=N2n zZ/r~<œ= O?K }@uMgV8x޲o&$rҖx yD^.J^U3ޣu_ @h5@U[J{e/p5ӃWe ݽ%l--5)>0.QV!5^۲k}^ kCA"][\ X@'G/WVjR ㄋ@M0V>ۛ\_$ S'V<,}AV>;yGުU, 򖌲gu2h7@:htnQ m=֫,6ОvvNPp"٦~j@~8dcA,>l:M7a3ɫ r)qs^MLh]+b[<1$/}PjHWڀL6goGDG@]m`RO:r ıNw&ͫvp)V8N \T;@έ}Fcdᗛj/ޱkX"+AllՌ^T 6Ǽw2&&8ӠI'#t6魺 x$.>X||es쳶-,KnRPκB2PZخrIJ8h<tCf8@h PKE`JrۇAl nYlPǬpz}ƠVdH_^ 'J!8DoY<ɓ<#+~CP}[AϪ:!1(m1+X5A>OŠSW>2;ĺ 4M-YR(2sB)awe#`k's6"@u)I$&CN,A'&EGHKRSef9h_}ArYZ[5VM{ƬImw3Ҏw@u ́b _Y}z4rW7O45AG;=i dĹX_j ϫbnmP/#m tPXR'SMqIrN|wdt;,ouy< bYg&8.< }8p+}JSПd4h?3NLp{F^t/1-,-K(&bt^0 }G+뤓4Gs4tQ1&GFh |$S ?#o2Vm 0}!tsVzZRS>;lLT);,vjCzC.!#+O7>Puj쯬 2)74oc:y@@ gfyP #Ϣ ֭6\3>HzWNӁ6WaYeLK^J\Pv=\0I6Tű {lZ`.P:OMXt.qS4/o)} Iՠ i= }X;l/"e>w]iecHbKϻF6d }G1+d-)2ҢyhV~+* v]nvx'y[[[Aސ7 pn&7Vzύ] eiqxgA_.;t^QsDNA v P +W7w\uyP<4`-SS%=y"&t:'ZD H<K(}, i?dHfP NFn r[mOiHyK@MR0`]Ge+s2 <YI CzHX}>d&3C;@xb7F(OjuWA{^ko'3@+GM%*A|Lpqa kz2HXƝI;A~Y.xFФsZ .WJWv=D胜F@@Dޑ fWU~0+((J'^ à;gf5's8d?CPt9hO{ڃ0'''lt6+‰7[J^Y9Ӯݥ5",ۚ ee&-.Xm4{vH,6VqO z# 9kD\1H݁;T,`9H}'pF*C@2٬AgAIm9P&* e^X3l& ks|K)-@lkg27գ8~QYr}@7(*Py|m:<,)8ov38^ @e@>s>gpg4!??QŰh|4,w+}E)o0޷w_^%şYgj:GFO$"hҴ̔@]58;%/&STZ/V\!wZA. HRM*VBHln,_&V ֳU9]yEdf,3@,_78[AuFr:kJn5OqR'HXB*dh xKus@7@qg #HrU ˵:AAT+0B ,; 2&x{#<=a@.o\k*U {+itԊ| ɠ7Vϵ$`uo: ڗpPO$ <tˉJ68bѥBVCiIx%;PI:{f@Fٗj$v(P @:bQ$Lx>KFR |/.j\ai-+^ h{#wF;Ps:h6yfTt_tg*]Oん!M>nm[,rq'xٞfv3!;d ~0~0~?Ipb_N =Z`.*@iAH;Icv}Lu57 P#`e\|@/6"j .Wt PA&d15:Ө?Mk =#њfiLmfu4j:@p3 6XXWV=OչOA@oV&2@qˏ}=AT2rPϻ\tL\^aIB r.G@=kq(.(  I[ H@4l٩='}ZdRUmZ {Zg> 7'4I3zIwxVt-p~b9DC߂nSbY1tu5+䙴5Jj7ԅ k/:`gI~VX|rn??Da0QvU]ggg8A";XYYA`V`V`ċbP_}Alņ[a|fw\k;:LxFc6x̋VyK@^:e~=ÁOb0@.s )u -}@@H-WZj5+f>Hze.'[+5S$)nҳ`z?k.60Ț^z8ݭۃ`^4 +^ mu7<^r^3gf˼%Tf JJ QN)u4PhDdJ uxn:tN9^/{]=\Dˊ@a ׃ Y*ÈmDA$> uEF {7m^@g#>ڜĸ#[<(2{%l. *ʍE~"(@Q]/0 yNQ9^x6k6IuXUu | ? *~Meth.vP   ?a`1{@Y¹7H)`.1K}(EzRw$& P][Avq]6 vF(ē]k*zUp61R~M>(ϙ Q:쯌^;@ MczxȵHٚ2p i@D1Mx{lk{Pwe4y1nzPŎ_)@v%CiKk;ߦ?rXHP/N[nlPec`k@`KI0d{ی1AZfČ`5X 4$ r,d! O'0m6 T*GἬrFPV>c; )2=JrvJ آ|sO]eQU?LhPjǒsV`hʳ۠:='pXaU\Sy=0[ZHIddkD/4IVYMZ;`nفlжk۵M~W 1"(";ooob9ĶU@ۗ!) HP^V^ogҁOo _"m{`w/je?ojSt?;Aj > W ’78(+\ rWtD\ǛoD9Vo}# g{=٪RF@t4Ipe*db<~4ؾPAEde'їH(w$Z X|~uaUw:0R@}~#u?\@\ ¤ C@͊ }j:#Qg BZ*~D9": >qKvy+|-kWG PB( QG@*NЀ*h 3ڬ l%jB;h4D[-i~Icy<Qu+բVU TMvǡAZ*yrwىs GB:4]x;'Ԛ5's*">Q頪o:yNN'љgFu{ S/CGz~jWw쐩ZWFoy)ݞh@sPO4(.@ʙM.v\$gś>09pЁ هwZ A'q{8Hb5πZ_W^?V!=Ӟ25._rtمo:Aՠf8O¸ eT PM#BQVG<~pմQA.xo`'ډv"f <#ڿH#4:*f s\(J}^^^t18cHnh2[f*574mu5*yI,su L: >GDCT^(p5mp/mг7u~vknl #wig Ap3"[6U\{6PZ_ѻȷDbfmA̮~Iw'*|{?9}xtKAk$9ڀsMJؼ'b9\._,tnO9 jJ; 7@a e"kDz5>yeOz";A]. yNu-+22>ЅJF GcUvs3$1ҹ0MS/KxVNէW"v; zHk^.矕0iw ԂHPo9u+(WAx@޴ۀ7+_!nu-l E oru>жAU;eK_v| qeFg:gV^I@}CP{rm< jdi7Qj hˆhHm4`GKxIPLX7Ruuh"O @ _gvX(+*UZ ^c/x˼˿}B/"/B[ѷ(3 (Z=Zߎ.9oO{񘃺njθ{/huOw] }6p2Z~&z <4&(g ՖyIAήѷ1PO!2wDVh۠t#x7]np80@^Fy sR:::vA&~(HF2111ps8):Rt*(gvupLtQ=ּN`t\k[jwGoI>%.t hJAhe^P8OK(xzNµhvTPXbԈ.>S7GGKOw.Iv!G;M0L:ĝev0ux!@ܦz rE2Q5=и}ZsawP~E;9x Ʌ Q Xg@h6MJKal劲A5^lTz5W:k 5Vv]ҜuY\@Ɂ`3Ǚli4[ii!g3ŕO5[ܷoEC٢Ee*,M^|ͥP4GYzp8RˮcV F]QX$eUvPR1 ČPTX*0͗Z(9nhr%a#@Ʌ҉ tE>A$ laF%0o$TX Ǝ kcCJr X}^,/hi>w ļ` 2Y` k:-Ƶ7\ F{vUy'k@MG} "9\P>p<[B)Y€۠¢gaq{, œ cUKU ;OvAxDoѭ`Nmzѫ|SvY A{Mχqǁ'I=};%/Fj$zzzAq5!<'<'<JJJAM*JQV!vc/vP[YEl:0"`SM]@Lg.=5*mi(/%> -e4fSvPQsvE+qDMh#;uGjUtCRRaU_xPaiu6~ @T N:%v@=,Ovhgwc8hn?\2ODP桌dn^il$eŠPaQ} [-Jn?[|i17XtUOW{uy]`hfh6~i zqJc%xyy|(Y0`$?cZ:{_"QAjS@SDc7 =,\ǫEZWa]% V3[*NlL=cI%njq,`hvչLUN1x6u|ŁjV./r. \.w]~>^{J`LBs'N8 &&&PfYe׌չ9ੑ`͉@ZZKB@W=mA5}t%!F*pu4c'=nЌz~7 s*_ 3ܠ.l5Ѽgh Y\eFo T`#yM"z1X{DxBoxE"Fw*QfIv\fbg_/O3@h;/JDAE*?3{Xq{\G%)m,7ނlq-P9M4z<] d|Y3|π@@@W444c1 r\.k"x ty[VCzHJ^+y ׳^#bD `jxV(w?Jy;xJSA|h0PgcsfąٓZ1  ߆cߌP!BE;~ 4K :^mqU^~'k5$T9rVT|$rj r#=1ijJnbs~S\" UW\e09r96xY%÷Vf |[ij H<ˬ(PH0@؞%K=}g$PD=b|Ail] J{>zˎ-휿J1A˱FMwLz s7רAJ!^q{h~-s AW?֎!ZY%u &v6ApZkB{s멟5[JŤtR x̾ ^qH|׽ r!E`6fѽѽ:z }Pxc9no7ӛ EEEp} 2d8"[dloqS}{(>`UhATb=YS1Eq^"⎀P29bŌW;M\ (h HS$#H)3/ѵI} = =u?њbOLGfz&UGh SZc}WUi\ Jه#-Ԯ \3Vwbp[ BhaBhF~I]rWG@^Za\r!p`հjX5 ǒ ue]Y_={*V M&}Cuڿڿ n)!}+->IӠE|U^YkD|GTa @Z;" @] EU@"A֏o|uS`*u#~@}˫Q=¥ottXerأИFONo2bU~Qz/'ˎ._o> #YCk*$N @Ь ٠"bFx-C^k  DU,zˍX- &&C!h-#3a2GjIDATA+$<}7ex߀]yYZY&(+h`ʠ͡@H+#4/<@\ZE6ٹYU%Bã3nк*cTT_WAǑ˾7߶@>͸@Pd+IXiV\%'pUMY\M`gWyxOVZf$zǘ! zy)e9e9e9 QQQjs%,*TK_"L2+d>g>g>ǹ nED,K @ʁ<ɓ/t7$l6yL(q\p(y7+fZZ^@2P\$E1h(ˀ ʲEJv`;0x a9B@؎0θ k$[@f?%z[ i-DuZ4@7& zVoԩ-x浭ˏBNJ0DTka(v],|+] ; gw7mzg%Wh$2Aq0T  䂊I!8XCgc^T{75vד2+ L`.Z]/)^s$ REH+ZEy3/ј4H6i4kBK /%ޫWy&M @KAUpcw$r)ԁRat;  ]QzxDu I\*D?J|a%^Ue5D/P6MzV@wؗ_+ӶK\m%r"Kp-jL$ Է|7w8T뀪mQ5ʋA]u(ʽ i5u'NwҶgBo'Myt5^G vU>B;][n$.QMl*+K4J91. -dbP@lQq+)dddA)S fbĚ FosN_HZg_"NO-d "W)ѝѝѝP)RN09 qN0$ esvNQ"Ӌ_pU߶'j @d0GmN @9(zp)`L)=}ԧCn i-_;O@H>w>F~<'VE@4W1H,'߂W מ9BP|7 $Y@jWG@a3o?a[ ҏ6^]Vv#Pk?eP ēFe ~"j.`9O2'who@t^8 <>35tez{^ /TTTH\8q1׻׻׃loZ9]?>"^lϴg3! !={<+YWFg3dB `2f~ݜVpDaq!𳟼Άvؤg@v Y;8 ƕ3:+4\Y eT Mޥ] fG,ׁ %%Xǂ@z^@VwL1#Uu`=Ŏ@*%UJhm2nȸ<<<}^$YЇyu~ !J,|D 1P2rKPF: !>:WXTs]ב`KA$PPЛKU?L j?òj8Xkwlr+H :[@ʠ"Zz @fvT܅e{]:j1A^VwAqHU`]w\ FW+m=!{n5 F/VW| /濘"hZmW;W;W;ooo1B#8/]%#r%w9ŜbNwtJtB]ewx @Hm(Qo1:zlʆ tO 0jv8%.gA 6UU=ܭ*;JG\4uNzUPa?Xe];z |n烸J5A9x#3` =VWX*}aHP艒 tq<;x(p_޳ :{Vp#bsO']=Jù߃S): f3?a; j.4ݠ>ts~ }T>bluTGyi{&'R)T#[&* > B6Ǧ8;3U7]͏| Yb_԰O\fjTG e1B)i ;kKܵ]pDG-ߑtfWx_s;V߭[AZ֪5$^xUU2@۠m6ըF5Ϋ7Ѕ8I'DH)izK%мWdte=zv42vPKU\ئ]ѷMJAk+{`]޴!y)/.oIͫ(qX@8u-+v ;vp>|4$|e—Hq8R@a= 'o mXZւ&  d777)єh $lN؜RL3N0o7o7oZӚֿ;Ŕ{sDD ҫ@hٜ ! ?P-ȍׂ|4 ;@Z gC{B=A%FЎJ/Q*ٿ{YX2%cSA{gHߔ^:`gGG~UN El˕Xrڍ z'.> JW4+ޯ+wY[{x HHӇwwwAѐ!ECw^߽ ኄ+gwgwgw0Ìa EHJ;@9Kzғ`o7 <</_ H ooo:]vWԆIdPQ_::>UrDZ' OAto`Uz=f]RB|j*xoꀸVQ1 j\\ 0"[7y eջ5XKAI.uHue--_ڪkZ:1 l|I)Mi`G+ʱr >>"[#[#[!45454BPDDD=gPkfqpxFG8ekxwyhF3oa [ d ؛M&هC`}`}`}===MMM0XuV]&  s8 f/ 2B%z h_˯ל+I2{{~y`JnnnA444Z#Hz%"Dęя~`w;AWUK YYYكA`[ʶl*[`YnO] ){ DgIDATxuVUsCwwK"" bJH4R"t'5ނw=޿?<~Yk+0le+լe e,VR8A8yT@5P T@UmUhԦ6RK,if7*8 '|' ʫ*H#}x@$A@19~gd, W\("H i!-@ ?pJULePUJ_WA) Vnu^WAS>Pj e2  Д4S׍ _A}q{^^N05D+++pvv$; $'I%%%ȋLc@T@@U*]P]޽N0inƶG?' ;a' * R\Kqw]y_ZV&j";Ъkյ7 AQQT!UHAmP@MWu p M4W.rt3t nqdLrf9vk5=vCzn&UzUz@vvv+h|PD 0lg;<6j:h]5|?*LLL`=Y7A8O9O9Onj7k kNY,h B0:N }>l-[0!IFS){=۞ Xs9B o6hk:rF90(# @U}Uëʫ@P?=}{&l`*S RBJH q2NƁ%X[[߃y+A7M_/}gܵܵܵ@Wѫ6T E@iJS?9G$'418ݜnN7/ z;vm0A`mm :::`x Sw%O e+{joq&X.޷ wfv`0Ֆ!`XVaji*Uՙ2@ />>W֘Ј+F6vώn&n׍38syLh} X-6QC ˛v/o1® % Sg8U ڵkA`Hqj֦`}jt_l2U xx= ʼnT~Lu:v k5QQQݶ}>]ꢺ/ 1q dLMMM0GmAWUWUWU$fVs5T`/ȽpUzfLvxΗכMzWFjb*o2ONyH2MdX}3LbcJS]zzB2K$@액 !wT@d9-$ArƁjTަ*\Gl`Bp\`p&Z3 Ҫ Z9p*% V< <ƪ-cz:\}ZmWQa>UͪfU\ \ \9#g xd_s_s_s...v]wq]` tOm]WN5ܺ%^ܚϯz; @cTk#:@T U >b]X+QoW7Y ʣ~]Ң[CN(#U~y$ݙdhīN,~}7&Ƈ2qTuL>o 2_~r/ 1/h**.# &<'))2Bk\?~OOOkn_nVnwl )nJT[-vc7 1b:t}F_h(wA?'~yw*_8u56:eNwjfm>Hr{dz;Un4T{At=(H?r9~ q4a |[u;`E- q6ӤhmP-ydk&/ܲ䘝GPfex8 It'VvxGH{$89N\2u`F:h3 d/s+Q$ rN9pz;׎=tpss6QmڀOݧC{Y )#?9 2a&wRt8z49 w:x>p\kt|jV#Ui@  ƣa*FHs>1u+lkԴfo^jl직j^Ȗx'TEcKP]CPu =Yꔟ.Yq Ae D[FU 9iSUG)(>p;H0ȼp,K+o)p,8?n /1@v3k] $ p9v@{FC\v[:y0nݞfq8>}\I$Wҵȫp׊?g~+se.b-ZZZ3|Ѕ.t9Ym?FSܒ/O]Á[;+(x kHI?th64X1v{HO-%}۱{SvO^܌VJ|+NW hNiЛi ho/[%`$%>|dm.2r>?1|S:{&v?U=ܥĬ-_ PaqJR *+*+* ۃۃ!w]u _,F6Zک5˚e͂P\(.999/_L?pqqdq+΍=EpT/uJX`<J3Y VPqƓ@[o_q+\s }h-TND꧇2; ܭRu >Uw 8` +=8O]qH#\5;lf{@Br™24=WBd4|ⷰO[{*`Y@B4à|`³@LIHp6rs墿 \/ j%Ѡ\z h/* } UTmX 9C%ayζ^#XCE>lφrn˹ <<<D>YONs@ $ *V d ` XC X6X6X/b؋::#_cbBL WBS~}'30PA^v\΃d . F\ai-@ UScu;%/M]=PS&UH|l^/{ / =z (*\@MAo7>UyE, rU$hg@]gvY!) t;1Д ّeS,9aVZӀ>T0?`ZEL zI,idh` 9+•Bێ;_(v@{>]]]AxȮ]1tno9o9o9llPWuGSχgHk4WoWcQUŦ*1ngu: ٽ{gW+˕\o7].m׵JC?( `{.e+ `V0+@ܱcq`t0:ܜ{J֑i,,ӻ~к) ,2z>GQS ~C!TAKDy8+"C! -23 a̲UoȞq߃l{{f/<;nԫ5  F4AN_.S00)(H>SCݟ7" 5_l6K[bt鯅!_i]<$PmG@= [ aU(TV}MPQ`]+pRpӞ@N/k#й+vjW|mڱv,dgga{{{4SqN1@+^^^Po o o@\ .7'g'!ʀ%VW;k]^pdrCuʃ  زQ"GԲ{뀄@Fqzi6{C^*UTV:jf9QK' 34췎$}5@L9lZtig b@O[R9{W$2Qy!0/D|W70|J c [ȗmATO.Sr*2ߐ`9q=?$dNE G.rA =а) *ijU _ 'C:πVd;6B_[ِU,XV1UOZP݂ft:餃\ rl˶l BBB T3T3TbĞ='G`X.Hݽq'͒. wyggk;cȣΏ \A~m5(?iDjiΏ zȆ4f^>=T,iatHƓA?`VpK0kOwޱUY\9̺ L{6*_"QAcǃX3/#lR'`@w_1d?VXTM7+5lj( 8(ƴ_6o i\uYoClL&e[6d<}3ߜFWӣӣ!T&T&T333`o7zEN666]ں:BQ(-[ $$$ggg6PΝYU9 FfՎ9 9"_t;P* OArTs;1,MUU3Ay]i M`n{$?3ZO;Ԙg|O{k|}{q?9u/AR0׬vrS _:-\R :U2{o,FB4G7Э:> Z」!SF#̻zᾘTo r!!; Ab`așro )%2jM-//r#xxxpqqVR+ɵ&y$ {KKK@)Sſſ<_x|qs2NpŜ~nK\8678{9;m/H) ZA{8޺[A`@0 1sA:Aw/zR׃cO E lWu$WbX[3O8J~XŘ a͠Z }n J{U 0/app+< zpCa>@ KV% )"7KS_aRT##܏?bn^-ZXU]{;Cf-g$A|WWW~~~ \3>r}TMUSZ1 S۩u:>>>nnnzz?b+ =Qsϝyj+98,E@5>3H4ZE^#!K1{ L eZZ]wu-υ|F*ϭesddufY(p=.x[})R2g|Wu޺SQxĮ;A=~ sr!y0m(1d3ڪ;J_@~6j)ee_Gطc)'݀Tױ@z]9@6T# ǔ TU5 ppI-v RY@ֻE &:F%@s@;PbpoG=Q%Qfׇm{ABZt{Ic^*_)_)_)݁wzWc*q_.p e}پ @zb,Yȯހߡ@ƀ.}N5DR/՜!m| r% ,T^$uĴa0( (q[r z׹b>i=QYzG=#S wޡ?{dQO5@M2~otl{ R= 9;ʹOޣ#Dʓ@­6F{S:^ZJ`ŕ~2# rg=m4}>SūH'%"G桶  LFi%)~y3U9uu\]@\2@YLT]f,ojl `W^j:u~ [سA-J\v-h;*p~s3>8b[J@T# d΄ t V8CʨQ+!]Fvz:tijgcMlbӿB@6DI`}g}g}A JP H7ބ{6c+_J1?/FNzVL6|M&Zw GYuYaP.WR@BrйE-v$/Fbϲ9k|.pbz PbhڊzQG: 2xuӁ|;^<)._DR,|g-zi '~RP'S2>9#x2jM)Fj0Ta=@U.Q&p,g?Yt6u2?#~ AKHR~n:@dv?`bٙ*Н"5^ج}q]Yѧ T- llhf< T 8A4ehl4_J;-[ގ~H hY5<OX~?H=ADݑxX#]m%X 9z&xVbT|Z.̿5f ̲e3˂/ 2=I N_%_^+gzX= ##~!?<k]: } 1){8P}u HF`O4ԘC3}D@c,1$,XPLy$XV\} T+=b,{CW)ȹ#Ywh.ۻ,/Nl\:82n}8I&mQC.ߵ؉o$ZS.q{~TPէܜS8ɍJ6 ġ+ {۟ÁVԘ|Ro+@ْd8ET++R@/XZX/h,Ӂ$)}wFa߃ S`6p SվNK5ӂRYTd=br8y uZe2Vׁ^*jHL{Hp5Fꬽ̓Zj{| r V2Pni[svsUs'@N| \bZwWu@_3^3^~0!z{pwwF)Я6y'sH/%b1@Β%9K^$ K0 58gtHmi߄|ti ~rYP r^x$@=/, VqS@F= =OP>VC a3ň=wMH^`O@y2 Jts!.MxgX~]T"˛4Iz,k]@yg$bv ˓*G<@pDjpyż]|C+`3pt sT5F5-dz=\wHXF-/5&8:ڋ7uLYޚAL= nj)UVNzg+0Jnu+Ùu&]{90S;a0ޗR_B%@V[|p^R@ Oxx't)Ԑ`+Gg&s[$PA 0^+ ʃ.f~wj8ՙM LVfvq#IMcFB3Ucܙ޷+H\uK1$*6 'J12cdHP`4z=?OІ6`ff%%%`Xk X̱c7|Y4'/^ڹNWo{ڔ 9y{w^ N`K]@9]r&3S0hf'Xlyى\):Ĵ r9HDb)Z6e (Tʭ}A%N/='i6` jf]*5"kH dרl7{d?@I%$CЉ^ stv9(eP *ԜwR :;'}םXWʃV~gA߳c rNo;E@_3ѱ ގ@;YGA/OAj;CA{x.D{_!IT}Xm}Ƃ;7`sߗsj?*PXOB%QOvo_[ׂSX[ہV qWldYe)myk^]pnAf4I>8RoC .H!7GLo;\esO} K/X|dsu]'Nts\N#X_W5a 8;;eZeB˿˿ {{{nN&gi'[ǂ۷-oC'ftTOq9Tm@BKfcP=,H"(eݗ8%ÂQ}]X89)@R1@j)PVP} 8%0<ȋZ3[aǼ JarJsگKErZF6 IWfmJw-P 'R 4| 9}>QW ȄAd ;q !u穋 Kxy潗j D5iS΂]8&tK4tY!CI $ǝ TZU@cm76Y,EbVLUNM2nW@{,A+;Lh.A7,'? P1p\|yPOsESr5 zA-e~Q_zWKQӶ~ 9?&/o) n)zy߃`L0&"ck]sU%UݕmMu:iEr9ŜbN| 7< 2kԸ? bjs-)(?m gmS#<)[A4DG@B/b3"T e;{W=Ni_,!y Ȕo~89+] ԓp5?N984V q jIUwVkp?> #{@2ࡱz&°\"A5Rb@#kI#pbNZ7$GZi0 tBHdIA\!v0N/s]{xxL= 7^ 5vg`5X7>YiR@C hqZYke*ޙ:tjR0vV[wڽ[Yt kHNdC,PhSO'`OIUM^ ۋrG|111 |?~p3O &1I`7ۍ!>>Ϻ?~3;sኳ)s|_`թ?샸1i1aP :"pgGS (-ewˌ[XUTo ZUs֮gcSdc@ms[FA>#=@г:aHPfcӟo4@Zo Ϲ-GtS8P;AzjF>uՍy6Q5.徒p28Ǽu[stoM%0 )!:8cuZ(A80|Ӡ>:E . :{ q8~ j9#/MGН}kW~J Mm I#0y*Iln?m?lURd'702=1ˮg`en.=nysѠ\<ΓWv":_kEG}Mw먞Ӳ (,{שpp*$\onfŹʕ_ AfUYகaJY$/Zp8Jqj/R'A=#(28򩏁{5Tagsȡ ׵ٮAzBUsBǿZjEPBlw/ ڊ7 L2_jUH>;0*RIloQ P$(V*:wY]9\ a1?B'6O€iX+Rvʧ<P_zˠ:z^̽,# 2Zo90o'@Us sTVP)("HϬNQSmQ@y<5Ly*O!n5M@H;`$d3A'@N oj]v`?EX2zug'H+ni1L\4ջ;** 0:_XxqX {7f~޴ Hl@= (#"wn7V}Zfo|Ö*[7jSf%TpU^P`-]m^wҾ@a9 Վ>`sG/A?ެV{@RpYʓ4 :r8r#Hg$R쒊v-ߡƈ!#-R׭b IV&`[AƀJU*H$fчOHY)+eq@7Ao7gg Xt;Ovh,^u/⪖ؚJՓ@vϙ:X=~>Q20^}) Eq.@x"x5"G8b m^`x'F4:a tv"_huoQj6oV mY@^ f> cֺj_16Hg;_iO^N ŬGQJ!KEz a- U a 1F?lmԑNdr}:j!Gڋ@9{s`nM ^g; 'p@~q 8u>n/j$@-P/ρ|D bgmͷwf-];ϟwN^v*E9{jiӧo!QKD? .Wl_AP8 Z5Ye|TU= noy>rx'&1PH@@5]x;akx4S|\]]!n^ܼy',G'! m^]}C|T>^"|(8{%7Wn (u<. R_x*u#<)1pSdK- +mM=vShŗ@ewHijh%zD}  p~s/8ր@ B2ڃOij^ HnfĨiQOm Fm ! P-Z *<@Ѱ@>b U@ʹ-鵓^iՋz w 43i-XuoBh~x@mѢzߪlУs/l_pCAFިl\P `dEԼO٨j,w0L\WLi-T-q YFe˕[ўx @4 JS|Z zP~3$*jd: ɞɅ@kTA5NkieuZi]ѻwaa'9ɛ'g>8NZZ-`YiVcVxr)< ы݇pEA,`QYA<TVZGVg er3?7^+(|9jEDS[Q蠅+}80 iXʺ-v&{@UQ+0X6^ìurP:abk> ؄%^ԟ8 JW!PPπROk( @ Otɸl"SD` K 1o -:Pw㗢`/\}TقAif #Cjq!xi-HڞR 4<n+%m 40A5x˂2١z3 73JXg48 د$^T(wcdP'+{tUn]5"{K gEy5h×@@+ *^^\Z Hp--rɅ%8?oq}ƫfzWzTJW@<7jrS ʽr/899\gqqqpr]ٖN* #X;cG@ޑ\/8+AϷcТz“, xxSX3 -2pH`$',oH9PݣbU>AgwoQߨQx@ej&yu!T:R֏b ZrخހO3Igk- tq?:+&)TVk[*Fm@Z$YeիFrF;r5. 譼;v0  aN9y 1?dzN 51DjR&jHٷΆ>ԛ*@!W{-vxUm^Źv:-iUvPl>@9&Ҝb ʁdd<|dH0/| 5 p?s9bT2E"F @oz_RI%D]tpF;`̐w:Nӿ's/vPQ@?w5F4f63@f~|;nb<`zܐ'g9Oy6 U?!8lAWxP3{Uٜ;kf+i * E;tG܎87?IWK@:eݽYtVStlE:oVk?$z6`Z$+Y_)1&U,-UJ*pIF3e> =L $uhIG@vNmvYъhwAWs`Pp/4dQ.&of@uioSTyC_jNZ{:9QPlͼ}}Q< ju!8<_ڥ!ysF>sopˉ*Q%^9h6 ;;; `%+Y rRNI[`Y o`hpZǓz5S3 ZCcov/ދ]| YA-}25xꝀnM  # PmH):HDa!PJ/lST-EpԁϾ{8Bh:Vy׃\*ς}!a(aCnfTv Y9d}-)Ar[([ juXx( ̐nAﳀpFU%4W+mw@!mZ dBfdUkGi N9~R2%xB#qzdd9Wo-4iI5BlyL`03'@el D}"U^Up:;`-Y@z.7E0{tMп2\2ɚ`"Vy'o F#G47 _ 죧A%Y  n1펡ҲYg NfYr^*ƚAe\P9pf69h|0E QCo5(j v^6\n4b)rNj9/Oܾ.(g·v4Õy$g}W@9]AL]ZXVl"P,jۧ @-Gz#8/I3(MÀG@$Ę3Fe'+4pdl\DR'Pd>R$MgpSA$oTҜO%=,8y9L6\5,_vFXσ\`W?d,`٘Wn>g\h:Zlv6;՝֗R'ƉYɬ{!|˅w{ir"$d Jw> GI4cL8arQrm]A]LH,ܮ&ȧT5AŒp * = jXȤ{AQveyȚAf(Z p;8rQL5g򝌱ry4>u B`nz ࡾ.ʃBOҭ‘Q>O\ҏ1KȪbZ_6;#Hyn(N)8O\=G~8S:`Z4Ż,p։7QiI^rYf)F]P{@pt]tS,WHҴҚԓ1ĔЇB*H=:N<n *[F>j~ o8ܲѮ ȋqym#Ztglx$H>z皜m␝AZX&`Z?O`T4*lN6'#;'|' Ԑ8"g+J1cߜfVO`yDo -(r Ьɠ\!2 &ST yNiǁG (jMM/,"`_Z.P~U\/`Uޕn-Ҩ.A*_5 ҁhG!P 7 k9`S%jZj.H?y 03{.);^"/ ,RP 띰U헟i*;{U3ב=wr& HsԼWH.Vx(%9H,N8n g*HPk는>MsJJt^6 V)Tv؟DL>ie59@ 06x{Ǵ-}Ei fhƋNi' 0ce<_ {ҡB c' @i!s# ЕȰr2✋V.`e"rubIAYhVqQ QLc"^ ڑ˒ Q&~?=W_A`E`E`8`xѺk'mwN vi]>OaaanJ3oBpԏj&:N 5PV}(uY v`]|:ԙv}#ғNN~`3ImPz]{Vl?Ȋӫו85 Gl:׍XjzdE VGP>uZ]PT@ck@RW3t|*Fk֨ .s =ʬ,@T+39Kf|8P?瀲 jfמʧ-P۪IRPnTE5iNZuQ+'=ڰbr@"m]'eLRZ_*}@ՒA&J+g; e>M c$q뉬Xҵ8ZIVܙ@!o7DQɿY>wۯΛf<8sMNTgAkd-J R;}\xW<8BN!puu%FZ^+Q]{oǃV*E^1f7PGd"/ UpN Y̱As@Hn>N e%YX:xg* lP*{pp4hGA+4,b·aXr2&{]yVļ y5"tSZ J @+)cAX@MYX: T>g !sD`(`8#-(Vbd, fEeUM̻JUWAAvPK*4dN,k!'(P.ۀ׃\NI1@2OҺ PkL?qXܗ`7Z]Lf<_Q0nH]\ fЖXpVV/\R*dl7oY~Px@u.5y#< /%}L2HЪ 8U9 a (S>.y7YCx;-nq{uUUUUPU<sdPtp[is`+ FwU<ڭ l.*VoFwFri{iME'UoRV[Oŭ &A_A>%0ZZn,J vlk<(*K.Bg!bJw P$=\ Omz˞4W6pqDΒ30x[Y:YIPU=T`(HE"UI(@߯c;=4F,p} Uzc=XA2]d`Jvn-<<< KKK>!}B%f DzhiCFէq\Z` ),@"~U,WЂOz;uA:N9e0>|L[P[5^ۡXVk HЙ$MXB.P1E1Qjܖ7_,(HHޗ.:51o1/27zY]DʟH/h{PTUtITjl%s UW_Γt`U'0xFHC?NꃻZu *@2 @23!0+YِSGG:`<1䇠>t;́cZ[ H&ݸ<\"T wD+_*C5( ơܾ< cOǞW7W7W7PGգ`]i$8yyVF+w'β[={@ @30@h6o' /u5m﹄hZ-ى@Pm[K3C[3{٩3li9O+j *|Pr|L^1f_d U 0GfGP@BJO?9'_7? <%rQ kI*h.Wi@6W>ڤA(ݻ$\l1:(7]%U!Ī٠QoKqpwMwA*F{ x=Q!p-7G!zJrHW-8?xa=yֆf9 )L!`6_'AE'2IM5ҩo.IqNM;O+WΠwᠪf=T%S~w}VT = [A%E5\Hp eQyktINDmMSr}>Fprr'މwV3QZֲVlw;A1з[7WC9'/-FPEw 0!H:Ҫ?:FGS\Np|4,\1e~_"sn{ z`uP[l;RZ [h}HVM%ZQo˩N/X+P7Z&sVcy{*t4&Iؤ׏Aт m?c72K.TϙSj [I` .rwV5z1jzpV@R O%Ci@E֨lqnVɓ@kz7nJ0Cji ,jzĿZk n=jP:85=s%F $ VK_Nƥ(GK%~ ťyJ@]TE0XR 2d'IzF=s`|{߲@(Tr*=(kUw48s$E9Q1bFs"HTrΙSz? <?UU+7D:#4898P%xl炷#6Xc(>_> z_Q{na6Żg[%%Zǯ'jq>n1]]85z:T: Uqy큎OJ@w)4:$@v'3Ͼ {tmcxA'x0C&Y 2D7*\꫟R) H7%ZkqJ.(& )o|n G]g|® Xո[}wk.Z/@xֿV7-/Pnw?=f`֋ex ^4vqRUe@ OA6 @c}nn^܈ EڱȶJ`ޣ1C~A#kd3H{UeAI.t05PU&a4`wSf3O"Bc,Hyw@gN "ȏ@4cvN ~ԣ#ApȢ#;g2%UTЂfo[w-~###!;3;3;dէKIvkZr$y 9%#v''gJ hx+.QG$V^㣒'*َl1`[q9ؤ_I dHTMqJ'Or3踷)Z$ T`/َD.A:ɿ;MCi!UOLJ:ɿ7&n,ifm~g@j.xZQ725EӀ#oﻍcrnQ{7A]7ʰk#b}jό_c)c=Og ^< X+)u=_^W¯ Eԇpc3wNS֍5{ vOIѷ`Dm83g j%5XeGց\NG>wzUIN) r9G֪w@h>rL}\t4iӌ=AYq2'Qg.-VNE{{V篞'ꉠ뇁Mlb(09z0xI$T??s\]Ph TE+T"G# }BW$J] F߲?꥞[yHk@v=}A:_v[2$t>Fkq*{Slͧf%-@%$!J(J`Wr @IJ&cpW+´´4,e){v1OXAs^zH)>py~tD7 69n2@ LE\Xˀޥn9 : t;h/ljjR&ܼ-LI$q>A^+*H$)`r 谚OT@lLy^1} ?tcC[?қ8G1@ʧrAԝ / U/T}[YS2kz, hf*Wb zm/'*f%dz@lvv,/yE,m2p c*wLr@_xꯁKS6He<Xɣi@@˴/ u ݾHq8uwOPcsNP/W}@`.+O]d{l-0< c % SsgW)u2x E ҩz+ EF-\^'K³@P;?Bg5Aٱ>Ϡ"cg`:c' Tͺͺ @| Y߷'.r:m@zc 2g(/@˷} (]3ЬA2`=`\ُ9/w]@]44VPi|gwf9/t>o] ʟvvقWR Y.@$v%G*8[\ }pX%, K 3Ԍ)?Y dZk p@n]. Bx]Wvr#lfabu/lW+(s9`q>Avbgm,tw݋@qoIP;1nFvŠE6MΕ?-o% VAzV0Ph^ eP [;¿,o+!W@Ӭ jb N@/;e5{ @ pQ_H] w FjJ֮PpɪX]IeвC{+vW> :FG{u.DE@kyeKdըF5b.bл. L=@Yd[` kX-N8xj`0^o@p $ )`U?.=BplEAʢ}RB̤` w/TxLQVod;Dg((HZnaՃfe}wA?@zڸ#pQʞ ]eQ^;pEB,A Gm<Ƽ:]T ( E {2tuv3F}sQik}$g׊`0Fz4):wK ҈, 悼Y%|`<r=Fv1/l]ǝ.yc6Peu7TR"brGq`~hجwLeO6T"zB|[@w PV`'TZ 2KUz^ RZJK#d';$H p&t#H76 U;fcM? TEV %~Sis4LVܾ7Ҽ (Ҩ8GM<Lo.i4u٣fVuv D&גJW+Iw7ˈ*0Hpi80,MAz[nH|_I'u'>_%V򔿁;!83 ؋@VfGॲ[tRr>~2c$4`<:5'?t%/aBrAu;{k&ГE^)HM@:y[ @:c*q͕ձD0JP"FC0\=Нo:X qѝ g9A=m)i t\ '>H5"0 tkT]/\Q,d8/NڠuK9v!yo1, uA@jk\rU%p֏ң<ʣ@MjRD 'I-jQ? z{^*UO#T:z^6` "B/4A?-q^}SPdMrG4 ~p1-9bt2"P'Z` P4 oF;u<_IALtj`*r@ v+fOG@G=ɪ3 H,!tXV<p^ h&} gA|h:fMid {.Hӫ^t$ Dũ_@OzųA\rўwK%@% t Zb>h&W %9W 8,ϩ&=' @LnAgy#/y @V@ ZBn> '{:\*y#9ςΝ 2Yvh?`:mCuA3/(pL!]V.=˜:D {F8FҘ hT3OuN)ʭArԓzh@F7wxLF7y\:뻁#ƭ@̜_ hr ( z]?|0:R yCkB$"EgORQ?uRamxˁ#C@S}xnLI$+1A [o@ǼD1O ypÀ _t |3=@W炎EM16\i1 IJ?MvJZA۾C('e>J};_wwVoVg+zy8~l>avAb|8S;Cz ȌdXt63MY6r,1 } U q`(Fgd Q;Jꢆ 2@?5 D;*n$nu@hD /1Xz_rMtL= ڵ/ 䭠7+Wj?^\,͛bI3epQBǠwE;؉%?lu4a߻탠cVatF-6΄љ$2 CP>ZN_qy:}tC\e]Z{:&_qh S^5A>uA5l`Y}A=t|&)ѤA&eR/2$^d6ĸM{ } X^;R\Ʌ=Z! >X;ڹ?)'2 G% q9sӥZR頝2JmJIDATAt+KlulG&'Np!No\ F-5}k U?}=)0{^f2|ONQ$(=z}<|ckzI7/v_@|Nh—:.ҧ۠ PJ\ ݻ-`p|ԧ {@OobbӇk@2iDDgςvkG5WK^R%m@DZV;A|;BY>=bw~r敀bII:~AjK} !qD9Udz9xh 9\$H 6ٵW7kukQh-Bky"H !2&}CNKIx^WI0i')O!vPqfp 0^8BW >=#f LmS @]js/} ?%p](J *U: w}+(iA`%SD{ʈ;U9#|cr>B"  x\'@?PUAE9@|j9tki&| $v`X2zVJP+^>;0dv—S6Agǟ(x&3Dqc2L ]Iw]d[N=dKY'"A|tL1e(Hgy@WUx$|ۡ7WS) ( 0ж<ėGѯ@ĝQcŗɿ1SpE? ;0܁~;1>\ O\?xYTjC?Rhk@^M@(G=~ޗpAϱ˔  6;G/}*/0P7zIDOgNr#0iau%Cyi_u|A߀ԗRhIKZr'= 2M4P[xq޸}'%YFYZ֙U@ }BoY R:M[Wm~t{W34lR7Υ~tܙUs~JxOl=Ȕ@r٭@aQnveЮ'\ dd[qfѠZR{0z kolfݮchSez$At\=h'k#W_"#E \C!|u=]-wW5:yLw  @L'|(} .TH"' ol$pOj_@slu pJ=]Xo0Q$|Ή?< S 8(6l& 7ͼ$+G͝QS[v Uƭ@藅@ыrHe$NH M9 *ç5 ]0K:&>}2|㪵u :pd|]{R <:j_:V= b3|AʾkA WKMnxngd`,W/IO82E޷~*oDdQ{^(_$ :F@ǍG|U.8rJ>пJ>,Sy99 :86:nmNby=77z9;I'B^6O` PB<~ n,˼=y?$p/r/yjwN>WJ_N\+s9YG6r]:Sݹ6r!I7[;T%*諽[A=G4L^W׀l w]AdRkzRW0$2[׃ѯQOhNjz$Yf CwJڙg wD*DVI;hG.T5PH@U}ut>LRIj:5)׃mm uCx)bJ}s\Kb!@+:SÅ nCE݁SUj<^{q CԐ" >=4^8#>KYqm˧4:|A k;EktJk?9S(z/ox{.w%7$[J%\xGSzѓe,x28R1<)$w; (Ft.d 7|7`҃zK2JF(___>{/%55E..4HkW(j^ ުmK>?h-S `H#ź#pڣn* z8 :\t -}e8|;q?0H{UxBU<3͗gtzɿ=p8'֗z 썑W@>جmv5=$a0} 'Ϫ6twD1] KRm"z-HЛX2WܒRP#xkwڗ]݀G>1\`7}G:YePt+`E/єKcOǂdou.'u.Aҭv.6~UA{58 &x2 RxĀj1tmf`dbnnꂚ t8Y& jq#n!>*>*t* A:WnHS`ޮ A -33>Ȼk6@HOA>C@mGop1*ޫ_86AR #x.`Tz؀{h,?C9Ul+ǪZƷ((x?GZg;ՁLҕ t nhamʀz_~ụX{^KV3QLO^fKDq*g~2.m${D] BQ{ƃ_yv4\@|!|fE *TJZڋWoB4LWSIT| s8G#`㺩tsr4:.u$NqVP,"=G:bȶ@M!o~K!M2HA2raWZus;RO@"pϤ! i2UTuyjF5ؗۗۗoo b MN*+9\RM-gu_yn셀Th:9C|[ħf$E `4٥A|6/=BEe}YWCi#3jmݶn[p`3@Γס̀xW]m+mה1/m tMrϓc:+*dhTLWf&v `OyJD|JGF,բ_8vU*'y><#IuR8poO`^+{!++/eY#(sKݟu;rk d7R@P$:;A{2ԹD.^E@w  [e1@[J 4`Sh'V*ږWuѨlҌw۴*eR@e/Q$rATcu zQm6n`:o"soHgj)/2+gkw7h\x0S_ݥ&n#j ǣ6X\.mKfQ$ Qۉ/ 4 /O`eeDdn e-\$,<$դ3rEغknɀ߼5kNla H-8oJg4AB*U}*r_ޣչ"tHx}J 4e5 p|9Hw:@_0ePTX@, #7WZDtbI^F{]#oX^KAG-7Zg*8uAnE?Hߊ*_$cccho7ڃhf4)/

ss-r-ȥr\ 333`ccD?3T+YXX@U]Ac i\+@LY'~pIK:dwYA5zJjs4m`Rw|e`|onh[oNӧ]+Hж`o 煂bN`A ̐!pS('WE e.߀ O wj 4huXmi1iVr_A]]V20z&VoznزBAǹË'[X$cW bA @:9JVWZtmQIT[ɽG!9c,MlF q.1udq_@nU+Ah o~-!Rh"s%#/%s@i%frnwC>|%%vd1>x9nn+? @Ǥ٧HlW%7@L @@g+:N3TKƃaRgHvY,g2U&HH PZ?,IJ!%+ՕJXG#όg39993bǜ +so ʩBDZf /Gԑ$$ |].okQo]CB^@/'-+'RTi :5-,brilTz$J,m \\zz}Kk@G.;xӃ=U7-&c]AMww UM H T]:yivLi :*ލ$N]Y}mpӀKIt>n2h?׀~Y80р@XC7<7#ОKЪ;dn|1$ƥJtOҨ꿼e?u :G] zPa߽KAe>]E ,ٴ/M:#%yǓ/yXwhp_/K,5$_hB }@sT(n@q<nIGGhZԱ^#K؉Hs:˵ T_@Ϭ |eCut ;OQI=]|r9\ .JЗytUq 6_A 3 #jۧV5Jooߡ۱~ӊss败18'1c1 !3N A+_jds9̊fE"TrSMBŬ 7 r; UvJdB-4稞L]F ZmMjA2H_yɄJt-}W޼{. ЮAO+)ypRM n] k7D1\b@ ?" ]U2gV&'5)0?ƒF{ꀶM ,mݖ9_vx,Ŷ׃d9 ) h&'3KszMbHe@* @../0W9Z`<a')IEZ&[ ýR(I޻_ukv{bt[S)E 省^q֫ tض7{{{Ad"@q8ύ@0VmPwU35.<;<;<^f/A#hAݥRw;0ȟ^2GQ}(c1ʀ0DGG]zd 0R r~Y 2`BS˨R Rr ԩiH+kQX\fi +B)m@^2sW=%qfNuo~ȸjƷr AZ@Xotہz"?+~"&g.Ty2O࿕,>S@#Z@֘5$3D%WO-Յ@^ uJL&+ NTPWV[m :JnRIb5gKs=$8{:{vثo0@ &\p">\W\ꛟ$j&R_ P2@W <!t@Ȥ" R`n/.X?m~.7C yz3^Z8(& h٠HJ UgK] @ǽ] KvzГ/@|mL)2*{^{ҟȵ ><偞f- #G%`$s* znɸ͠Q.Hة5$$Lhr P8KFL wZX|[t~W뱧@*.NЇv2Uc-,@IqO"!/4+Z/)c]:9sgNX1+f@T-UK73&;d^rcooouuu,Y<RI='5qgRz)[˴wvt9|vT0s}qo%7 %Nk37(y&x|ZȔ1KU>oM- @ک9"߃\l ,1W&3>> @.6"'0x9ۯ۩qmj(&ng7IOZտwXwП~:lZ:V޵~OɌ2t{E@Dn}wXa&@TQ]"`iFE B,K_N~x*lvF]A/SLZ/$d}vFqx={>*xeT>d)SdXu:011P-T wyL?ّ1qj?I$K%y0`AWW\4{%U=#8ѷ<<=A3]`⟔'͆#@ٔY7A,'l0p5,\j?Z z-] '4H ryי IvB_n?xp!SΛҧl+ڸ}E5?ur]:+ݷٹ ehcPzHD uDș}t[l2p訿\~P 'øEL&țL\:b ~ h(xs*ko Pd&T޳n𦔼z=[,,K#7TVaJNo<Tzꦊ}hP0m ޶-~>x^u Nx!Ց@.5; tOIYޥu[}iFͬ!e/|?>IJbY,{*FQr\+hG7 p.2,---ITIՋ~L`N D;픋m+R,̀3Rn~}nq,yVa} N- ȧKgŠ)G" gTQ&:@(YXm[n>k%6Me_e[pD{͊ *.T}"Swmo+[Mڕܮ- uydofZqVg׃Nn@Q'q'V ڕ<5O=$uԔ~@b,߁Pp6pga3`Qf?_5A ܯw(I?A~A@@6H9TV @կ oQ%G6mKhUA'ҽ0`qd'[ChIgLX̙ٗq`ݼAcŏ?jZVUêa5BP#@~I+49rGGGi4G;5)jR wc8HqI_Ւ!Or07f߂fn@s57+-r#NcU}h oq_$H< T-ڍfu<\o^wZA7wDUAmΡ"uޅ= q5O ` Koj dJ]s/,k^Ζwߩz[noS >UP+K@y|oz%q$)wN$Q{շ@2C/HRbp;-x5|c$mz˅ܞ@Eg`<Izqk⬋=dяAq^ \>2< b=U~q}#;u/vox ^9QkA"^@9(ȵ78SE`9$j'qW: b8u"5C@%un U^BI$Z?ßj/01Va'd|gYqǸc犟;en={ ?W@RJlt=| O\-gǷ 业hY:jHJfgN/wykA/͒ @|4_صZѦꟽ@CQF5W:v-?ܝ/Ձ\&K'{$ zCy_w/\^N'5o{|Wi֠n nM\ LL*@*z@" be[0in ku!¬] Pn";oπd].}{Agz nG1A_ 23AYVi jx՗Ͽ_T6L^UtVt .գ?- :,4LtPs˂~'zq w*]x@8Aҩ AGrЯ9 c!.[n6[W7#\)RxI3 =eX'~N{GDPQuT0Jwl.\&MJjN:5 Rk|p%(X2r][铇\&xݳmܧ:7SH_E /1܍EK(OY$}dN_ŝ5FЛrA2Y@+9rxзإ-%kxA'ьϗB3Sw[-+c7AK:Kд_]"! R/3؉ >gFt$hK>:g7=zKAͭ>+ V?ȮfD-d߼͠_/_G6~ag  s47;m;֪sн>>P ~O 'hOv@8"Հ?xTg}?m_ :$2NDE+$x;% jt8FTcHY= rTݦAЭpp7^7q-HhdBܾ5r9- ?,.Qm\ ")"yCf̾}! );xєp֒w;yNEEEPx`Apwws*ϩ<F Ɵ5 fk-]x5 -ѡu?ڕ`Mi|ClX6 .{vI㎕)xC#vW1IMd$R\Π#lwY7QB1HM#+UPpmwa_rQ-_vfek^֜i|恤%tG?N}h[#Aǂ3&2>vkEZ_ ]ƫ@W@,ʥZ -S' M 4 ?(\ =N:v=Pa HM|skΊ GfJ$coEJuO74C9 z؁ߝ c$聒 3M32E c uw s2>h,e/0M9o$0M?V!9O* B+?{uM,lRؤ x^|,[ͭVPkZ ~ qꢺ.`̀_3_3_3 e[>e}Dpy}hjp;l'q "Fr;ڬҍ;^rգAZ݋27${Hټi>gmй̈0i&4 Ef!(;uA&Gyb%%A4g, _rT)kPwKy`^TF 0l3uD2} @bHT#H0ӍP4hn\(--΅TRϘ㯑9lSnoBI;vg6` dlmsMI jK%%mA;Lu%8>+Tk^:jOp€Y"*񺂎{J4.@z-}Z4:YN```ZZKkSNf0`2F+++r'NȝJgR356ڴ %[x7XI}$CfPtޝ8ŨVw[fVCs6IdqGN į~sW-yb!*%W%X/ CM Aջ '|9jj.^>xF+w2Q;yN~\*R+ДPUp_\雞 }3*SR[j}\c-ccF:?6@@_@724H\5s԰f^dV=EPL.H iKyP/B@+q իݢfp^:[ލc?`%QJ/* X2Cz2DS pHaxY}߃TBwpF΢Kl_-ޝ?^^ҜAo`P&}K!00 : pʞmH?t@tu ` 6il6"+1?Z֮NԢES]Iv?J,r|PS>+++[?~n}s93 3祥 4x{P'? c{K-րGd=w:/[~<|̑]/8?7p@_4+T gY@^Xw$aiDgĐP@jHtS瀶Y@,3fR{t{|ɇLߌmֿp yJ+IfA;G[@,fc3.L#hRRY4ȔWb;ċ) >)!-fZHYŶWv111pl± &@cc#Rߏ38k-' hIzw7sss/xdP9r^<0~2~2~о?4^:B>9 T#HHSwF÷܄:fN3IwEt4KIXҧE'w4mZT=A z :LX*FցvsS *I((, K8!>Pսs.8M?4 R(fGU돀:JFoWiy>t:.}URgsA_u:n999crLYdįz6 dI&888@! !((_P<͠4BBBCP>5ᐚo|eF:t!9Fb!ko"y $+:KGJX_E {U7*ҶL=%xCbG9-_~@GTg@K o={0u|RoqM@z|f-+^}-!c&Y&H-LVwrAuu=$`?j?:3j:QLH ]^!ڭBctم޼ԍWCZ#X(gHUw]p$H֑,5553nϸwj e(C~pBN!oe+[o7ƃcVprr C9ܐrC 2轅VxZž,|>2o |n *ja/US >hh]):p/qg!<xI"`r+>wz.R@eU@{COM~ūoә&>s=ñ *N:^c]f]f]R>OFY,={:v\?Hu%o`8>9p ~2QQL$Wl*AEU gQbo= UہtWTjxRO'hߒ6 cpCA. K@Ōc: .8pA6@o>pr_\VƟp'-3w}#|ja^+@.)ɄJt vN"jM I&E >2g)#q); tqwCz*u/c /;/;/ ),iii87pn\L˴LPx5G''Rgj&yfO?P~(?)RjԂNr;AW_ ɌSMyQ͂9unm6Knod. F;<*k}RHBUCKEDDQ^+83RTAGEQPF -CB?eq|gFsr}}^guĸW@RtSrU 1בhr<Nj.He?wt5,@)NpZ7><ȋyrNJMS@,5R I<|gQ )^FeSyʫOW#@%ç|~:ȫi7~*n8S`O+Y_)?2] x+w5xi!t;Trqх w+]]R;(MVX4Ǣjwm̆'XkGB )Nw=H+kkkooo)z*UT6S_] jpGloXA Vʛ7ˑ#/Ca)Stg-f ĭ!oN#i8B⯧z;} T[@5D  CUnF| 12v,\[(A qQt\pГk_׀IJM Iv ^)}ҺMV؁xU|PDχk;Ak|뷂X㓪;Q2^nֻ\꺌ˏW7oK7C|G>[4Kmˀ6\߱nqn8c_<2>`75PpA)Xs ֲf O^ ǯw$UNwYMSPD\k\+ ƘFG!~u95Oz0WWW@Q&EM ((O'hg#[x"TQ݋݋݋렢ME6#zDkB븎0]%c˪ @/ټ0$3L0 f_S|;H9t|*]xXRА^B${e 8rTep@iC.>w`xێm|UNf'Ӯ.`J 1=lN>VrmN 1EA7: !ʍc|rGiQ x;qi]ԟѱ1x w_ 8TڤzS7 ~z/NvKAM MsO[ns!|1/`[{A;0g *7vٻ⟕y[pn7UR\.ŠiEgֲ)'8V'xk@uq߱̚PҲeIK85ԜSs ᙄg,g3`1}@S0A ﾳȕUg%^[ 9W^`3%%%f{ĚkN`7{)ɹ͠K ;.Z >tr:#äGA5gAq P"5(;<$Xv<htu#^':Hr7^a f&񪺻I@,}YI}T,9崎$H D?#H'҅I5ZꦌW$dO7ꀌvrڃD+?s䶀]*#=c;zG:I%N}ufnIKs>In _56 %m8 UƄW[i@,Y`wVޅzŃR@Oߞ!CNpH8p0 5FgЊb5=~wvq1o%dIyuAH+3e3@5\^IL: r5P~C8e^{=~$iueon_:4r Qyz(Wp/@z Q EPo7(K>QrRMAkVWyܚu_z_2j;P q8i*0i -mڵ{3=+wUOhpjƝ/@$Jh<'S2%EѢ(&&&B†  kBׄ c1Z].0L'&gZ偯3gj`c亓Nc1K5~4ֽۖj(؇ 3!:bP5yrg;#e΀8L@#UiuՃU̚\V]5Q:=@*KA%uE\mQ@V iu!@vۋ PqFP. yXi_8? $zІwu@^] *hI-П*'\ RDcʚ Zy,Dݯ\M{$r6u__Aˀ\0hKPR-@Lo\o";vFFb禐6ѓ5}Pо}A{QIFAp]p]pW\FWzOOvO&"Dp`{=v܎]]]eח]_v=ez^;Z(d{S|T,_s%yW7HC@p Qz< jP՛;2y2V;84L@ &o ޑݯϚiT @Tu b3Z} @hF+=rWJ%j?-K'&cTLpjxߓ⌓%}:粫qNem1֔Jf{ݿHUٓ072`8cJeoxMO3=Y-%m]$i J,M> M:\ M)N~$1G[\7kiYEN!eC`,ݛ=MHH S2L34H<5y*y<_~m?!XZւ>QOs\ gPv(; 5t!08080N|7ñnǺXcHִH|?iW+u?M|S7p)XY` x < 2D~pPiQh"=Ö,:^ [s4;**- [ joN\>@ej@[ߴE~W9ڣ5UC Ec*YWZż0>wnZمF @NxÝ, j]rF;5rG>a% P֦|=Biq~{*:twRC}6`o[o9f*`E#ɑ#G8j5EۢmnL{==Te^Wgv]jBVV@3ϔ?!CzH<&y Յ1AGC侣Fm+;u>;`&j'AP2T7\)7u mjՇjtP;2ִ*ue#he^; L<$=+QsD}R}=<%9#0T[ HܚY8 pX.ŠY|o R4z$q}þ=^+޴@z3^*9*2ozSƵ?r΀:0EeUf7gP֭[Y7(ƢQb$ޝxw `7ɗTЌf47?8*m3iCo7 vcV]wAɄ '!@@@ ]QTD;ql!d'@. Q$lS%zT5%}i}{;hHt! FK.6dհЁ2KAK@zQxwMJ%A:P>_NwAbzZ»3ZZjr5(Ьy' ͻ>*TWXoRꃼjέ J T4M`yuue`mP!p;TNpooo BV?şPs9A34C3`g?W #B^;Xk5bccb@ŀ^^^ )-RZ5kfQjsTLxFN@좢&{o(>; E}vlU/޹`W| ;qxۇ@⯟Z j!-VP؏ylԳ7G5\fB2|􁃠Bj 8Si@P8K݅z gTkSw sc ;]%7ԯz +A^!$Y{OKHw_waw{P) 1fu/4'ͧp'rxVY g3ǸǸBSCSCS!33|`5ǚcA#C__/:h@Mt9;E:iQi B󂔛@^$=@nj+HwNw?m/!ӓtaD0/jG&+zZ&_k5&w;!oÿ=%{J2BBB `0]5]'I5i+98^|oG8>^kܸw`ϱshBkk+DGGC'@{H{H{R)0|iʧ`6GRMzpG58VpCUiS;Ksव%T60iz7@[L$HxQOP>U{ԫjP)wၼjւ.&G 4 4joZ'wydcj]PB-Ɨ5^4Z5w*e{kV ,c}p Ѐtv{^}}}vnJJJ. . .twf]-???j~ ;rXayCw׻뫳8{=? Xn,b'b'b'@-UKRHj6-lMٚ333A].S1g x;+v/֭Rp&G;X粅v n_E@Ů9>$ədwv2J@P8-uzh x#x9 Zf虼 =?D@o6Pbdv) ~dlpn8-.[ e/{!..@]&f A#hAߤo7B[6@s H1D)D%Dnw{{{`هgճA|^|^|ܘsp@`n`n`.$On'O_/o l>`"d |ʝp /N@g5C;lZpgJiFBK@Ȳe#!.q IzZZZ`6w8i4NMۦmvD;Qr'1gw 7qPE4TF܈mZH`Y N;`X)V ijaaa1cRG   P:Ǟt`m6[+,r%|5}5}5!//|`jfj`nnc1e2mh_j_j_RJ) e(C?3p Tɝ|^cQ(wE"pN =Þa't2du:A|Z|Z|؞g^f/ST @n 7 555/ח| xpqq6c7n4fG`ױu@-Wr0f Js5s WWWXm=YO֓Af٠"*"0jB/~1UJ/La S@$I@1p B[[[q3 \\\p;`w]^mWagnq[8=Gfv3ffflkRRR5kAVhPPzE^zы^_}! a2 ԒZ 3eJ$usγor+OySբg_2A&ղZV$J$ 2lfSd{y B6 j6K-Wr%iIehZh-ZK:hWVo ZC@+zGSeW-T NSq&_db]8#jZf:ә2P@\Ùq&M)keY&dx ŲXd씝 R! u,38'WyW(LqhPs\5' 8tAe,zWʗju,-KUKRr6O:Hzޚִ?>q9.E@>2\%J{{{R-qKw;,w;E*)""vegX[-J uuuennnnnnVԊ{+%XX"Tw;Uk5xyyHKi)-EiyZIDATh޽wU_~>ߚJ! BB' M@Q@iRDQQ)"")" !J ')wXgvܙݙy9} Y,,,>I;βnoϴzSb6V?i??*WALwEg^YLވdԭxH(yq:o􍠺LW횆X U՗ تw  G5g$IJ[]A/I= -W@%@7~4Ձ1z^`M C'kZc 89@ڐ?sy< wi.v984UϱeL51&XT`ڠhuo`ɮ{. Dow W3@H|9ap9 _z9U~9"ZAm %%>mQy%~0Ptf5jAs!` T=Kbze we zD<̭ d XGNv:ළɠgt.Bgk/Z[)@(.^zO[Vq<rIb5  @s".i$9 ^r4 _]g]h}c!>} ڷ?Xƹ*xk}+@wݨlࣨs>:bV2?te`@ൢ~NSe-H 4qra'f.zd= (9טLHONQ, .+*8Pq5 .Qu_꒬+.OȈ`xmeUi 0yU*< zX Ĉ*ցe@f}zbsϜE8 vA֟* NyW9ׂG"JDAq]B ?*^{yç]zt*BX_ui+u18sqYK|f~bs5f۴Rg@W n%A܈+sEׁ32_q /Zʇ.BQKzg zښgBܵ}׻9 R2&Ztc2zq9εa@= /gTh1T}( a\ Ds$`^ "a@yg-{Uaػ1okz<zj)ȴkdǶyI36ҖXٱ sN?Z3ADWaN/)bUb20j { t^L*f4ѨZD}y+O ͽ@EO\ h@o).gi˟lh|`rdnA`xq荍?/ XSw΂**{ꡙ@փz OϪ~[ u\}7R3P=IVTZ-uK%]10WS #vSP)*^7#2c+F+Y3 ԺЯesje@D}֙ 78+8\gvzϼA~[\55~p[w1E,;G C<`y Xp~ y5Y e=2?@'pZe~(/`۟5'4U5k1`k[ ;#AM(" tPu *[1D5 PVQoVlb.*[*{ہCe7A1;A}X]@Ji*q@1]v&ô:^2]=nE>v)z5՟L.y%*Bp>r]ծjWAHFnN\ ^)y*gq4*A :ktىA .)8u> "V\&X/* IkfW1Tvׁ;t#P-`P $T/X*`. vM큨Eݬ0Ζ/0>999A Jh4ı%`X9 ^EdL(< !RC%ch sا՛(J;VS.^U7u`W)Y n!Pd{/6ڳغ{v\}Cse@ 5X*7%4eW 2?n5bzߌx2hY{թyn9\"N0wjFcM#߫@  FeC` c v8q?94T|Zw,cX&@c9W[PgH(5KO>7Y{/\*5d@Э;@TP!_bjkO-]=BV{A%{zҕ?FH" w, _7gv̹/9Q=(y *jWuGo00DZ𱠬mUtyfXo TKl0iu5V> Ŏ?-o7a`9YH餓_o .91ʏg{V-ڠeK:=^0J"[S9#īvq?X L 8~|j;ݞ).r*Xv#_jVqݛK^զ@] ]! kBy&e`[.PS Kp}}}I$}20?wkf1G\j.5u˺c{TA~"WwAu:ccc z gLe*pTov%tEXtdate:create2014-12-31T13:30:38+02:00dQ%tEXtdate:modify2014-10-17T01:10:21+03:00BaGtEXtsvg:base-urifile:///home/andrew/projects/aiohttp/docs/aiohttp-icon.svg!hIENDB`aiohttp-1.2.0/docs/index.rst0000664000175000017500000001161113025134363016617 0ustar travistravis00000000000000.. aiohttp documentation master file, created by sphinx-quickstart on Wed Mar 5 12:35:35 2014. You can adapt this file completely to your liking, but it should at least contain the root `toctree` directive. aiohttp: Asynchronous HTTP Client/Server ======================================== HTTP client/server for :term:`asyncio` (:pep:`3156`). .. _GitHub: https://github.com/KeepSafe/aiohttp .. _Freenode: http://freenode.net Features -------- - Supports both :ref:`aiohttp-client` and :ref:`HTTP Server `. - Supports both :ref:`Server WebSockets ` and :ref:`Client WebSockets ` out-of-the-box. - Web-server has :ref:`aiohttp-web-middlewares`, :ref:`aiohttp-web-signals` and pluggable routing. Library Installation -------------------- .. code-block:: bash $ pip install aiohttp You may want to install *optional* :term:`cchardet` library as faster replacement for :term:`chardet`: .. code-block:: bash $ pip install cchardet For speeding up DNS resolving by client API you may install :term:`aiodns` as well. This option is highly recommended: .. code-block:: bash $ pip install aiodns Getting Started --------------- Client example:: import aiohttp import asyncio import async_timeout async def fetch(session, url): with async_timeout.timeout(10): async with session.get(url) as response: return await response.text() async def main(loop): async with aiohttp.ClientSession(loop=loop) as session: html = await fetch(session, 'http://python.org') print(html) loop = asyncio.get_event_loop() loop.run_until_complete(main(loop)) Server example:: from aiohttp import web async def handle(request): name = request.match_info.get('name', "Anonymous") text = "Hello, " + name return web.Response(text=text) app = web.Application() app.router.add_get('/', handle) app.router.add_get('/{name}', handle) web.run_app(app) .. note:: Throughout this documentation, examples utilize the `async/await` syntax introduced by :pep:`492` that is only valid for Python 3.5+. If you are using Python 3.4, please replace ``await`` with ``yield from`` and ``async def`` with a ``@coroutine`` decorator. For example, this:: async def coro(...): ret = await f() should be replaced by:: @asyncio.coroutine def coro(...): ret = yield from f() Tutorial -------- :ref:`Polls tutorial ` Source code ----------- The project is hosted on GitHub_ Please feel free to file an issue on the `bug tracker `_ if you have found a bug or have some suggestion in order to improve the library. The library uses `Travis `_ for Continuous Integration. Dependencies ------------ - Python 3.4.2+ - *chardet* - *multidict* - *async_timeout* - *yarl* - *Optional* :term:`cchardet` as faster replacement for :term:`chardet`. Install it explicitly via: .. code-block:: bash $ pip install cchardet - *Optional* :term:`aiodns` for fast DNS resolving. The library is highly recommended. .. code-block:: bash $ pip install aiodns Discussion list --------------- *aio-libs* google group: https://groups.google.com/forum/#!forum/aio-libs Feel free to post your questions and ideas here. Contributing ------------ Please read the :ref:`instructions for contributors` before making a Pull Request. Authors and License ------------------- The ``aiohttp`` package is written mostly by Nikolay Kim and Andrew Svetlov. It's *Apache 2* licensed and freely available. Feel free to improve this package and send a pull request to GitHub_. .. _aiohttp-backward-compatibility-policy: Policy for Backward Incompatible Changes ---------------------------------------- *aiohttp* keeps backward compatibility. After deprecating some *Public API* (method, class, function argument, etc.) the library guaranties the usage of *deprecated API* is still allowed at least for a year and half after publishing new release with deprecation. All deprecations are reflected in documentation and raises :exc:`DeprectaionWarning`. Sometimes we are forced to break the own rule for sake of very strong reason. Most likely the reason is a critical bug which cannot be solved without major API change, but we are working hard for keeping these changes as rare as possible. Contents -------- .. toctree:: client client_reference tutorial web web_reference web_lowlevel abc multipart streams api logging testing deployment faq third_party server essays contributing changes glossary Indices and tables ================== * :ref:`genindex` * :ref:`modindex` * :ref:`search` .. disqus:: :title: aiohttp documentation aiohttp-1.2.0/docs/changes.rst0000664000175000017500000000017113025134363017117 0ustar travistravis00000000000000.. _aiohttp_changes: .. include:: ../CHANGES.rst .. include:: ../HISTORY.rst .. disqus:: :title: aiohttp changelog aiohttp-1.2.0/docs/essays.rst0000664000175000017500000000007513025134363017021 0ustar travistravis00000000000000Essays ====== .. toctree:: new_router whats_new_1_1 aiohttp-1.2.0/docs/glossary.rst0000664000175000017500000000423513025134363017357 0ustar travistravis00000000000000.. _aiohttp-glossary: ========== Glossary ========== .. if you add new entries, keep the alphabetical sorting! .. glossary:: :sorted: aiodns DNS resolver for asyncio. https://pypi.python.org/pypi/aiodns asyncio The library for writing single-threaded concurrent code using coroutines, multiplexing I/O access over sockets and other resources, running network clients and servers, and other related primitives. Reference implementation of :pep:`3156` https://pypi.python.org/pypi/asyncio/ callable Any object that can be called. Use :func:`callable` to check that. chardet The Universal Character Encoding Detector https://pypi.python.org/pypi/chardet/ cchardet cChardet is high speed universal character encoding detector - binding to charsetdetect. https://pypi.python.org/pypi/cchardet/ gunicorn Gunicorn 'Green Unicorn' is a Python WSGI HTTP Server for UNIX. http://gunicorn.org/ keep-alive A technique for communicating between HTTP client and server when connection is not closed after sending response but kept open for sending next request through the same socket. It makes communication faster by getting rid of connection establishment for every request. nginx Nginx [engine x] is an HTTP and reverse proxy server, a mail proxy server, and a generic TCP/UDP proxy server. https://nginx.org/en/ resource A concept reflects the HTTP **path**, every resource corresponds to *URI*. May have a unique name. Contains :term:`route`\'s for different HTTP methods. route A part of :term:`resource`, resource's *path* coupled with HTTP method. web-handler An endpoint that returns HTTP response. websocket A protocol providing full-duplex communication channels over a single TCP connection. The WebSocket protocol was standardized by the IETF as :rfc:`6455` yarl A library for operating with URL objects. https://pypi.python.org/pypi/yarl .. disqus:: :title: aiohttp glossary aiohttp-1.2.0/examples/0000775000175000017500000000000013025135427015646 5ustar travistravis00000000000000aiohttp-1.2.0/examples/websocket.html0000664000175000017500000000452113025134363020522 0ustar travistravis00000000000000

Chat!

 | Status: disconnected
aiohttp-1.2.0/examples/static_files.py0000775000175000017500000000023613025134363020673 0ustar travistravis00000000000000import pathlib from aiohttp import web app = web.Application() app.router.add_static('/', pathlib.Path(__file__).parent, show_index=True) web.run_app(app) aiohttp-1.2.0/examples/fake_server.py0000775000175000017500000001137213025134363020521 0ustar travistravis00000000000000import asyncio import pathlib import socket import ssl import aiohttp from aiohttp import web from aiohttp.resolver import DefaultResolver from aiohttp.test_utils import unused_port def http_method(method, path): def wrapper(func): func.__method__ = method func.__path__ = path return func return wrapper def head(path): return http_method('HEAD', path) def get(path): return http_method('GET', path) def delete(path): return http_method('DELETE', path) def options(path): return http_method('OPTIONS', path) def patch(path): return http_method('PATCH', path) def post(path): return http_method('POST', path) def put(path): return http_method('PUT', path) def trace(path): return http_method('TRACE', path) class FakeResolver: _LOCAL_HOST = {0: '127.0.0.1', socket.AF_INET: '127.0.0.1', socket.AF_INET6: '::1'} def __init__(self, fakes, *, loop): """fakes -- dns -> port dict""" self._fakes = fakes self._resolver = DefaultResolver(loop=loop) async def resolve(self, host, port=0, family=socket.AF_INET): fake_port = self._fakes.get(host) if fake_port is not None: return [{'hostname': host, 'host': self._LOCAL_HOST[family], 'port': fake_port, 'family': family, 'proto': 0, 'flags': socket.AI_NUMERICHOST}] else: return await self._resolver.resolve(host, port, family) class FakeFacebook: def __init__(self, *, loop): self.loop = loop self.app = web.Application(loop=loop) for name in dir(self.__class__): func = getattr(self.__class__, name) if hasattr(func, '__method__'): self.app.router.add_route(func.__method__, func.__path__, getattr(self, name)) self.handler = None self.server = None here = pathlib.Path(__file__) ssl_cert = here.parent / 'server.crt' ssl_key = here.parent / 'server.key' self.ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) self.ssl_context.load_cert_chain(str(ssl_cert), str(ssl_key)) async def start(self): port = unused_port() self.handler = self.app.make_handler() self.server = await self.loop.create_server(self.handler, '127.0.0.1', port, ssl=self.ssl_context) return {'graph.facebook.com': port} async def stop(self): self.server.close() await self.server.wait_closed() await self.app.shutdown() await self.handler.shutdown() await self.app.cleanup() @get('/v2.7/me') async def on_me(self, request): return web.json_response({ "name": "John Doe", "id": "12345678901234567" }) @get('/v2.7/me/friends') async def on_my_friends(self, request): return web.json_response({ "data": [ { "name": "Bill Doe", "id": "233242342342" }, { "name": "Mary Doe", "id": "2342342343222" }, { "name": "Alex Smith", "id": "234234234344" }, ], "paging": { "cursors": { "before": "QVFIUjRtc2c5NEl0ajN", "after": "QVFIUlpFQWM0TmVuaDRad0dt", }, "next": ("https://graph.facebook.com/v2.7/12345678901234567/" "friends?access_token=EAACEdEose0cB") }, "summary": { "total_count": 3 }}) async def main(loop): token = "ER34gsSGGS34XCBKd7u" fake_facebook = FakeFacebook(loop=loop) info = await fake_facebook.start() resolver = FakeResolver(info, loop=loop) connector = aiohttp.TCPConnector(loop=loop, resolver=resolver, verify_ssl=False) async with aiohttp.ClientSession(connector=connector, loop=loop) as session: async with session.get('https://graph.facebook.com/v2.7/me', params={'access_token': token}) as resp: print(await resp.json()) async with session.get('https://graph.facebook.com/v2.7/me/friends', params={'access_token': token}) as resp: print(await resp.json()) await fake_facebook.stop() loop = asyncio.get_event_loop() loop.run_until_complete(main(loop)) aiohttp-1.2.0/examples/basic_srv.py0000775000175000017500000000274413025134363020203 0ustar travistravis00000000000000#!/usr/bin/env python3 """Basic HTTP server with minimal setup""" import asyncio from urllib.parse import parse_qsl, urlparse import aiohttp import aiohttp.server from aiohttp import MultiDict class HttpRequestHandler(aiohttp.server.ServerHttpProtocol): @asyncio.coroutine def handle_request(self, message, payload): response = aiohttp.Response( self.writer, 200, http_version=message.version) get_params = MultiDict(parse_qsl(urlparse(message.path).query)) if message.method == 'POST': post_params = yield from payload.read() else: post_params = None content = "

It Works!

" if get_params: content += "

Get params

" + str(get_params) + "

" if post_params: content += "

Post params

" + str(post_params) + "

" bcontent = content.encode('utf-8') response.add_header('Content-Type', 'text/html; charset=UTF-8') response.add_header('Content-Length', str(len(bcontent))) response.send_headers() response.write(bcontent) yield from response.write_eof() if __name__ == '__main__': loop = asyncio.get_event_loop() f = loop.create_server( lambda: HttpRequestHandler(debug=True, keep_alive=75), '0.0.0.0', 8080) srv = loop.run_until_complete(f) print('serving on', srv.sockets[0].getsockname()) try: loop.run_forever() except KeyboardInterrupt: pass aiohttp-1.2.0/examples/web_ws.py0000775000175000017500000000277113025134363017516 0ustar travistravis00000000000000#!/usr/bin/env python3 """Example for aiohttp.web websocket server """ import asyncio import os from aiohttp.web import (Application, Response, WebSocketResponse, WSMsgType, run_app) WS_FILE = os.path.join(os.path.dirname(__file__), 'websocket.html') async def wshandler(request): resp = WebSocketResponse() ok, protocol = resp.can_prepare(request) if not ok: with open(WS_FILE, 'rb') as fp: return Response(body=fp.read(), content_type='text/html') await resp.prepare(request) try: print('Someone joined.') for ws in request.app['sockets']: ws.send_str('Someone joined') request.app['sockets'].append(resp) async for msg in resp: if msg.type == WSMsgType.TEXT: for ws in request.app['sockets']: if ws is not resp: ws.send_str(msg.data) else: return resp return resp finally: request.app['sockets'].remove(resp) print('Someone disconnected.') for ws in request.app['sockets']: ws.send_str('Someone disconnected.') async def on_shutdown(app): for ws in app['sockets']: await ws.close() async def init(loop): app = Application(loop=loop) app['sockets'] = [] app.router.add_get('/', wshandler) app.on_shutdown.append(on_shutdown) return app loop = asyncio.get_event_loop() app = loop.run_until_complete(init(loop)) run_app(app) aiohttp-1.2.0/examples/client_auth.py0000775000175000017500000000105013025134363020514 0ustar travistravis00000000000000import asyncio import aiohttp async def fetch(session): print('Query http://httpbin.org/basic-auth/andrew/password') async with session.get( 'http://httpbin.org/basic-auth/andrew/password') as resp: print(resp.status) body = await resp.text() print(body) async def go(loop): async with aiohttp.ClientSession( auth=aiohttp.BasicAuth('andrew', 'password'), loop=loop) as session: await fetch(session) loop = asyncio.get_event_loop() loop.run_until_complete(go(loop)) aiohttp-1.2.0/examples/client_ws.py0000775000175000017500000000433513025134363020215 0ustar travistravis00000000000000#!/usr/bin/env python3 """websocket cmd client for wssrv.py example.""" import argparse import asyncio import signal import sys import aiohttp try: import selectors except ImportError: from asyncio import selectors def start_client(loop, url): name = input('Please enter your name: ') # send request ws = yield from aiohttp.ws_connect(url, autoclose=False, autoping=False) # input reader def stdin_callback(): line = sys.stdin.buffer.readline().decode('utf-8') if not line: loop.stop() else: ws.send_str(name + ': ' + line) loop.add_reader(sys.stdin.fileno(), stdin_callback) @asyncio.coroutine def dispatch(): while True: msg = yield from ws.receive() if msg.type == aiohttp.WSMsgType.TEXT: print('Text: ', msg.data.strip()) elif msg.type == aiohttp.WSMsgType.BINARY: print('Binary: ', msg.data) elif msg.type == aiohttp.WSMsgType.PING: ws.pong() elif msg.type == aiohttp.WSMsgType.PONG: print('Pong received') else: if msg.type == aiohttp.WSMsgType.CLOSE: yield from ws.close() elif msg.type == aiohttp.WSMsgType.ERROR: print('Error during receive %s' % ws.exception()) elif msg.type == aiohttp.WSMsgType.CLOSED: pass break yield from dispatch() ARGS = argparse.ArgumentParser( description="websocket console client for wssrv.py example.") ARGS.add_argument( '--host', action="store", dest='host', default='127.0.0.1', help='Host name') ARGS.add_argument( '--port', action="store", dest='port', default=8080, type=int, help='Port number') if __name__ == '__main__': args = ARGS.parse_args() if ':' in args.host: args.host, port = args.host.split(':', 1) args.port = int(port) url = 'http://{}:{}'.format(args.host, args.port) loop = asyncio.SelectorEventLoop(selectors.SelectSelector()) asyncio.set_event_loop(loop) loop.add_signal_handler(signal.SIGINT, loop.stop) asyncio.Task(start_client(loop, url)) loop.run_forever() aiohttp-1.2.0/examples/server.key0000664000175000017500000000321313025134363017663 0ustar travistravis00000000000000-----BEGIN RSA PRIVATE KEY----- MIIEowIBAAKCAQEA5SCSfeNf+x2DoYa54YMcIz6ychRVjd8zoPiNePIGGdPdOoob WUnAIZhHXUAP7ZIlimlT7DhBoXphnAx5kErL6ZVD34KtVjIpATuP0fxeA0QdX0FD OitqBPyWJrx4Llo5DNR5fwDEJJJuyfJP9f5LUgp13S3Es55k4PqlbAmhzd2kMQuC WTZvW3OHI3YaNC/dpEePnk/HvXbsx5nJFfA4MWleulufCKHg6qQDgRi2aoVtm20Y TMyF3hjmaRvK5FsYz4gT32hAky+ciSMB9SjRoqcOtwAiRYKTAshyL1Mgbq7dHU/Z Of4dhWe3NBngGfFqdsU1DlL0BF3fnb0SY7cHNQIDAQABAoIBAG9BJ6B03VADfrzZ vDwh+3Gpqd/2u6wNqvYIejk123yDATLBiJIMW3x0goJm7tT+V7gjeJqEnmmYEPlC nWxQxT6AOdq3iw8FgB+XGjhuAAA5/MEZ4VjHZ81QEGBytzBaosT2DqB6cMMJTz5D qEvb1Brb9WsWJCLLUFRloBkbfDOG9lMvt34ixYTTmqjsVj5WByD5BhzKH51OJ72L 00IYpvrsEOtSev1hNV4199CHPYE90T/YQVooRBiHtTcfN+/KNVJu6Rf/zcaJ3WMS 1l3MBI8HwMimjKKkbddpoMHyFMtSNmS9Yq+4a9w7XZo1F5rt88hYSCtAF8HRAarX 0VBCJmkCgYEA9HenBBnmfDoN857femzoTHdWQQrZQ4YPAKHvKPlcgudizE5tQbs0 iTpwm+IsecgJS2Rio7zY+P7A5nKFz3N5c0IX3smYo0J2PoakkLAm25KMxFZYBuz4 MFWVdfByAU7d28BdNfyOVbA2kU2eal9lJ0yPLpMLbH8+bbvw5uBS808CgYEA7++p ftwib3DvKWMpl6G5eA1C2xprdbE0jm2fSr3LYp/vZ4QN2V6kK2YIlyUqQvhYCnxX oIP3v2MWDRHKKwJtBWR4+t23PaDaSXS2Ifm0qhRxwSm/oqpAJQXbR7VzxXp4/4FP 1SgkLe51bubc4h+cDngqBLcplCanvj52CqhqzDsCgYAEIhG8zANNjl22BLWaiETV Jh9bMifCMH4IcLRuaOjbfbX55kmKlvOobkiBGi3OUUd28teIFSVF8GiqfL0uaLFg 9XkZ1yaxe+or3HLjz1aY171xhFQwqcj4aDoCqHIE+6Rclr/8raxqXnRNuJY5DivT okO5cdr7lpsjl83W2WwNmQKBgCPXi1xWChbXqgJmu8nY8NnMMVaFpdPY+t7j5U3G +GDtP1gZU/BKwP9yqInblWqXqp82X+isjg/a/2pIZAj0vdB2Z9Qh1sOwCau7cZG1 uZVGpI+UavojsJ1XOKCHrJmtZ/HTIVfYPT9XRdehSRHGYwuOS8iUi/ODqr8ymXOS IRINAoGBAMEmhTihgFz6Y8ezRK3QTubguehHZG1zIvtgVhOk+8hRUTSJPI9nBJPC 4gOZsPx4g2oLK6PiudPR79bhxRxPACCMnXkdwZ/8FaIdmvRHsWVs8T80wID0wthI r5hW4uqi9CcKZrGWH7mx9cVJktspeGUczvKyzNMfCaojwzA/49Z1 -----END RSA PRIVATE KEY----- aiohttp-1.2.0/examples/background_tasks.py0000775000175000017500000000360413025134363021550 0ustar travistravis00000000000000#!/usr/bin/env python3 """Example of aiohttp.web.Application.on_startup signal handler""" import asyncio import aioredis from aiohttp.web import Application, WebSocketResponse, run_app async def websocket_handler(request): ws = WebSocketResponse() await ws.prepare(request) request.app['websockets'].append(ws) try: async for msg in ws: print(msg) await asyncio.sleep(1) finally: request.app['websockets'].remove(ws) return ws async def on_shutdown(app): for ws in app['websockets']: await ws.close(code=999, message='Server shutdown') async def listen_to_redis(app): try: sub = await aioredis.create_redis(('localhost', 6379), loop=app.loop) ch, *_ = await sub.subscribe('news') async for msg in ch.iter(encoding='utf-8'): # Forward message to all connected websockets: for ws in app['websockets']: ws.send_str('{}: {}'.format(ch.name, msg)) print("message in {}: {}".format(ch.name, msg)) except asyncio.CancelledError: pass finally: print('Cancel Redis listener: close connection...') await sub.unsubscribe(ch.name) await sub.quit() print('Redis connection closed.') async def start_background_tasks(app): app['redis_listener'] = app.loop.create_task(listen_to_redis(app)) async def cleanup_background_tasks(app): print('cleanup background tasks...') app['redis_listener'].cancel() await app['redis_listener'] async def init(loop): app = Application(loop=loop) app['websockets'] = [] app.router.add_get('/news', websocket_handler) app.on_startup.append(start_background_tasks) app.on_cleanup.append(cleanup_background_tasks) app.on_shutdown.append(on_shutdown) return app loop = asyncio.get_event_loop() app = loop.run_until_complete(init(loop)) run_app(app) aiohttp-1.2.0/examples/web_rewrite_headers_middleware.py0000775000175000017500000000153513025134363024433 0ustar travistravis00000000000000#!/usr/bin/env python3 """ Example for rewriting response headers by middleware. """ import asyncio from aiohttp.web import Application, HTTPException, Response, run_app @asyncio.coroutine def handler(request): return Response(text="Everything is fine") @asyncio.coroutine def middleware_factory(app, next_handler): @asyncio.coroutine def middleware(request): try: response = yield from next_handler(request) except HTTPException as exc: response = exc if not response.prepared: response.headers['SERVER'] = "Secured Server Software" return response return middleware def init(loop): app = Application(loop=loop, middlewares=[middleware_factory]) app.router.add_get('/', handler) return app loop = asyncio.get_event_loop() app = init(loop) run_app(app) aiohttp-1.2.0/examples/cli_app.py0000775000175000017500000000261613025134363017635 0ustar travistravis00000000000000""" Example of serving an Application using the `aiohttp.web` CLI. Serve this app using:: $ python -m aiohttp.web -H localhost -P 8080 --repeat 10 cli_app:init \ > "Hello World" Here ``--repeat`` & ``"Hello World"`` are application specific command-line arguments. `aiohttp.web` only parses & consumes the command-line arguments it needs (i.e. ``-H``, ``-P`` & ``entry-func``) and passes on any additional arguments to the `cli_app:init` function for processing. """ from argparse import ArgumentParser from aiohttp.web import Application, Response def display_message(req): args = req.app["args"] text = "\n".join([args.message] * args.repeat) return Response(text=text) def init(argv): arg_parser = ArgumentParser( prog="aiohttp.web ...", description="Application CLI", add_help=False ) # Positional argument arg_parser.add_argument( "message", help="message to print" ) # Optional argument arg_parser.add_argument( "--repeat", help="number of times to repeat message", type=int, default="1" ) # Avoid conflict with -h from `aiohttp.web` CLI parser arg_parser.add_argument( "--app-help", help="show this message and exit", action="help" ) args = arg_parser.parse_args(argv) app = Application() app["args"] = args app.router.add_get('/', display_message) return app aiohttp-1.2.0/examples/web_srv.py0000775000175000017500000000271513025134363017675 0ustar travistravis00000000000000#!/usr/bin/env python3 """Example for aiohttp.web basic server """ import asyncio import textwrap from aiohttp.web import Application, Response, StreamResponse, run_app async def intro(request): txt = textwrap.dedent("""\ Type {url}/hello/John {url}/simple or {url}/change_body in browser url bar """).format(url='127.0.0.1:8080') binary = txt.encode('utf8') resp = StreamResponse() resp.content_length = len(binary) resp.content_type = 'text/plain' await resp.prepare(request) resp.write(binary) return resp async def simple(request): return Response(text="Simple answer") async def change_body(request): resp = Response() resp.body = b"Body changed" resp.content_type = 'text/plain' return resp async def hello(request): resp = StreamResponse() name = request.match_info.get('name', 'Anonymous') answer = ('Hello, ' + name).encode('utf8') resp.content_length = len(answer) resp.content_type = 'text/plain' await resp.prepare(request) resp.write(answer) await resp.write_eof() return resp async def init(loop): app = Application(loop=loop) app.router.add_get('/', intro) app.router.add_get('/simple', simple) app.router.add_get('/change_body', change_body) app.router.add_get('/hello/{name}', hello) app.router.add_get('/hello', hello) return app loop = asyncio.get_event_loop() app = loop.run_until_complete(init(loop)) run_app(app) aiohttp-1.2.0/examples/curl.py0000775000175000017500000000166313025134363017174 0ustar travistravis00000000000000#!/usr/bin/env python3 import argparse import asyncio import aiohttp def curl(url): session = aiohttp.ClientSession() response = yield from session.request('GET', url) print(repr(response)) chunk = yield from response.content.read() print('Downloaded: %s' % len(chunk)) response.close() yield from session.close() if __name__ == '__main__': ARGS = argparse.ArgumentParser(description="GET url example") ARGS.add_argument('url', nargs=1, metavar='URL', help="URL to download") ARGS.add_argument('--iocp', default=False, action="store_true", help="Use ProactorEventLoop on Windows") options = ARGS.parse_args() if options.iocp: from asyncio import events, windows_events el = windows_events.ProactorEventLoop() events.set_event_loop(el) loop = asyncio.get_event_loop() loop.run_until_complete(curl(options.url[0])) aiohttp-1.2.0/examples/legacy/0000775000175000017500000000000013025135427017112 5ustar travistravis00000000000000aiohttp-1.2.0/examples/legacy/crawl.py0000775000175000017500000000621713025134363020603 0ustar travistravis00000000000000#!/usr/bin/env python3 import asyncio import logging import re import signal import sys import urllib.parse import aiohttp class Crawler: def __init__(self, rooturl, loop, maxtasks=100): self.rooturl = rooturl self.loop = loop self.todo = set() self.busy = set() self.done = {} self.tasks = set() self.sem = asyncio.Semaphore(maxtasks, loop=loop) # connector stores cookies between requests and uses connection pool self.session = aiohttp.ClientSession(loop=loop) @asyncio.coroutine def run(self): t = asyncio.ensure_future(self.addurls([(self.rooturl, '')]), loop=self.loop) yield from asyncio.sleep(1, loop=self.loop) while self.busy: yield from asyncio.sleep(1, loop=self.loop) yield from t yield from self.session.close() self.loop.stop() @asyncio.coroutine def addurls(self, urls): for url, parenturl in urls: url = urllib.parse.urljoin(parenturl, url) url, frag = urllib.parse.urldefrag(url) if (url.startswith(self.rooturl) and url not in self.busy and url not in self.done and url not in self.todo): self.todo.add(url) yield from self.sem.acquire() task = asyncio.ensure_future(self.process(url), loop=self.loop) task.add_done_callback(lambda t: self.sem.release()) task.add_done_callback(self.tasks.remove) self.tasks.add(task) @asyncio.coroutine def process(self, url): print('processing:', url) self.todo.remove(url) self.busy.add(url) try: resp = yield from self.session.get(url) except Exception as exc: print('...', url, 'has error', repr(str(exc))) self.done[url] = False else: if (resp.status == 200 and ('text/html' in resp.headers.get('content-type'))): data = (yield from resp.read()).decode('utf-8', 'replace') urls = re.findall(r'(?i)href=["\']?([^\s"\'<>]+)', data) asyncio.Task(self.addurls([(u, url) for u in urls])) resp.close() self.done[url] = True self.busy.remove(url) print(len(self.done), 'completed tasks,', len(self.tasks), 'still pending, todo', len(self.todo)) def main(): loop = asyncio.get_event_loop() c = Crawler(sys.argv[1], loop) asyncio.ensure_future(c.run(), loop=loop) try: loop.add_signal_handler(signal.SIGINT, loop.stop) except RuntimeError: pass loop.run_forever() print('todo:', len(c.todo)) print('busy:', len(c.busy)) print('done:', len(c.done), '; ok:', sum(c.done.values())) print('tasks:', len(c.tasks)) if __name__ == '__main__': if '--iocp' in sys.argv: from asyncio import events, windows_events sys.argv.remove('--iocp') logging.info('using iocp') el = windows_events.ProactorEventLoop() events.set_event_loop(el) main() aiohttp-1.2.0/examples/legacy/srv.py0000775000175000017500000001240113025134363020275 0ustar travistravis00000000000000#!/usr/bin/env python3 """Simple server written using an event loop.""" import argparse import asyncio import logging import os import sys import aiohttp import aiohttp.server try: import ssl except ImportError: # pragma: no cover ssl = None class HttpRequestHandler(aiohttp.server.ServerHttpProtocol): @asyncio.coroutine def handle_request(self, message, payload): print('method = {!r}; path = {!r}; version = {!r}'.format( message.method, message.path, message.version)) path = message.path if (not (path.isprintable() and path.startswith('/')) or '/.' in path): print('bad path', repr(path)) path = None else: path = '.' + path if not os.path.exists(path): print('no file', repr(path)) path = None else: isdir = os.path.isdir(path) if not path: raise aiohttp.HttpProcessingError(code=404) for hdr, val in message.headers.items(): print(hdr, val) if isdir and not path.endswith('/'): path = path + '/' raise aiohttp.HttpProcessingError( code=302, headers=(('URI', path), ('Location', path))) response = aiohttp.Response( self.writer, 200, http_version=message.version) response.add_header('Transfer-Encoding', 'chunked') # content encoding accept_encoding = message.headers.get('accept-encoding', '').lower() if 'deflate' in accept_encoding: response.add_header('Content-Encoding', 'deflate') response.add_compression_filter('deflate') elif 'gzip' in accept_encoding: response.add_header('Content-Encoding', 'gzip') response.add_compression_filter('gzip') response.add_chunking_filter(1025) if isdir: response.add_header('Content-type', 'text/html') response.send_headers() response.write(b'
    \r\n') for name in sorted(os.listdir(path)): if name.isprintable() and not name.startswith('.'): try: bname = name.encode('ascii') except UnicodeError: pass else: if os.path.isdir(os.path.join(path, name)): response.write(b'
  • ' + bname + b'/
    • \r\n') else: response.write(b'
  • ' + bname + b'
    • \r\n') response.write(b'
') else: response.add_header('Content-type', 'text/plain') response.send_headers() try: with open(path, 'rb') as fp: chunk = fp.read(8192) while chunk: response.write(chunk) chunk = fp.read(8192) except OSError: response.write(b'Cannot open') yield from response.write_eof() if response.keep_alive(): self.keep_alive(True) ARGS = argparse.ArgumentParser(description="Run simple HTTP server.") ARGS.add_argument( '--host', action="store", dest='host', default='127.0.0.1', help='Host name') ARGS.add_argument( '--port', action="store", dest='port', default=8080, type=int, help='Port number') # make iocp and ssl mutually exclusive because ProactorEventLoop is # incompatible with SSL group = ARGS.add_mutually_exclusive_group() group.add_argument( '--iocp', action="store_true", dest='iocp', help='Windows IOCP event loop') group.add_argument( '--ssl', action="store_true", dest='ssl', help='Run ssl mode.') ARGS.add_argument( '--sslcert', action="store", dest='certfile', help='SSL cert file.') ARGS.add_argument( '--sslkey', action="store", dest='keyfile', help='SSL key file.') def main(): args = ARGS.parse_args() if ':' in args.host: args.host, port = args.host.split(':', 1) args.port = int(port) if args.iocp: from asyncio import windows_events sys.argv.remove('--iocp') logging.info('using iocp') el = windows_events.ProactorEventLoop() asyncio.set_event_loop(el) if args.ssl: here = os.path.join(os.path.dirname(__file__), 'tests') if args.certfile: certfile = args.certfile or os.path.join(here, 'sample.crt') keyfile = args.keyfile or os.path.join(here, 'sample.key') else: certfile = os.path.join(here, 'sample.crt') keyfile = os.path.join(here, 'sample.key') sslcontext = ssl.SSLContext(ssl.PROTOCOL_SSLv23) sslcontext.load_cert_chain(certfile, keyfile) else: sslcontext = None loop = asyncio.get_event_loop() f = loop.create_server( lambda: HttpRequestHandler(debug=True, keep_alive=75), args.host, args.port, ssl=sslcontext) svr = loop.run_until_complete(f) socks = svr.sockets print('serving on', socks[0].getsockname()) try: loop.run_forever() except KeyboardInterrupt: pass if __name__ == '__main__': main() aiohttp-1.2.0/examples/legacy/tcp_protocol_parser.py0000775000175000017500000001152513025134363023554 0ustar travistravis00000000000000#!/usr/bin/env python3 """Protocol parser example.""" import argparse import asyncio import collections import aiohttp try: import signal except ImportError: signal = None MSG_TEXT = b'text:' MSG_PING = b'ping:' MSG_PONG = b'pong:' MSG_STOP = b'stop:' Message = collections.namedtuple('Message', ('tp', 'data')) def my_protocol_parser(out, buf): """Parser is used with StreamParser for incremental protocol parsing. Parser is a generator function, but it is not a coroutine. Usually parsers are implemented as a state machine. more details in asyncio/parsers.py existing parsers: * HTTP protocol parsers asyncio/http/protocol.py * websocket parser asyncio/http/websocket.py """ while True: tp = yield from buf.read(5) if tp in (MSG_PING, MSG_PONG): # skip line yield from buf.skipuntil(b'\r\n') out.feed_data(Message(tp, None)) elif tp == MSG_STOP: out.feed_data(Message(tp, None)) elif tp == MSG_TEXT: # read text text = yield from buf.readuntil(b'\r\n') out.feed_data(Message(tp, text.strip().decode('utf-8'))) else: raise ValueError('Unknown protocol prefix.') class MyProtocolWriter: def __init__(self, transport): self.transport = transport def ping(self): self.transport.write(b'ping:\r\n') def pong(self): self.transport.write(b'pong:\r\n') def stop(self): self.transport.write(b'stop:\r\n') def send_text(self, text): self.transport.write( 'text:{}\r\n'.format(text.strip()).encode('utf-8')) class EchoServer(asyncio.Protocol): def connection_made(self, transport): print('Connection made') self.transport = transport self.stream = aiohttp.StreamParser() asyncio.Task(self.dispatch()) def data_received(self, data): self.stream.feed_data(data) def eof_received(self): self.stream.feed_eof() def connection_lost(self, exc): print('Connection lost') @asyncio.coroutine def dispatch(self): reader = self.stream.set_parser(my_protocol_parser) writer = MyProtocolWriter(self.transport) while True: try: msg = yield from reader.read() except aiohttp.ConnectionError: # client has been disconnected break print('Message received: {}'.format(msg)) if msg.type == MSG_PING: writer.pong() elif msg.type == MSG_TEXT: writer.send_text('Re: ' + msg.data) elif msg.type == MSG_STOP: self.transport.close() break @asyncio.coroutine def start_client(loop, host, port): transport, stream = yield from loop.create_connection( aiohttp.StreamProtocol, host, port) reader = stream.reader.set_parser(my_protocol_parser) writer = MyProtocolWriter(transport) writer.ping() message = 'This is the message. It will be echoed.' while True: try: msg = yield from reader.read() except aiohttp.ConnectionError: print('Server has been disconnected.') break print('Message received: {}'.format(msg)) if msg.type == MSG_PONG: writer.send_text(message) print('data sent:', message) elif msg.type == MSG_TEXT: writer.stop() print('stop sent') break transport.close() def start_server(loop, host, port): f = loop.create_server(EchoServer, host, port) srv = loop.run_until_complete(f) x = srv.sockets[0] print('serving on', x.getsockname()) loop.run_forever() ARGS = argparse.ArgumentParser(description="Protocol parser example.") ARGS.add_argument( '--server', action="store_true", dest='server', default=False, help='Run tcp server') ARGS.add_argument( '--client', action="store_true", dest='client', default=False, help='Run tcp client') ARGS.add_argument( '--host', action="store", dest='host', default='127.0.0.1', help='Host name') ARGS.add_argument( '--port', action="store", dest='port', default=9999, type=int, help='Port number') if __name__ == '__main__': args = ARGS.parse_args() if ':' in args.host: args.host, port = args.host.split(':', 1) args.port = int(port) if (not (args.server or args.client)) or (args.server and args.client): print('Please specify --server or --client\n') ARGS.print_help() else: loop = asyncio.get_event_loop() if signal is not None: loop.add_signal_handler(signal.SIGINT, loop.stop) if args.server: start_server(loop, args.host, args.port) else: loop.run_until_complete(start_client(loop, args.host, args.port)) aiohttp-1.2.0/examples/lowlevel_srv.py0000664000175000017500000000104313025134363020737 0ustar travistravis00000000000000import asyncio from aiohttp import web async def handler(request): return web.Response(text="OK") async def main(loop): server = web.Server(handler) await loop.create_server(server, "127.0.0.1", 8080) print("======= Serving on http://127.0.0.1:8080/ ======") # pause here for very long time by serving HTTP requests and # waiting for keyboard interruption await asyncio.sleep(100*3600) loop = asyncio.get_event_loop() try: loop.run_until_complete(main(loop)) except KeyboardInterrupt: pass loop.close() aiohttp-1.2.0/examples/server.csr0000664000175000017500000000167013025134363017667 0ustar travistravis00000000000000-----BEGIN CERTIFICATE REQUEST----- MIIChzCCAW8CAQAwQjELMAkGA1UEBhMCVUExEDAOBgNVBAgMB1VrcmFpbmUxITAf BgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDCCASIwDQYJKoZIhvcNAQEB BQADggEPADCCAQoCggEBAOUgkn3jX/sdg6GGueGDHCM+snIUVY3fM6D4jXjyBhnT 3TqKG1lJwCGYR11AD+2SJYppU+w4QaF6YZwMeZBKy+mVQ9+CrVYyKQE7j9H8XgNE HV9BQzoragT8lia8eC5aOQzUeX8AxCSSbsnyT/X+S1IKdd0txLOeZOD6pWwJoc3d pDELglk2b1tzhyN2GjQv3aRHj55Px7127MeZyRXwODFpXrpbnwih4OqkA4EYtmqF bZttGEzMhd4Y5mkbyuRbGM+IE99oQJMvnIkjAfUo0aKnDrcAIkWCkwLIci9TIG6u 3R1P2Tn+HYVntzQZ4BnxanbFNQ5S9ARd3529EmO3BzUCAwEAAaAAMA0GCSqGSIb3 DQEBCwUAA4IBAQDO/PSd29KgisTdGXhntg7yBEhBAjsDW7uQCrdrPSZtFyN6wUHy /1yrrWe56ZuW8jpuP5tG0eTZ+0bT2RXIRot8a2Cc3eBhpoe8M3d84yXjKAoHutGE 5IK+TViQdvT3pT3a7pTmjlf8Ojq9tx+U2ckiz8Ccnjd9yM47M9NgMhrS1aBpVZSt gOD+zzrqMML4xks9id94H7bi9Tgs3AbEJIyDpBpoK6i4OvK7KTidCngCg80qmdTy bcScLapoy1Ped2BKKuxWdOOlP+mDJatc/pcfBLE13AncQjJgMerS9M5RWCBjmRow A+aB6fBEU8bOTrqCryfBeTiV6xzyDDcIXtc6 -----END CERTIFICATE REQUEST----- aiohttp-1.2.0/examples/web_cookies.py0000775000175000017500000000200113025134363020503 0ustar travistravis00000000000000#!/usr/bin/env python3 """Example for aiohttp.web basic server with cookies. """ import asyncio from pprint import pformat from aiohttp import web tmpl = '''\ Login
Logout
{}
''' @asyncio.coroutine def root(request): resp = web.Response(content_type='text/html') resp.text = tmpl.format(pformat(request.cookies)) return resp @asyncio.coroutine def login(request): resp = web.HTTPFound(location='/') resp.set_cookie('AUTH', 'secret') return resp @asyncio.coroutine def logout(request): resp = web.HTTPFound(location='/') resp.del_cookie('AUTH') return resp @asyncio.coroutine def init(loop): app = web.Application(loop=loop) app.router.add_get('/', root) app.router.add_get('/login', login) app.router.add_get('/logout', logout) return app loop = asyncio.get_event_loop() app = loop.run_until_complete(init(loop)) web.run_app(app) aiohttp-1.2.0/examples/web_classview1.py0000775000175000017500000000277113025134363021146 0ustar travistravis00000000000000#!/usr/bin/env python3 """Example for aiohttp.web class based views """ import asyncio import functools import json from aiohttp.web import Application, Response, View, json_response, run_app class MyView(View): async def get(self): return json_response({ 'method': 'get', 'args': dict(self.request.GET), 'headers': dict(self.request.headers), }, dumps=functools.partial(json.dumps, indent=4)) async def post(self): data = await self.request.post() return json_response({ 'method': 'post', 'args': dict(self.request.GET), 'data': dict(data), 'headers': dict(self.request.headers), }, dumps=functools.partial(json.dumps, indent=4)) async def index(request): txt = """ Class based view example

Class based view example

  • / This page
  • /get Returns GET data.
  • /post Returns POST data.
""" return Response(text=txt, content_type='text/html') async def init(loop): app = Application(loop=loop) app.router.add_get('/', index) app.router.add_get('/get', MyView) app.router.add_post('/post', MyView) return app loop = asyncio.get_event_loop() app = loop.run_until_complete(init(loop)) run_app(app) aiohttp-1.2.0/examples/server.crt0000664000175000017500000000211713025134363017665 0ustar travistravis00000000000000-----BEGIN CERTIFICATE----- MIIDADCCAegCCQCgevpPMuTTLzANBgkqhkiG9w0BAQsFADBCMQswCQYDVQQGEwJV QTEQMA4GA1UECAwHVWtyYWluZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0cyBQ dHkgTHRkMB4XDTE2MDgwNzIzMTMwOFoXDTI2MDgwNTIzMTMwOFowQjELMAkGA1UE BhMCVUExEDAOBgNVBAgMB1VrcmFpbmUxITAfBgNVBAoMGEludGVybmV0IFdpZGdp dHMgUHR5IEx0ZDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOUgkn3j X/sdg6GGueGDHCM+snIUVY3fM6D4jXjyBhnT3TqKG1lJwCGYR11AD+2SJYppU+w4 QaF6YZwMeZBKy+mVQ9+CrVYyKQE7j9H8XgNEHV9BQzoragT8lia8eC5aOQzUeX8A xCSSbsnyT/X+S1IKdd0txLOeZOD6pWwJoc3dpDELglk2b1tzhyN2GjQv3aRHj55P x7127MeZyRXwODFpXrpbnwih4OqkA4EYtmqFbZttGEzMhd4Y5mkbyuRbGM+IE99o QJMvnIkjAfUo0aKnDrcAIkWCkwLIci9TIG6u3R1P2Tn+HYVntzQZ4BnxanbFNQ5S 9ARd3529EmO3BzUCAwEAATANBgkqhkiG9w0BAQsFAAOCAQEAXyiw1+YUnTEDI3C/ vq1Vn9pnwZALVQPiPlTqEGkl/nbq0suMmeZZG7pwrOJp3wr+sGwRAv9sPTro6srf Vj12wTo4LrTRKEDuS+AUJl0Mut7cPGIUKo+MGeZmmnDjMqcjljN3AO47ef4eWYo5 XGe4r4NDABEk5auOD/vQW5IiIMdmWsaMJ+0mZNpAV2NhAD/6ia28VvSL/yuaNqDW TYTUYHWLH08H6M6qrQ7FdoIDyYR5siqBukQzeqlnuq45bQ3ViYttNIkzZN4jbWJV /MFYLuJQ/fNoalDIC+ec0EIa9NbrfpoocJ8h6HlmWOqkES4QpBSOrkVid64Cdy3P JgiEWg== -----END CERTIFICATE----- aiohttp-1.2.0/examples/client_json.py0000775000175000017500000000070013025134363020525 0ustar travistravis00000000000000import asyncio import aiohttp async def fetch(session): print('Query http://httpbin.org/get') async with session.get( 'http://httpbin.org/get') as resp: print(resp.status) data = await resp.json() print(data) async def go(loop): async with aiohttp.ClientSession(loop=loop) as session: await fetch(session) loop = asyncio.get_event_loop() loop.run_until_complete(go(loop)) loop.close() aiohttp-1.2.0/MANIFEST.in0000664000175000017500000000070013025134363015561 0ustar travistravis00000000000000include LICENSE.txt include CHANGES.rst include README.rst include CONTRIBUTORS.txt include Makefile graft aiohttp graft docs graft examples graft tests global-exclude *.pyc exclude aiohttp/_multidict.html exclude aiohttp/_multidict.*.so exclude aiohttp/_multidict.pyd exclude aiohttp/_multidict.*.pyd exclude aiohttp/_websocket.html exclude aiohttp/_websocket.*.so exclude aiohttp/_websocket.pyd exclude aiohttp/_websocket.*.pyd prune docs/_build aiohttp-1.2.0/setup.cfg0000664000175000017500000000036213025135427015652 0ustar travistravis00000000000000[easy_install] zip_ok = false [flake8] ignore = N801,N802,N803,E226 [tool:pytest] timeout = 10 [isort] known_third_party = jinja2 known_first_party = aiohttp,aiohttp_jinja2,aiopg [egg_info] tag_build = tag_date = 0 tag_svn_revision = 0
  • {name}