warning msg: Unclosed client session, Unclosed connector about miniopy-async HOT 2 CLOSED

    async def _url_open(  # pylint: disable=too-many-branches
        self,
        method,
        region,
        bucket_name=None,
        object_name=None,
        body=None,
        headers=None,
        query_params=None,
        session=None,
    ):
        """Execute HTTP request."""
        credentials = self._provider.retrieve() if self._provider else None
        url = self._base_url.build(
            method,
            region,
            bucket_name=bucket_name,
            object_name=object_name,
            query_params=query_params,
        )
        headers, date = await self._build_headers(
            url.netloc,
            headers,
            body,
            credentials
        )
        if credentials:
            headers = sign_v4_s3(
                method,
                url,
                region,
                headers,
                credentials,
                headers.get("x-amz-content-sha256"),
                date,
            )      
        if session is None:
            async with aiohttp.ClientSession() as session:
                return await self._do_req_in_session(session, method, url, body, headers)
        else:
            return await self._do_req_in_session(session, method, url, body, headers)

    async def _do_req_in_session(self, session, method, url, body, headers):
        response = await session.request(
            method,
            urlunsplit(url),
            data=body,
            headers=headers)

        # if should_attach_finalizer:
        #     _attach_finalizer(response, session, asyncio.get_running_loop())

        if response.status in [200, 204, 206]:
            return response

        response_data = await response.content.read()
        content_types = response.headers.get("content-type", "").split(";")
        if method != "HEAD" and "application/xml" not in content_types:
            raise InvalidResponseError(
                response.status,
                response.headers.get("content-type"),
                response_data if response_data else None,
            )

        if not response_data and method != "HEAD":
            raise InvalidResponseError(
                response.status,
                response.headers.get("content-type"),
                None,
            )

        response_error = S3Error.fromxml(
            response, response_data
        ) if response_data else None

        error_map = {
            301: lambda: self._handle_redirect_response(
                method, bucket_name, response, True,
            ),
            307: lambda: self._handle_redirect_response(
                method, bucket_name, response, True,
            ),
            400: lambda: self._handle_redirect_response(
                method, bucket_name, response, True,
            ),
            403: lambda: ("AccessDenied", "Access denied"),
            404: lambda: (
                ("NoSuchKey", "Object does not exist")
                if object_name
                else ("NoSuchBucket", "Bucket does not exist")
                if bucket_name
                else ("ResourceNotFound", "Request resource not found")
            ),
            405: lambda: (
                "MethodNotAllowed",
                "The specified method is not allowed against this resource",
            ),
            409: lambda: (
                ("NoSuchBucket", "Bucket does not exist")
                if bucket_name
                else ("ResourceConflict", "Request resource conflicts"),
            ),
            501: lambda: (
                "MethodNotAllowed",
                "The specified method is not allowed against this resource",
            ),
        }

        if not response_error:
            func = error_map.get(response.status)
            code, message = func() if func else (None, None)
            if not code:
                raise ServerError(
                    f"server failed with HTTP status code {response.status}",
                    response.status
                )
            response_error = S3Error(
                code,
                message,
                url.path,
                response.headers.get("x-amz-request-id"),
                response.headers.get("x-amz-id-2"),
                response,
                bucket_name=bucket_name,
                object_name=object_name,
            )

        if response_error.code in ["NoSuchBucket", "RetryHead"]:
            self._region_map.pop(bucket_name, None)

        raise response_error