boto__botocore-830

{
  "status": "ok",
  "stdout": "botocore/serialize.py:61:    # TODO: Unknown protocols.\nbotocore/serialize.py:360:    \"\"\"Base class for rest protocols.\nbotocore/serialize.py:362:    The only variance between the various rest protocols is the\nbotocore/parsers.py:19:There are many similarities amongst the different protocols with regard\nbotocore/parsers.py:48:contains logic that is similar amongst all the different protocols (``query``,\nbotocore/parsers.py:54:* The ``json`` and ``rest-json`` protocols both have JSON bodies that are\nbotocore/parsers.py:56:* The ``rest-json`` and ``rest-xml`` protocols have additional attributes\nbotocore/parsers.py:161:    various protocols must implement.\nbotocore/regions.py:54:            - protocols: (list<string>) A list of supported protocols\nbotocore/vendored/requests/status_codes.py:9:    101: ('switching_protocols',),\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "botocore/endpoint.py",
  "content": "# Copyright (c) 2012-2013 Mitch Garnaat http://garnaat.org/\n# Copyright 2012-2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\"). You\n# may not use this file except in compliance with the License. A copy of\n# the License is located at\n#\n# http://aws.amazon.com/apache2.0/\n#\n# or in the \"license\" file accompanying this file. This file is\n# distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF\n# ANY KIND, either express or implied. See the License for the specific\n# language governing permissions and limitations under the License.\n\nimport os\nimport logging\nimport time\nimport threading\n\nfrom botocore.vendored.requests.sessions import Session\nfrom botocore.vendored.requests.utils import get_environ_proxies\nfrom botocore.vendored.requests.exceptions import ConnectionError\nfrom botocore.vendored import six\n\nfrom botocore.awsrequest import create_request_object\nfrom botocore.exceptions import UnknownEndpointError\nfrom botocore.exceptions import EndpointConnectionError\nfrom botocore.exceptions import ConnectionClosedError\nfrom botocore.compat import filter_ssl_warnings\nfrom botocore.utils import is_valid_endpoint_url\nfrom botocore.hooks import first_non_none_response\nfrom botocore.response import StreamingBody\nfrom botocore import parsers\n\n\nlogger = logging.getLogger(__name__)\nDEFAULT_TIMEOUT = 60\nfilter_ssl_warnings()\n\ntry:\n    from botocore.vendored.requests.packages.urllib3.contrib import pyopenssl\n    pyopenssl.extract_from_urllib3()\nexcept ImportError:\n    pass\n\n\ndef convert_to_response_dict(http_response, operation_model):\n    \"\"\"Convert an HTTP response object to a request dict.\n\n    This converts the requests library's HTTP response object to\n    a dictionary.\n\n    :type http_response: botocore.vendored.requests.model.Response\n    :param http_response: The HTTP response from an AWS service request.\n\n    :rtype: dict\n    :return: A response dictionary which will contain the following keys:\n        * headers (dict)\n        * status_code (int)\n        * body (string or file-like object)\n\n    \"\"\"\n    response_dict = {\n        'headers': http_response.headers,\n        'status_code': http_response.status_code,\n    }\n    if response_dict['status_code'] >= 300:\n        response_dict['body'] = http_response.content\n    elif operation_model.has_streaming_output:\n        response_dict['body'] = StreamingBody(\n            http_response.raw, response_dict['headers'].get('content-length'))\n    else:\n        response_dict['body'] = http_response.content\n    return response_dict\n\n\nclass PreserveAuthSession(Session):\n    def rebuild_auth(self, prepared_request, response):\n        pass\n\n\nclass Endpoint(object):\n    \"\"\"\n    Represents an endpoint for a particular service in a specific\n    region.  Only an endpoint can make requests.\n\n    :ivar service: The Service object that describes this endpoints\n        service.\n    :ivar host: The fully qualified endpoint hostname.\n    :ivar session: The session object.\n    \"\"\"\n\n    def __init__(self, host, endpoint_prefix,\n                 event_emitter, proxies=None, verify=True,\n                 timeout=DEFAULT_TIMEOUT, response_parser_factory=None):\n        self._endpoint_prefix = endpoint_prefix\n        self._event_emitter = event_emitter\n        self.host = host\n        self.verify = verify\n        if proxies is None:\n            proxies = {}\n        self.proxies = proxies\n        self.http_session = PreserveAuthSession()\n        self.timeout = timeout\n        logger.debug('Setting %s timeout as %s', endpoint_prefix, self.timeout)\n        self._lock = threading.Lock()\n        if response_parser_factory is None:\n            response_parser_factory = parsers.ResponseParserFactory()\n        self._response_parser_factory = response_parser_factory\n\n    def __repr__(self):\n        return '%s(%s)' % (self._endpoint_prefix, self.host)\n\n    def make_request(self, operation_model, request_dict):\n        logger.debug(\"Making request for %s (verify_ssl=%s) with params: %s\",\n                     operation_model, self.verify, request_dict)\n        return self._send_request(request_dict, operation_model)\n\n    def create_request(self, params, operation_model=None):\n        request = create_request_object(params)\n        if operation_model:\n            event_name = 'request-created.{endpoint_prefix}.{op_name}'.format(\n                endpoint_prefix=self._endpoint_prefix,\n                op_name=operation_model.name)\n            self._event_emitter.emit(event_name, request=request,\n                                     operation_name=operation_model.name)\n        prepared_request = self.prepare_request(request)\n        return prepared_request\n\n    def _encode_headers(self, headers):\n        # In place encoding of headers to utf-8 if they are unicode.\n        for key, value in headers.items():\n            if isinstance(value, six.text_type):\n                headers[key] = value.encode('utf-8')\n\n    def prepare_request(self, request):\n        self._encode_headers(request.headers)\n        return request.prepare()\n\n    def _send_request(self, request_dict, operation_model):\n        attempts = 1\n        request = self.create_request(request_dict, operation_model)\n        success_response, exception = self._get_response(\n            request, operation_model, attempts)\n        while self._needs_retry(attempts, operation_model,\n                                success_response, exception):\n            attempts += 1\n            # If there is a stream associated with the request, we need\n            # to reset it before attempting to send the request again.\n            # This will ensure that we resend the entire contents of the",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 266,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "botocore/endpoint.py:82:class Endpoint(object):\nbotocore/endpoint.py:241:        return Endpoint(\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "botocore/endpoint.py",
  "content": "        parser = self._response_parser_factory.create_parser(\n            operation_model.metadata['protocol'])\n        return ((http_response,\n                 parser.parse(response_dict, operation_model.output_shape)),\n                None)\n\n    def _looks_like_dns_error(self, e):\n        return 'gaierror' in str(e) and e.request is not None\n\n    def _looks_like_bad_status_line(self, e):\n        return 'BadStatusLine' in str(e) and e.request is not None\n\n    def _needs_retry(self, attempts, operation_model, response=None,\n                     caught_exception=None):\n        event_name = 'needs-retry.%s.%s' % (self._endpoint_prefix,\n                                            operation_model.name)\n        responses = self._event_emitter.emit(\n            event_name, response=response, endpoint=self,\n            operation=operation_model, attempts=attempts,\n            caught_exception=caught_exception)\n        handler_response = first_non_none_response(responses)\n        if handler_response is None:\n            return False\n        else:\n            # Request needs to be retried, and we need to sleep\n            # for the specified number of times.\n            logger.debug(\"Response received to retry, sleeping for \"\n                         \"%s seconds\", handler_response)\n            time.sleep(handler_response)\n            return True\n\n\nclass EndpointCreator(object):\n    def __init__(self, event_emitter):\n        self._event_emitter = event_emitter\n\n    def create_endpoint(self, service_model, region_name, endpoint_url,\n                        verify=None, response_parser_factory=None,\n                        timeout=DEFAULT_TIMEOUT):\n        if not is_valid_endpoint_url(endpoint_url):\n            raise ValueError(\"Invalid endpoint: %s\" % endpoint_url)\n        return Endpoint(\n            endpoint_url,\n            endpoint_prefix=service_model.endpoint_prefix,\n            event_emitter=self._event_emitter,\n            proxies=self._get_proxies(endpoint_url),\n            verify=self._get_verify_value(verify),\n            timeout=timeout,\n            response_parser_factory=response_parser_factory)\n\n    def _get_proxies(self, url):\n        # We could also support getting proxies from a config file,\n        # but for now proxy support is taken from the environment.\n        return get_environ_proxies(url)\n\n    def _get_verify_value(self, verify):\n        # This is to account for:\n        # https://github.com/kennethreitz/requests/issues/1436\n        # where we need to honor REQUESTS_CA_BUNDLE because we're creating our\n        # own request objects.\n        # First, if verify is not None, then the user explicitly specified\n        # a value so this automatically wins.\n        if verify is not None:\n            return verify\n        # Otherwise use the value from REQUESTS_CA_BUNDLE, or default to\n        # True if the env var does not exist.\n        return os.environ.get('REQUESTS_CA_BUNDLE', True)",
  "start_line": 200,
  "end_line": 266,
  "total_lines": 266,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "botocore/endpoint.py:236:    def create_endpoint(self, service_model, region_name, endpoint_url,\nbotocore/client.py:184:        endpoint = endpoint_creator.create_endpoint(\nbotocore/client.py:274:            return self._create_endpoint(\nbotocore/client.py:287:    def _create_endpoint(self, resolved, service_name, region_name,\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "            service_name, region_name, endpoint_url, is_secure)\n\n        # Override the user agent if specified in the client config.\n        user_agent = self._user_agent\n        if client_config is not None:\n            if client_config.user_agent is not None:\n                user_agent = client_config.user_agent\n            if client_config.user_agent_extra is not None:\n                user_agent += ' %s' % client_config.user_agent_extra\n\n        signer = RequestSigner(\n            service_name, endpoint_config['signing_region'],\n            endpoint_config['signing_name'],\n            endpoint_config['signature_version'],\n            credentials, event_emitter)\n\n        # Create a new client config to be passed to the client based\n        # on the final values. We do not want the user to be able\n        # to try to modify an existing client with a client config.\n        config_kwargs = dict(\n            region_name=endpoint_config['region_name'],\n            signature_version=endpoint_config['signature_version'],\n            user_agent=user_agent)\n        if client_config is not None:\n            config_kwargs.update(\n                connect_timeout=client_config.connect_timeout,\n                read_timeout=client_config.read_timeout)\n\n        # Add any additional s3 configuration for client\n        self._inject_s3_configuration(\n            config_kwargs, scoped_config, client_config)\n\n        new_config = Config(**config_kwargs)\n        endpoint_creator = EndpointCreator(event_emitter)\n        endpoint = endpoint_creator.create_endpoint(\n            service_model, region_name=endpoint_config['region_name'],\n            endpoint_url=endpoint_config['endpoint_url'], verify=verify,\n            response_parser_factory=self._response_parser_factory,\n            timeout=(new_config.connect_timeout, new_config.read_timeout))\n\n        return {\n            'serializer': serializer,\n            'endpoint': endpoint,\n            'response_parser': response_parser,\n            'event_emitter': event_emitter,\n            'request_signer': signer,\n            'service_model': service_model,\n            'loader': self._loader,\n            'client_config': new_config\n        }\n\n    def _create_methods(self, service_model):\n        op_dict = {}\n        for operation_name in service_model.operation_names:\n            py_operation_name = xform_name(operation_name)\n            op_dict[py_operation_name] = self._create_api_method(\n                py_operation_name, operation_name, service_model)\n        return op_dict\n\n    def _create_name_mapping(self, service_model):\n        # py_name -> OperationName, for every operation available\n        # for a service.\n        mapping = {}\n        for operation_name in service_model.operation_names:\n            py_operation_name = xform_name(operation_name)\n            mapping[py_operation_name] = operation_name\n        return mapping\n\n    def _create_api_method(self, py_operation_name, operation_name,\n                           service_model):\n        def _api_call(self, *args, **kwargs):\n            # We're accepting *args so that we can give a more helpful\n            # error message than TypeError: _api_call takes exactly\n            # 1 argument.\n            if args:\n                raise TypeError(\n                    \"%s() only accepts keyword arguments.\" % py_operation_name)\n            # The \"self\" in this scope is referring to the BaseClient.\n            return self._make_api_call(operation_name, kwargs)\n\n        _api_call.__name__ = str(py_operation_name)\n\n        # Add the docstring to the client method\n        operation_model = service_model.operation_model(operation_name)\n        docstring = ClientMethodDocstring(\n            operation_model=operation_model,\n            method_name=operation_name,\n            event_emitter=self._event_emitter,\n            method_description=operation_model.documentation,\n            example_prefix='response = client.%s' % py_operation_name,\n            include_signature=False\n        )\n        _api_call.__doc__ = docstring\n        return _api_call\n\n\nclass ClientEndpointBridge(object):\n    \"\"\"Bridges endpoint data and client creation\n\n    This class handles taking out the relevant arguments from the endpoint\n    resolver and determining which values to use, taking into account any\n    client configuration options and scope configuration options.\n\n    This class also handles determining what, if any, region to use if no\n    explicit region setting is provided. For example, Amazon S3 client will\n    utilize \"us-east-1\" by default if no region can be resolved.\"\"\"\n\n    DEFAULT_ENDPOINT = '{service}.{region}.amazonaws.com'\n\n    def __init__(self, endpoint_resolver, scoped_config=None,\n                 client_config=None, default_endpoint=None,\n                 service_signing_name=None):\n        self.service_signing_name = service_signing_name\n        self.endpoint_resolver = endpoint_resolver\n        self.scoped_config = scoped_config\n        self.client_config = client_config\n        self.default_endpoint = default_endpoint or self.DEFAULT_ENDPOINT\n\n    def resolve(self, service_name, region_name=None, endpoint_url=None,\n                is_secure=True):\n        region_name = self._check_default_region(service_name, region_name)\n        resolved = self.endpoint_resolver.construct_endpoint(\n            service_name, region_name)\n        if resolved:\n            return self._create_endpoint(\n                resolved, service_name, region_name, endpoint_url, is_secure)\n        else:\n            return self._assume_endpoint(service_name, region_name,\n                                         endpoint_url, is_secure)\n\n    def _check_default_region(self, service_name, region_name):\n        if region_name is not None:\n            return region_name\n        # Use the client_config region if no explicit region was provided.\n        if self.client_config and self.client_config.region_name is not None:\n            return self.client_config.region_name\n\n    def _create_endpoint(self, resolved, service_name, region_name,\n                         endpoint_url, is_secure):\n        region_name, signing_region = self._pick_region_values(\n            resolved, region_name, endpoint_url)\n        if endpoint_url is None:\n            # Use the sslCommonName over the hostname for Python 2.6 compat.\n            hostname = resolved.get('sslCommonName', resolved.get('hostname'))\n            endpoint_url = self._make_url(hostname, is_secure)\n        signature_version = self._resolve_signature_version(\n            service_name, resolved)\n        signing_name = self._resolve_signing_name(service_name, resolved)\n        return self._create_result(\n            service_name=service_name, region_name=region_name,",
  "start_line": 150,
  "end_line": 299,
  "total_lines": 679,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "294:            endpoint_url = self._make_url(hostname, is_secure)\n310:            endpoint_url = self._make_url(hostname, is_secure)\n335:    def _make_url(self, hostname, is_secure):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "            'endpoint_url': endpoint_url,\n            'signature_version': signature_version,\n            'metadata': metadata\n        }\n\n    def _make_url(self, hostname, is_secure):\n        endpoint_url = 'https://' if is_secure else 'http://'\n        return endpoint_url + hostname\n\n    def _resolve_signing_name(self, service_name, resolved):\n        # CredentialScope overrides everything else.\n        if 'credentialScope' in resolved \\\n                and 'service' in resolved['credentialScope']:\n            return resolved['credentialScope']['service']\n        # Use the signingName from the model if present.\n        if self.service_signing_name:",
  "start_line": 330,
  "end_line": 345,
  "total_lines": 679,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "149:        endpoint_config = endpoint_bridge.resolve(\n268:    def resolve(self, service_name, region_name=None, endpoint_url=None,\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "            parameter_validation = client_config.parameter_validation\n        serializer = botocore.serialize.create_serializer(\n            protocol, parameter_validation)\n\n        event_emitter = copy.copy(self._event_emitter)\n        response_parser = botocore.parsers.create_parser(protocol)\n        endpoint_bridge = ClientEndpointBridge(\n            self._endpoint_resolver, scoped_config, client_config,\n            service_model.metadata.get('signingName'))\n        endpoint_config = endpoint_bridge.resolve(\n            service_name, region_name, endpoint_url, is_secure)\n\n        # Override the user agent if specified in the client config.\n        user_agent = self._user_agent\n        if client_config is not None:\n            if client_config.user_agent is not None:",
  "start_line": 140,
  "end_line": 155,
  "total_lines": 679,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "\n        logger.debug(\"Registering retry handlers for service: %s\",\n                     service_model.service_name)\n        handler = self._retry_handler_factory.create_retry_handler(\n            retry_config, endpoint_prefix)\n        unique_id = 'retry-config-%s' % endpoint_prefix\n        self._event_emitter.register('needs-retry.%s' % endpoint_prefix,\n                                     handler, unique_id=unique_id)\n\n    def _inject_s3_configuration(self, config_kwargs, scoped_config,\n                                 client_config):\n        s3_configuration = None\n\n        # Check the scoped config first\n        if scoped_config is not None:\n            s3_configuration = scoped_config.get('s3')\n\n        # Next specfic client config values takes precedence over\n        # specific values in the scoped config.\n        if client_config is not None:\n            if client_config.s3 is not None:\n                if s3_configuration is None:\n                    s3_configuration = client_config.s3\n                else:\n                    # The current s3_configuration dictionary may be\n                    # from a source that only should be read from so\n                    # we want to be safe and just make a copy of it to modify\n                    # before it actually gets updated.\n                    s3_configuration = s3_configuration.copy()\n                    s3_configuration.update(client_config.s3)\n\n        config_kwargs['s3'] = s3_configuration\n\n    def _get_client_args(self, service_model, region_name, is_secure,\n                         endpoint_url, verify, credentials,\n                         scoped_config, client_config):\n        service_name = service_model.endpoint_prefix\n        protocol = service_model.metadata['protocol']\n        parameter_validation = True\n        if client_config:\n            parameter_validation = client_config.parameter_validation",
  "start_line": 100,
  "end_line": 140,
  "total_lines": 679,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "                         endpoint_url, verify, credentials,\n                         scoped_config, client_config):\n        service_name = service_model.endpoint_prefix\n        protocol = service_model.metadata['protocol']\n        parameter_validation = True\n        if client_config:\n            parameter_validation = client_config.parameter_validation\n        serializer = botocore.serialize.create_serializer(\n            protocol, parameter_validation)\n\n        event_emitter = copy.copy(self._event_emitter)\n        response_parser = botocore.parsers.create_parser(protocol)\n        endpoint_bridge = ClientEndpointBridge(\n            self._endpoint_resolver, scoped_config, client_config,\n            service_model.metadata.get('signingName'))\n        endpoint_config = endpoint_bridge.resolve(\n            service_name, region_name, endpoint_url, is_secure)\n\n        # Override the user agent if specified in the client config.\n        user_agent = self._user_agent\n        if client_config is not None:\n            if client_config.user_agent is not None:\n                user_agent = client_config.user_agent\n            if client_config.user_agent_extra is not None:\n                user_agent += ' %s' % client_config.user_agent_extra\n\n        signer = RequestSigner(",
  "start_line": 134,
  "end_line": 160,
  "total_lines": 679,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "60:        client_args = self._get_client_args(\n133:    def _get_client_args(self, service_model, region_name, is_secure,\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "        self._retry_config_translator = retry_config_translator\n        self._response_parser_factory = response_parser_factory\n\n    def create_client(self, service_name, region_name, is_secure=True,\n                      endpoint_url=None, verify=None,\n                      credentials=None, scoped_config=None,\n                      api_version=None,\n                      client_config=None):\n        service_model = self._load_service_model(service_name, api_version)\n        cls = self._create_client_class(service_name, service_model)\n        client_args = self._get_client_args(\n            service_model, region_name, is_secure, endpoint_url,\n            verify, credentials, scoped_config, client_config)\n        return cls(**client_args)\n\n    def create_client_class(self, service_name, api_version=None):\n        service_model = self._load_service_model(service_name, api_version)\n        return self._create_client_class(service_name, service_model)\n\n    def _create_client_class(self, service_name, service_model):\n        class_attributes = self._create_methods(service_model)",
  "start_line": 50,
  "end_line": 70,
  "total_lines": 679,
  "is_truncated": false
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 3, in <module>\n  File \"/workspace/botocore/session.py\", line 800, in create_client\n    credentials = self.get_credentials()\n  File \"/workspace/botocore/session.py\", line 438, in get_credentials\n    'credential_provider').load_credentials()\n  File \"/workspace/botocore/credentials.py\", line 1012, in load_credentials\n    creds = provider.load()\n  File \"/workspace/botocore/credentials.py\", line 472, in load\n    metadata = fetcher.retrieve_iam_role_credentials()\n  File \"/workspace/botocore/utils.py\", line 182, in retrieve_iam_role_credentials\n    r = self._get_request(url, timeout, num_attempts)\n  File \"/workspace/botocore/utils.py\", line 167, in _get_request\n    response = requests.get(url, timeout=timeout)\n  File \"/workspace/botocore/vendored/requests/api.py\", line 69, in get\n    return request('get', url, params=params, **kwargs)\n  File \"/workspace/botocore/vendored/requests/api.py\", line 50, in request\n    response = session.request(method=method, url=url, **kwargs)\n  File \"/workspace/botocore/vendored/requests/sessions.py\", line 465, in request\n    resp = self.send(prep, **send_kwargs)\n  File \"/workspace/botocore/vendored/requests/sessions.py\", line 573, in send\n    r = adapter.send(request, **kwargs)\n  File \"/workspace/botocore/vendored/requests/adapters.py\", line 370, in send\n    timeout=timeout\n  File \"/workspace/botocore/vendored/requests/packages/urllib3/connectionpool.py\", line 544, in urlopen\n    body=body, headers=headers)\n  File \"/workspace/botocore/vendored/requests/packages/urllib3/connectionpool.py\", line 349, in _make_request\n    conn.request(method, url, **httplib_request_kw)\n  File \"/usr/local/lib/python3.7/http/client.py\", line 1281, in request\n    self._send_request(method, url, body, headers, encode_chunked)\nTypeError: _send_request() takes 5 positional arguments but 6 were given\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 3, in <module>\n  File \"/workspace/botocore/session.py\", line 800, in create_client\n    credentials = self.get_credentials()\n  File \"/workspace/botocore/session.py\", line 438, in get_credentials\n    'credential_provider').load_credentials()\n  File \"/workspace/botocore/credentials.py\", line 1012, in load_credentials\n    creds = provider.load()\n  File \"/workspace/botocore/credentials.py\", line 472, in load\n    metadata = fetcher.retrieve_iam_role_credentials()\n  File \"/workspace/botocore/utils.py\", line 182, in retrieve_iam_role_credentials\n    r = self._get_request(url, timeout, num_attempts)\n  File \"/workspace/botocore/utils.py\", line 167, in _get_request\n    response = requests.get(url, timeout=timeout)\n  File \"/workspace/botocore/vendored/requests/api.py\", line 69, in get\n    return request('get', url, params=params, **kwargs)\n  File \"/workspace/botocore/vendored/requests/api.py\", line 50, in request\n    response = session.request(method=method, url=url, **kwargs)\n  File \"/workspace/botocore/vendored/requests/sessions.py\", line 465, in request\n    resp = self.send(prep, **send_kwargs)\n  File \"/workspace/botocore/vendored/requests/sessions.py\", line 573, in send\n    r = adapter.send(request, **kwargs)\n  File \"/workspace/botocore/vendored/requests/adapters.py\", line 370, in send\n    timeout=timeout\n  File \"/workspace/botocore/vendored/requests/packages/urllib3/connectionpool.py\", line 544, in urlopen\n    body=body, headers=headers)\n  File \"/workspace/botocore/vendored/requests/packages/urllib3/connectionpool.py\", line 349, in _make_request\n    conn.request(method, url, **httplib_request_kw)\n  File \"/usr/local/lib/python3.7/http/client.py\", line 1281, in request\n    self._send_request(method, url, body, headers, encode_chunked)\nTypeError: _send_request() takes 5 positional arguments but 6 were given\n",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "stdout": "Endpoint host: https://localhost:8000\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "\n    def _create_methods(self, service_model):\n        op_dict = {}\n        for operation_name in service_model.operation_names:\n            py_operation_name = xform_name(operation_name)\n            op_dict[py_operation_name] = self._create_api_method(\n                py_operation_name, operation_name, service_model)\n        return op_dict\n\n    def _create_name_mapping(self, service_model):\n        # py_name -> OperationName, for every operation available\n        # for a service.\n        mapping = {}\n        for operation_name in service_model.operation_names:\n            py_operation_name = xform_name(operation_name)\n            mapping[py_operation_name] = operation_name\n        return mapping\n\n    def _create_api_method(self, py_operation_name, operation_name,\n                           service_model):\n        def _api_call(self, *args, **kwargs):\n            # We're accepting *args so that we can give a more helpful\n            # error message than TypeError: _api_call takes exactly\n            # 1 argument.\n            if args:\n                raise TypeError(\n                    \"%s() only accepts keyword arguments.\" % py_operation_name)\n            # The \"self\" in this scope is referring to the BaseClient.\n            return self._make_api_call(operation_name, kwargs)\n\n        _api_call.__name__ = str(py_operation_name)\n\n        # Add the docstring to the client method\n        operation_model = service_model.operation_model(operation_name)\n        docstring = ClientMethodDocstring(\n            operation_model=operation_model,\n            method_name=operation_name,\n            event_emitter=self._event_emitter,\n            method_description=operation_model.documentation,\n            example_prefix='response = client.%s' % py_operation_name,\n            include_signature=False\n        )\n        _api_call.__doc__ = docstring\n        return _api_call\n\n\nclass ClientEndpointBridge(object):\n    \"\"\"Bridges endpoint data and client creation\n\n    This class handles taking out the relevant arguments from the endpoint\n    resolver and determining which values to use, taking into account any\n    client configuration options and scope configuration options.\n\n    This class also handles determining what, if any, region to use if no\n    explicit region setting is provided. For example, Amazon S3 client will\n    utilize \"us-east-1\" by default if no region can be resolved.\"\"\"\n\n    DEFAULT_ENDPOINT = '{service}.{region}.amazonaws.com'\n\n    def __init__(self, endpoint_resolver, scoped_config=None,\n                 client_config=None, default_endpoint=None,",
  "start_line": 200,
  "end_line": 260,
  "total_lines": 679,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "274:            return self._create_endpoint(\n287:    def _create_endpoint(self, resolved, service_name, region_name,\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "        region_name = self._check_default_region(service_name, region_name)\n        resolved = self.endpoint_resolver.construct_endpoint(\n            service_name, region_name)\n        if resolved:\n            return self._create_endpoint(\n                resolved, service_name, region_name, endpoint_url, is_secure)\n        else:\n            return self._assume_endpoint(service_name, region_name,\n                                         endpoint_url, is_secure)\n\n    def _check_default_region(self, service_name, region_name):\n        if region_name is not None:\n            return region_name\n        # Use the client_config region if no explicit region was provided.\n        if self.client_config and self.client_config.region_name is not None:\n            return self.client_config.region_name\n\n    def _create_endpoint(self, resolved, service_name, region_name,\n                         endpoint_url, is_secure):\n        region_name, signing_region = self._pick_region_values(\n            resolved, region_name, endpoint_url)\n        if endpoint_url is None:\n            # Use the sslCommonName over the hostname for Python 2.6 compat.\n            hostname = resolved.get('sslCommonName', resolved.get('hostname'))\n            endpoint_url = self._make_url(hostname, is_secure)\n        signature_version = self._resolve_signature_version(\n            service_name, resolved)\n        signing_name = self._resolve_signing_name(service_name, resolved)\n        return self._create_result(\n            service_name=service_name, region_name=region_name,\n            signing_region=signing_region, signing_name=signing_name,\n            endpoint_url=endpoint_url, metadata=resolved,\n            signature_version=signature_version)\n\n    def _assume_endpoint(self, service_name, region_name, endpoint_url,\n                         is_secure):\n        if endpoint_url is None:\n            # Expand the default hostname URI template.\n            hostname = self.default_endpoint.format(\n                service=service_name, region=region_name)\n            endpoint_url = self._make_url(hostname, is_secure)\n        logger.debug('Assuming an endpoint for %s, %s: %s',\n                     service_name, region_name, endpoint_url)\n        # We still want to allow the user to provide an explicit version.\n        signature_version = self._resolve_signature_version(\n            service_name, {'signatureVersions': ['v4']})\n        return self._create_result(\n            service_name=service_name, region_name=region_name,\n            signing_region=region_name, signing_name=service_name,\n            signature_version=signature_version, endpoint_url=endpoint_url,\n            metadata={})",
  "start_line": 270,
  "end_line": 320,
  "total_lines": 679,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "occurrences": 1,
  "strategy": "exact",
  "diff": "--- a/botocore/client.py\n+++ b/botocore/client.py\n@@ -291,6 +291,9 @@\n         if endpoint_url is None:\n             # Use the sslCommonName over the hostname for Python 2.6 compat.\n             hostname = resolved.get('sslCommonName', resolved.get('hostname'))\n+            protocols = resolved.get('protocols')\n+            if protocols and 'https' not in protocols:\n+                is_secure = False\n             endpoint_url = self._make_url(hostname, is_secure)\n         signature_version = self._resolve_signature_version(\n             service_name, resolved)\n",
  "is_truncated": false,
  "budget_warning": "Only 10 tool call(s) remaining (20/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "Endpoint host: http://localhost:8000\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 9 tool call(s) remaining (21/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "297:            endpoint_url = self._make_url(hostname, is_secure)\n313:            endpoint_url = self._make_url(hostname, is_secure)\n338:    def _make_url(self, hostname, is_secure):\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 8 tool call(s) remaining (22/30 used). Finalize your edits and call submit_patch soon."
}