From 0012d0b0230a3d6a2abc71e4b97b4c948828c6e4 Mon Sep 17 00:00:00 2001 From: kevin Date: Mon, 15 Jun 2026 19:00:24 +0800 Subject: [PATCH 1/6] refactor: add defensive checks for self.data access and improve error handling --- dashscope/api_entities/http_request.py | 203 +++++++++++++------------ 1 file changed, 107 insertions(+), 96 deletions(-) diff --git a/dashscope/api_entities/http_request.py b/dashscope/api_entities/http_request.py index 3142328..b1a3211 100644 --- a/dashscope/api_entities/http_request.py +++ b/dashscope/api_entities/http_request.py @@ -161,62 +161,69 @@ async def aio_call(self): return result async def _handle_aio_request(self): # pylint: disable=too-many-branches - # Use external aio_session if provided, - # otherwise use shared session with connection pooling - if self._external_aio_session is not None: - session = self._external_aio_session - else: - session = await get_shared_aio_session() - - if self.stream: - request_timeout = aiohttp.ClientTimeout( - total=None, - sock_read=self.timeout, - ) - else: - request_timeout = aiohttp.ClientTimeout(total=self.timeout) + try: + # Use external aio_session if provided, + # otherwise use shared session with connection pooling + if self._external_aio_session is not None: + session = self._external_aio_session + else: + session = await get_shared_aio_session() - logger.debug("Starting request: %s", self.url) - if self.method == HTTPMethod.POST: - is_form, obj = False, {} - if hasattr(self, "data") and self.data is not None: - is_form, obj = self.data.get_aiohttp_payload() - if is_form: - headers = {**self.headers, **obj.headers} - response = await session.post( - url=self.url, - data=obj, - headers=headers, - timeout=request_timeout, + if self.stream: + request_timeout = aiohttp.ClientTimeout( + total=None, + sock_read=self.timeout, ) else: - response = await session.request( - "POST", + request_timeout = aiohttp.ClientTimeout(total=self.timeout) + + logger.debug("Starting request: %s", self.url) + if self.method == HTTPMethod.POST: + is_form, obj = False, {} + if hasattr(self, "data") and self.data is not None: + is_form, obj = self.data.get_aiohttp_payload() + if is_form: + headers = {**self.headers, **obj.headers} + response = await session.post( + url=self.url, + data=obj, + headers=headers, + timeout=request_timeout, + ) + else: + response = await session.request( + "POST", + url=self.url, + json=obj, + headers=self.headers, + timeout=request_timeout, + ) + elif self.method == HTTPMethod.GET: + params = {} + if hasattr(self, "data") and self.data is not None: + params = getattr(self.data, "parameters", {}) + if params: + params = self.__handle_parameters(params) + response = await session.get( url=self.url, - json=obj, + params=params, headers=self.headers, timeout=request_timeout, ) - elif self.method == HTTPMethod.GET: - params = {} - if hasattr(self, "data") and self.data is not None: - params = getattr(self.data, "parameters", {}) - if params: - params = self.__handle_parameters(params) - response = await session.get( - url=self.url, - params=params, - headers=self.headers, - timeout=request_timeout, - ) - else: - raise UnsupportedHTTPMethod( - f"Unsupported http method: {self.method}", - ) - logger.debug("Response returned: %s", self.url) - async with response: - async for rsp in self._handle_aio_response(response): - yield rsp + else: + raise UnsupportedHTTPMethod( + f"Unsupported http method: {self.method}", + ) + logger.debug("Response returned: %s", self.url) + async with response: + async for rsp in self._handle_aio_response(response): + yield rsp + except aiohttp.ClientConnectorError as e: + logger.error(e) + raise e + except BaseException as e: + logger.error(e) + raise e @staticmethod def __handle_parameters(params: dict) -> dict: @@ -446,56 +453,60 @@ def _handle_response( # pylint: disable=too-many-branches yield _handle_http_failed_response(response) def _handle_request(self): - # Use external session if provided, - # otherwise create temporary session - if self._external_session is not None: - session = self._external_session - should_close = False - else: - session = requests.Session() - should_close = True - try: - if self.method == HTTPMethod.POST: - is_form, form, obj = False, None, {} - if hasattr(self, "data") and self.data is not None: - is_form, form, obj = self.data.get_http_payload() - if is_form: - headers = {**self.headers} - headers.pop("Content-Type") - response = session.post( + # Use external session if provided, + # otherwise create temporary session + if self._external_session is not None: + session = self._external_session + should_close = False + else: + session = requests.Session() + should_close = True + + try: + if self.method == HTTPMethod.POST: + is_form, form, obj = False, None, {} + if hasattr(self, "data") and self.data is not None: + is_form, form, obj = self.data.get_http_payload() + if is_form: + headers = {**self.headers} + headers.pop("Content-Type") + response = session.post( + url=self.url, + data=obj, + files=form, + headers=headers, + timeout=self.timeout, + ) + else: + logger.debug("Request body: %s", obj) + response = session.post( + url=self.url, + stream=self.stream, + json=obj, + headers={**self.headers}, + timeout=self.timeout, + ) + elif self.method == HTTPMethod.GET: + params = {} + if hasattr(self, "data") and self.data is not None: + params = getattr(self.data, "parameters", {}) + response = session.get( url=self.url, - data=obj, - files=form, - headers=headers, + params=params, + headers=self.headers, timeout=self.timeout, ) else: - logger.debug("Request body: %s", obj) - response = session.post( - url=self.url, - stream=self.stream, - json=obj, - headers={**self.headers}, - timeout=self.timeout, + raise UnsupportedHTTPMethod( + f"Unsupported http method: {self.method}", ) - elif self.method == HTTPMethod.GET: - params = {} - if hasattr(self, "data") and self.data is not None: - params = getattr(self.data, "parameters", {}) - response = session.get( - url=self.url, - params=params, - headers=self.headers, - timeout=self.timeout, - ) - else: - raise UnsupportedHTTPMethod( - f"Unsupported http method: {self.method}", - ) - for rsp in self._handle_response(response): - yield rsp - finally: - # Only close if we created the session - if should_close: - session.close() + for rsp in self._handle_response(response): + yield rsp + finally: + # Only close if we created the session + if should_close: + session.close() + except BaseException as e: + logger.error(e) + raise e \ No newline at end of file From 34f8cc9d262535d156ba99788d308e5b73e2771d Mon Sep 17 00:00:00 2001 From: kevin Date: Mon, 15 Jun 2026 19:00:45 +0800 Subject: [PATCH 2/6] refactor: add defensive checks for self.data access and improve error handling --- dashscope/api_entities/aio_session.py | 29 +++----- dashscope/api_entities/aiohttp_request.py | 91 ++++++++++++----------- 2 files changed, 61 insertions(+), 59 deletions(-) diff --git a/dashscope/api_entities/aio_session.py b/dashscope/api_entities/aio_session.py index d2365db..9501a66 100644 --- a/dashscope/api_entities/aio_session.py +++ b/dashscope/api_entities/aio_session.py @@ -8,7 +8,6 @@ """ import asyncio import ssl -import threading import weakref from typing import Optional @@ -17,16 +16,14 @@ _shared_ssl_context: Optional[ssl.SSLContext] = None _aio_sessions: "weakref.WeakKeyDictionary" = weakref.WeakKeyDictionary() -_lock = threading.RLock() def get_ssl_context() -> ssl.SSLContext: global _shared_ssl_context - with _lock: - if _shared_ssl_context is None: - _shared_ssl_context = ssl.create_default_context( - cafile=certifi.where(), - ) + if _shared_ssl_context is None: + _shared_ssl_context = ssl.create_default_context( + cafile=certifi.where(), + ) return _shared_ssl_context @@ -39,21 +36,19 @@ async def get_shared_aio_session() -> aiohttp.ClientSession: """ loop = asyncio.get_running_loop() - with _lock: - session = _aio_sessions.get(loop) - if session is not None and not session.closed: - return session + session = _aio_sessions.get(loop) + if session is not None and not session.closed: + return session - connector = aiohttp.TCPConnector(ssl=get_ssl_context()) - session = aiohttp.ClientSession(connector=connector) - _aio_sessions[loop] = session + connector = aiohttp.TCPConnector(ssl=get_ssl_context()) + session = aiohttp.ClientSession(connector=connector) + _aio_sessions[loop] = session return session async def close_shared_aio_session() -> None: """Close the shared session for the current event loop.""" loop = asyncio.get_running_loop() - with _lock: - session = _aio_sessions.pop(loop, None) + session = _aio_sessions.pop(loop, None) if session is not None and not session.closed: - await session.close() + await session.close() \ No newline at end of file diff --git a/dashscope/api_entities/aiohttp_request.py b/dashscope/api_entities/aiohttp_request.py index 598be25..7bf37dd 100644 --- a/dashscope/api_entities/aiohttp_request.py +++ b/dashscope/api_entities/aiohttp_request.py @@ -248,51 +248,58 @@ async def _handle_response( # pylint: disable=too-many-branches ) async def _handle_request(self): - session = await get_shared_aio_session() - if self.stream: - request_timeout = aiohttp.ClientTimeout( - total=None, - sock_read=self.timeout, - ) - else: - request_timeout = aiohttp.ClientTimeout(total=self.timeout) - - logger.debug("Starting request: %s", self.url) - if self.method == HTTPMethod.POST: - is_form, obj = False, {} - if hasattr(self, "data") and self.data is not None: - is_form, obj = self.data.get_aiohttp_payload() - if is_form: - headers = {**self.headers, **obj.headers} - response = await session.post( - url=self.url, - data=obj, - headers=headers, - timeout=request_timeout, + try: + session = await get_shared_aio_session() + if self.stream: + request_timeout = aiohttp.ClientTimeout( + total=None, + sock_read=self.timeout, ) else: - response = await session.request( - "POST", + request_timeout = aiohttp.ClientTimeout(total=self.timeout) + + logger.debug("Starting request: %s", self.url) + if self.method == HTTPMethod.POST: + is_form, obj = False, {} + if hasattr(self, "data") and self.data is not None: + is_form, obj = self.data.get_aiohttp_payload() + if is_form: + headers = {**self.headers, **obj.headers} + response = await session.post( + url=self.url, + data=obj, + headers=headers, + timeout=request_timeout, + ) + else: + response = await session.request( + "POST", + url=self.url, + json=obj, + headers=self.headers, + timeout=request_timeout, + ) + elif self.method == HTTPMethod.GET: + params = {} + if hasattr(self, "data") and self.data is not None: + params = getattr(self.data, "parameters", {}) + response = await session.get( url=self.url, - json=obj, + params=params, headers=self.headers, timeout=request_timeout, ) - elif self.method == HTTPMethod.GET: - params = {} - if hasattr(self, "data") and self.data is not None: - params = getattr(self.data, "parameters", {}) - response = await session.get( - url=self.url, - params=params, - headers=self.headers, - timeout=request_timeout, - ) - else: - raise UnsupportedHTTPMethod( - f"Unsupported http method: {self.method}", - ) - logger.debug("Response returned: %s", self.url) - async with response: - async for rsp in self._handle_response(response): - yield rsp + else: + raise UnsupportedHTTPMethod( + f"Unsupported http method: {self.method}", + ) + logger.debug("Response returned: %s", self.url) + async with response: + async for rsp in self._handle_response(response): + yield rsp + except aiohttp.ClientConnectorError as e: + logger.error(e) + raise e + except Exception as e: + logger.error(e) + raise e \ No newline at end of file From 956fba39be46622779ec7c18af74e3872321a041 Mon Sep 17 00:00:00 2001 From: kevin Date: Mon, 15 Jun 2026 19:12:41 +0800 Subject: [PATCH 3/6] refactor: add defensive checks for self.data access and improve error handling --- dashscope/api_entities/aio_session.py | 2 +- dashscope/api_entities/aiohttp_request.py | 2 +- dashscope/api_entities/http_request.py | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/dashscope/api_entities/aio_session.py b/dashscope/api_entities/aio_session.py index 9501a66..ee64eec 100644 --- a/dashscope/api_entities/aio_session.py +++ b/dashscope/api_entities/aio_session.py @@ -51,4 +51,4 @@ async def close_shared_aio_session() -> None: loop = asyncio.get_running_loop() session = _aio_sessions.pop(loop, None) if session is not None and not session.closed: - await session.close() \ No newline at end of file + await session.close() diff --git a/dashscope/api_entities/aiohttp_request.py b/dashscope/api_entities/aiohttp_request.py index 7bf37dd..98eca3f 100644 --- a/dashscope/api_entities/aiohttp_request.py +++ b/dashscope/api_entities/aiohttp_request.py @@ -302,4 +302,4 @@ async def _handle_request(self): raise e except Exception as e: logger.error(e) - raise e \ No newline at end of file + raise e diff --git a/dashscope/api_entities/http_request.py b/dashscope/api_entities/http_request.py index b1a3211..9b8a85e 100644 --- a/dashscope/api_entities/http_request.py +++ b/dashscope/api_entities/http_request.py @@ -452,7 +452,7 @@ def _handle_response( # pylint: disable=too-many-branches else: yield _handle_http_failed_response(response) - def _handle_request(self): + def _handle_request(self): # pylint: disable=too-many-branches try: # Use external session if provided, # otherwise create temporary session @@ -509,4 +509,4 @@ def _handle_request(self): session.close() except BaseException as e: logger.error(e) - raise e \ No newline at end of file + raise e From b092e115a2b57ebcf3b8dcdeb26e4bf5da8f3568 Mon Sep 17 00:00:00 2001 From: kevin Date: Mon, 15 Jun 2026 19:22:03 +0800 Subject: [PATCH 4/6] refactor: restore thread safety for aio session and simplify exception handling --- dashscope/api_entities/aio_session.py | 28 +++++++++++++---------- dashscope/api_entities/aiohttp_request.py | 3 --- dashscope/api_entities/http_request.py | 7 ++---- 3 files changed, 18 insertions(+), 20 deletions(-) diff --git a/dashscope/api_entities/aio_session.py b/dashscope/api_entities/aio_session.py index ee64eec..0b8d775 100644 --- a/dashscope/api_entities/aio_session.py +++ b/dashscope/api_entities/aio_session.py @@ -8,6 +8,7 @@ """ import asyncio import ssl +import threading import weakref from typing import Optional @@ -16,14 +17,15 @@ _shared_ssl_context: Optional[ssl.SSLContext] = None _aio_sessions: "weakref.WeakKeyDictionary" = weakref.WeakKeyDictionary() - +_lock = threading.RLock() def get_ssl_context() -> ssl.SSLContext: global _shared_ssl_context - if _shared_ssl_context is None: - _shared_ssl_context = ssl.create_default_context( - cafile=certifi.where(), - ) + with _lock: + if _shared_ssl_context is None: + _shared_ssl_context = ssl.create_default_context( + cafile=certifi.where(), + ) return _shared_ssl_context @@ -36,19 +38,21 @@ async def get_shared_aio_session() -> aiohttp.ClientSession: """ loop = asyncio.get_running_loop() - session = _aio_sessions.get(loop) - if session is not None and not session.closed: - return session + with _lock: + session = _aio_sessions.get(loop) + if session is not None and not session.closed: + return session - connector = aiohttp.TCPConnector(ssl=get_ssl_context()) - session = aiohttp.ClientSession(connector=connector) - _aio_sessions[loop] = session + connector = aiohttp.TCPConnector(ssl=get_ssl_context()) + session = aiohttp.ClientSession(connector=connector) + _aio_sessions[loop] = session return session async def close_shared_aio_session() -> None: """Close the shared session for the current event loop.""" loop = asyncio.get_running_loop() - session = _aio_sessions.pop(loop, None) + with _lock: + session = _aio_sessions.pop(loop, None) if session is not None and not session.closed: await session.close() diff --git a/dashscope/api_entities/aiohttp_request.py b/dashscope/api_entities/aiohttp_request.py index 98eca3f..ae8ea0b 100644 --- a/dashscope/api_entities/aiohttp_request.py +++ b/dashscope/api_entities/aiohttp_request.py @@ -297,9 +297,6 @@ async def _handle_request(self): async with response: async for rsp in self._handle_response(response): yield rsp - except aiohttp.ClientConnectorError as e: - logger.error(e) - raise e except Exception as e: logger.error(e) raise e diff --git a/dashscope/api_entities/http_request.py b/dashscope/api_entities/http_request.py index 9b8a85e..01b6c8f 100644 --- a/dashscope/api_entities/http_request.py +++ b/dashscope/api_entities/http_request.py @@ -218,10 +218,7 @@ async def _handle_aio_request(self): # pylint: disable=too-many-branches async with response: async for rsp in self._handle_aio_response(response): yield rsp - except aiohttp.ClientConnectorError as e: - logger.error(e) - raise e - except BaseException as e: + except Exception as e: logger.error(e) raise e @@ -507,6 +504,6 @@ def _handle_request(self): # pylint: disable=too-many-branches # Only close if we created the session if should_close: session.close() - except BaseException as e: + except Exception as e: logger.error(e) raise e From 13aee1a65b2a00457c3873ae15279081de20cbc4 Mon Sep 17 00:00:00 2001 From: kevin Date: Mon, 15 Jun 2026 19:40:11 +0800 Subject: [PATCH 5/6] fix aio_session --- dashscope/api_entities/aio_session.py | 1 + 1 file changed, 1 insertion(+) diff --git a/dashscope/api_entities/aio_session.py b/dashscope/api_entities/aio_session.py index 0b8d775..d2365db 100644 --- a/dashscope/api_entities/aio_session.py +++ b/dashscope/api_entities/aio_session.py @@ -19,6 +19,7 @@ _aio_sessions: "weakref.WeakKeyDictionary" = weakref.WeakKeyDictionary() _lock = threading.RLock() + def get_ssl_context() -> ssl.SSLContext: global _shared_ssl_context with _lock: From c84d268f34a1327cc85690d33d2c7b910206ca09 Mon Sep 17 00:00:00 2001 From: "zhansheng.lzs" Date: Tue, 16 Jun 2026 10:43:25 +0800 Subject: [PATCH 6/6] feat: add external session support for AioHttpRequest and export close_shared_aio_session - Add optional `session` parameter to AioHttpRequest.__init__ for injecting external aiohttp.ClientSession (aligned with HttpRequest) - Add should_close lifecycle pattern to async request handlers in both AioHttpRequest and HttpRequest (consistent with sync _handle_request) - Export close_shared_aio_session from dashscope package for explicit connection pool cleanup Co-Authored-By: Claude Opus 4.7 --- dashscope/__init__.py | 2 + dashscope/api_entities/aiohttp_request.py | 91 ++++++++++++--------- dashscope/api_entities/http_request.py | 96 ++++++++++++----------- 3 files changed, 107 insertions(+), 82 deletions(-) diff --git a/dashscope/__init__.py b/dashscope/__init__.py index 92cd259..672f24c 100644 --- a/dashscope/__init__.py +++ b/dashscope/__init__.py @@ -21,6 +21,7 @@ HttpSpeechSynthesizer, ) from dashscope.audio.tts.speech_synthesizer import SpeechSynthesizer +from dashscope.api_entities.aio_session import close_shared_aio_session from dashscope.common.api_key import save_api_key from dashscope.common.env import ( api_key, @@ -75,6 +76,7 @@ "api_key", "api_key_file_path", "save_api_key", + "close_shared_aio_session", "AioGeneration", "Conversation", "Generation", diff --git a/dashscope/api_entities/aiohttp_request.py b/dashscope/api_entities/aiohttp_request.py index ae8ea0b..e5487b5 100644 --- a/dashscope/api_entities/aiohttp_request.py +++ b/dashscope/api_entities/aiohttp_request.py @@ -3,6 +3,7 @@ import json from http import HTTPStatus +from typing import Optional import aiohttp @@ -31,6 +32,7 @@ def __init__( timeout: int = DEFAULT_REQUEST_TIMEOUT_SECONDS, task_id: str = None, user_agent: str = "", + session: Optional[aiohttp.ClientSession] = None, ) -> None: """HttpSSERequest, processing http server sent event stream. @@ -45,16 +47,20 @@ def __init__( Defaults to DEFAULT_REQUEST_TIMEOUT_SECONDS. user_agent (str, optional): Additional user agent string to append. Defaults to ''. + session (aiohttp.ClientSession, optional): External aiohttp + session to use instead of the shared session. The caller is + responsible for closing it. Defaults to None. """ super().__init__(user_agent=user_agent) self.url = url self.async_request = async_request + self._external_aio_session = session self.headers = { "Accept": "application/json", "Authorization": f"Bearer {api_key}", "Cache-Control": "no-cache", - **self.headers, + **self.headers, # type: ignore[has-type] } self.query = query if self.async_request and self.query is False: @@ -247,9 +253,16 @@ async def _handle_response( # pylint: disable=too-many-branches message=msg.decode("utf-8"), ) + # pylint: disable=too-many-branches async def _handle_request(self): try: - session = await get_shared_aio_session() + if self._external_aio_session is not None: + session = self._external_aio_session + should_close = False + else: + session = await get_shared_aio_session() + should_close = False + if self.stream: request_timeout = aiohttp.ClientTimeout( total=None, @@ -258,45 +271,49 @@ async def _handle_request(self): else: request_timeout = aiohttp.ClientTimeout(total=self.timeout) - logger.debug("Starting request: %s", self.url) - if self.method == HTTPMethod.POST: - is_form, obj = False, {} - if hasattr(self, "data") and self.data is not None: - is_form, obj = self.data.get_aiohttp_payload() - if is_form: - headers = {**self.headers, **obj.headers} - response = await session.post( + try: + logger.debug("Starting request: %s", self.url) + if self.method == HTTPMethod.POST: + is_form, obj = False, {} + if hasattr(self, "data") and self.data is not None: + is_form, obj = self.data.get_aiohttp_payload() + if is_form: + headers = {**self.headers, **obj.headers} + response = await session.post( + url=self.url, + data=obj, + headers=headers, + timeout=request_timeout, + ) + else: + response = await session.request( + "POST", + url=self.url, + json=obj, + headers=self.headers, + timeout=request_timeout, + ) + elif self.method == HTTPMethod.GET: + params = {} + if hasattr(self, "data") and self.data is not None: + params = getattr(self.data, "parameters", {}) + response = await session.get( url=self.url, - data=obj, - headers=headers, + params=params, + headers=self.headers, timeout=request_timeout, ) else: - response = await session.request( - "POST", - url=self.url, - json=obj, - headers=self.headers, - timeout=request_timeout, + raise UnsupportedHTTPMethod( + f"Unsupported http method: {self.method}", ) - elif self.method == HTTPMethod.GET: - params = {} - if hasattr(self, "data") and self.data is not None: - params = getattr(self.data, "parameters", {}) - response = await session.get( - url=self.url, - params=params, - headers=self.headers, - timeout=request_timeout, - ) - else: - raise UnsupportedHTTPMethod( - f"Unsupported http method: {self.method}", - ) - logger.debug("Response returned: %s", self.url) - async with response: - async for rsp in self._handle_response(response): - yield rsp + logger.debug("Response returned: %s", self.url) + async with response: + async for rsp in self._handle_response(response): + yield rsp + finally: + if should_close: + await session.close() except Exception as e: - logger.error(e) + logger.debug(e) raise e diff --git a/dashscope/api_entities/http_request.py b/dashscope/api_entities/http_request.py index 01b6c8f..1208bbc 100644 --- a/dashscope/api_entities/http_request.py +++ b/dashscope/api_entities/http_request.py @@ -166,60 +166,66 @@ async def _handle_aio_request(self): # pylint: disable=too-many-branches # otherwise use shared session with connection pooling if self._external_aio_session is not None: session = self._external_aio_session + should_close = False else: session = await get_shared_aio_session() + should_close = False - if self.stream: - request_timeout = aiohttp.ClientTimeout( - total=None, - sock_read=self.timeout, - ) - else: - request_timeout = aiohttp.ClientTimeout(total=self.timeout) - - logger.debug("Starting request: %s", self.url) - if self.method == HTTPMethod.POST: - is_form, obj = False, {} - if hasattr(self, "data") and self.data is not None: - is_form, obj = self.data.get_aiohttp_payload() - if is_form: - headers = {**self.headers, **obj.headers} - response = await session.post( - url=self.url, - data=obj, - headers=headers, - timeout=request_timeout, + try: + if self.stream: + request_timeout = aiohttp.ClientTimeout( + total=None, + sock_read=self.timeout, ) else: - response = await session.request( - "POST", + request_timeout = aiohttp.ClientTimeout(total=self.timeout) + + logger.debug("Starting request: %s", self.url) + if self.method == HTTPMethod.POST: + is_form, obj = False, {} + if hasattr(self, "data") and self.data is not None: + is_form, obj = self.data.get_aiohttp_payload() + if is_form: + headers = {**self.headers, **obj.headers} + response = await session.post( + url=self.url, + data=obj, + headers=headers, + timeout=request_timeout, + ) + else: + response = await session.request( + "POST", + url=self.url, + json=obj, + headers=self.headers, + timeout=request_timeout, + ) + elif self.method == HTTPMethod.GET: + params = {} + if hasattr(self, "data") and self.data is not None: + params = getattr(self.data, "parameters", {}) + if params: + params = self.__handle_parameters(params) + response = await session.get( url=self.url, - json=obj, + params=params, headers=self.headers, timeout=request_timeout, ) - elif self.method == HTTPMethod.GET: - params = {} - if hasattr(self, "data") and self.data is not None: - params = getattr(self.data, "parameters", {}) - if params: - params = self.__handle_parameters(params) - response = await session.get( - url=self.url, - params=params, - headers=self.headers, - timeout=request_timeout, - ) - else: - raise UnsupportedHTTPMethod( - f"Unsupported http method: {self.method}", - ) - logger.debug("Response returned: %s", self.url) - async with response: - async for rsp in self._handle_aio_response(response): - yield rsp + else: + raise UnsupportedHTTPMethod( + f"Unsupported http method: {self.method}", + ) + logger.debug("Response returned: %s", self.url) + async with response: + async for rsp in self._handle_aio_response(response): + yield rsp + finally: + if should_close: + await session.close() except Exception as e: - logger.error(e) + logger.debug(e) raise e @staticmethod @@ -505,5 +511,5 @@ def _handle_request(self): # pylint: disable=too-many-branches if should_close: session.close() except Exception as e: - logger.error(e) + logger.debug(e) raise e