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",
  "filepath": "botocore/endpoint.py",
  "content": "            # body.\n            request.reset_stream()\n            # Create a new request when retried (including a new signature).\n            request = self.create_request(\n                request_dict, operation_model=operation_model)\n            success_response, exception = self._get_response(\n                request, operation_model, attempts)\n        if exception is not None:\n            raise exception\n        else:\n            return success_response\n\n    def _get_response(self, request, operation_model, attempts):\n        # This will return a tuple of (success_response, exception)\n        # and success_response is itself a tuple of\n        # (http_response, parsed_dict).\n        # If an exception occurs then the success_response is None.\n        # If no exception occurs then exception is None.\n        try:\n            logger.debug(\"Sending http request: %s\", request)\n            http_response = self.http_session.send(\n                request, verify=self.verify,\n                stream=operation_model.has_streaming_output,\n                proxies=self.proxies, timeout=self.timeout)\n        except ConnectionError as e:\n            # For a connection error, if it looks like it's a DNS\n            # lookup issue, 99% of the time this is due to a misconfigured\n            # region/endpoint so we'll raise a more specific error message\n            # to help users.\n            logger.debug(\"ConnectionError received when sending HTTP request.\",\n                         exc_info=True)\n            if self._looks_like_dns_error(e):\n                endpoint_url = e.request.url\n                better_exception = EndpointConnectionError(\n                    endpoint_url=endpoint_url, error=e)\n                return (None, better_exception)\n            elif self._looks_like_bad_status_line(e):\n                better_exception = ConnectionClosedError(\n                    endpoint_url=e.request.url, request=e.request)\n                return (None, better_exception)\n            else:\n                return (None, e)\n        except Exception as e:\n            logger.debug(\"Exception received when sending HTTP request.\",\n                         exc_info=True)\n            return (None, e)\n        # This returns the http_response and the parsed_data.\n        response_dict = convert_to_response_dict(http_response,\n                                                 operation_model)\n        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": 151,
  "end_line": 266,
  "total_lines": 266,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "botocore/awsrequest.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.\nimport sys\nimport logging\nimport select\nimport functools\nimport socket\nimport inspect\n\nfrom botocore.compat import six\nfrom botocore.compat import HTTPHeaders, HTTPResponse, urlunsplit, urlsplit\nfrom botocore.exceptions import UnseekableStreamError\nfrom botocore.utils import percent_encode_sequence\nfrom botocore.vendored.requests import models\nfrom botocore.vendored.requests.sessions import REDIRECT_STATI\nfrom botocore.vendored.requests.packages.urllib3.connection import \\\n    VerifiedHTTPSConnection\nfrom botocore.vendored.requests.packages.urllib3.connection import \\\n    HTTPConnection\nfrom botocore.vendored.requests.packages.urllib3.connectionpool import \\\n    HTTPConnectionPool\nfrom botocore.vendored.requests.packages.urllib3.connectionpool import \\\n    HTTPSConnectionPool\n\n\nlogger = logging.getLogger(__name__)\n\n\nclass AWSHTTPResponse(HTTPResponse):\n    # The *args, **kwargs is used because the args are slightly\n    # different in py2.6 than in py2.7/py3.\n    def __init__(self, *args, **kwargs):\n        self._status_tuple = kwargs.pop('status_tuple')\n        HTTPResponse.__init__(self, *args, **kwargs)\n\n    def _read_status(self):\n        if self._status_tuple is not None:\n            status_tuple = self._status_tuple\n            self._status_tuple = None\n            return status_tuple\n        else:\n            return HTTPResponse._read_status(self)\n\n\nclass AWSHTTPConnection(HTTPConnection):\n    \"\"\"HTTPConnection that supports Expect 100-continue.\n\n    This is conceptually a subclass of httplib.HTTPConnection (though\n    technically we subclass from urllib3, which subclasses\n    httplib.HTTPConnection) and we only override this class to support Expect\n    100-continue, which we need for S3.  As far as I can tell, this is\n    general purpose enough to not be specific to S3, but I'm being\n    tentative and keeping it in botocore because I've only tested\n    this against AWS services.\n\n    \"\"\"\n    def __init__(self, *args, **kwargs):\n        HTTPConnection.__init__(self, *args, **kwargs)\n        self._original_response_cls = self.response_class\n        # We'd ideally hook into httplib's states, but they're all\n        # __mangled_vars so we use our own state var.  This variable is set\n        # when we receive an early response from the server.  If this value is\n        # set to True, any calls to send() are noops.  This value is reset to\n        # false every time _send_request is called.  This is to workaround the\n        # fact that py2.6 (and only py2.6) has a separate send() call for the\n        # body in _send_request, as opposed to endheaders(), which is where the\n        # body is sent in all versions > 2.6.\n        self._response_received = False\n        self._expect_header_set = False\n\n    def close(self):\n        HTTPConnection.close(self)\n        # Reset all of our instance state we were tracking.\n        self._response_received = False\n        self._expect_header_set = False\n        self.response_class = self._original_response_cls\n\n    def _tunnel(self):\n        # Works around a bug in py26 which is fixed in later versions of\n        # python. Bug involves hitting an infinite loop if readline() returns\n        # nothing as opposed to just ``\\r\\n``.\n        # As much as I don't like having if py2: <foo> code blocks, this seems\n        # the cleanest way to handle this workaround.  Fortunately, the\n        # difference from py26 to py3 is very minimal.  We're essentially\n        # just overriding the while loop.\n        if sys.version_info[:2] != (2, 6):\n            return HTTPConnection._tunnel(self)\n\n        # Otherwise we workaround the issue.\n        self._set_hostport(self._tunnel_host, self._tunnel_port)\n        self.send(\"CONNECT %s:%d HTTP/1.0\\r\\n\" % (self.host, self.port))\n        for header, value in self._tunnel_headers.iteritems():\n            self.send(\"%s: %s\\r\\n\" % (header, value))\n        self.send(\"\\r\\n\")\n        response = self.response_class(self.sock, strict=self.strict,\n                                       method=self._method)\n        (version, code, message) = response._read_status()\n\n        if code != 200:\n            self.close()\n            raise socket.error(\"Tunnel connection failed: %d %s\" %\n                               (code, message.strip()))\n        while True:\n            line = response.fp.readline()\n            if not line:\n                break\n            if line in (b'\\r\\n', b'\\n', b''):\n                break\n\n    def _send_request(self, method, url, body, headers):\n        self._response_received = False\n        if headers.get('Expect', b'') == b'100-continue':\n            self._expect_header_set = True\n        else:\n            self._expect_header_set = False\n            self.response_class = self._original_response_cls\n        rval = HTTPConnection._send_request(\n            self, method, url, body, headers)\n        self._expect_header_set = False\n        return rval\n\n    def _convert_to_bytes(self, mixed_buffer):\n        # Take a list of mixed str/bytes and convert it\n        # all into a single bytestring.\n        # Any six.text_types will be encoded as utf-8.\n        bytes_buffer = []\n        for chunk in mixed_buffer:\n            if isinstance(chunk, six.text_type):\n                bytes_buffer.append(chunk.encode('utf-8'))\n            else:\n                bytes_buffer.append(chunk)\n        msg = b\"\\r\\n\".join(bytes_buffer)\n        return msg\n\n    def _send_output(self, message_body=None):\n        self._buffer.extend((b\"\", b\"\"))\n        msg = self._convert_to_bytes(self._buffer)\n        del self._buffer[:]\n        # If msg and message_body are sent in a single send() call,",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 448,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "botocore/awsrequest.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.\nimport sys\nimport logging\nimport select\nimport functools\nimport socket\nimport inspect\n\nfrom botocore.compat import six\nfrom botocore.compat import HTTPHeaders, HTTPResponse, urlunsplit, urlsplit\nfrom botocore.exceptions import UnseekableStreamError\nfrom botocore.utils import percent_encode_sequence\nfrom botocore.vendored.requests import models\nfrom botocore.vendored.requests.sessions import REDIRECT_STATI\nfrom botocore.vendored.requests.packages.urllib3.connection import \\\n    VerifiedHTTPSConnection\nfrom botocore.vendored.requests.packages.urllib3.connection import \\\n    HTTPConnection\nfrom botocore.vendored.requests.packages.urllib3.connectionpool import \\\n    HTTPConnectionPool\nfrom botocore.vendored.requests.packages.urllib3.connectionpool import \\\n    HTTPSConnectionPool\n\n\nlogger = logging.getLogger(__name__)\n\n\nclass AWSHTTPResponse(HTTPResponse):\n    # The *args, **kwargs is used because the args are slightly\n    # different in py2.6 than in py2.7/py3.\n    def __init__(self, *args, **kwargs):\n        self._status_tuple = kwargs.pop('status_tuple')\n        HTTPResponse.__init__(self, *args, **kwargs)\n\n    def _read_status(self):\n        if self._status_tuple is not None:\n            status_tuple = self._status_tuple\n            self._status_tuple = None\n            return status_tuple\n        else:\n            return HTTPResponse._read_status(self)\n\n\nclass AWSHTTPConnection(HTTPConnection):\n    \"\"\"HTTPConnection that supports Expect 100-continue.\n\n    This is conceptually a subclass of httplib.HTTPConnection (though\n    technically we subclass from urllib3, which subclasses\n    httplib.HTTPConnection) and we only override this class to support Expect\n    100-continue, which we need for S3.  As far as I can tell, this is\n    general purpose enough to not be specific to S3, but I'm being\n    tentative and keeping it in botocore because I've only tested\n    this against AWS services.\n\n    \"\"\"\n    def __init__(self, *args, **kwargs):\n        HTTPConnection.__init__(self, *args, **kwargs)\n        self._original_response_cls = self.response_class\n        # We'd ideally hook into httplib's states, but they're all\n        # __mangled_vars so we use our own state var.  This variable is set\n        # when we receive an early response from the server.  If this value is\n        # set to True, any calls to send() are noops.  This value is reset to\n        # false every time _send_request is called.  This is to workaround the\n        # fact that py2.6 (and only py2.6) has a separate send() call for the\n        # body in _send_request, as opposed to endheaders(), which is where the\n        # body is sent in all versions > 2.6.\n        self._response_received = False\n        self._expect_header_set = False\n\n    def close(self):\n        HTTPConnection.close(self)\n        # Reset all of our instance state we were tracking.\n        self._response_received = False\n        self._expect_header_set = False\n        self.response_class = self._original_response_cls\n\n    def _tunnel(self):\n        # Works around a bug in py26 which is fixed in later versions of\n        # python. Bug involves hitting an infinite loop if readline() returns\n        # nothing as opposed to just ``\\r\\n``.\n        # As much as I don't like having if py2: <foo> code blocks, this seems\n        # the cleanest way to handle this workaround.  Fortunately, the\n        # difference from py26 to py3 is very minimal.  We're essentially\n        # just overriding the while loop.\n        if sys.version_info[:2] != (2, 6):\n            return HTTPConnection._tunnel(self)\n\n        # Otherwise we workaround the issue.\n        self._set_hostport(self._tunnel_host, self._tunnel_port)\n        self.send(\"CONNECT %s:%d HTTP/1.0\\r\\n\" % (self.host, self.port))\n        for header, value in self._tunnel_headers.iteritems():\n            self.send(\"%s: %s\\r\\n\" % (header, value))\n        self.send(\"\\r\\n\")\n        response = self.response_class(self.sock, strict=self.strict,\n                                       method=self._method)\n        (version, code, message) = response._read_status()\n\n        if code != 200:\n            self.close()\n            raise socket.error(\"Tunnel connection failed: %d %s\" %\n                               (code, message.strip()))\n        while True:\n            line = response.fp.readline()\n            if not line:\n                break\n            if line in (b'\\r\\n', b'\\n', b''):\n                break\n\n    def _send_request(self, method, url, body, headers):\n        self._response_received = False\n        if headers.get('Expect', b'') == b'100-continue':\n            self._expect_header_set = True\n        else:\n            self._expect_header_set = False\n            self.response_class = self._original_response_cls\n        rval = HTTPConnection._send_request(\n            self, method, url, body, headers)\n        self._expect_header_set = False\n        return rval\n\n    def _convert_to_bytes(self, mixed_buffer):\n        # Take a list of mixed str/bytes and convert it\n        # all into a single bytestring.\n        # Any six.text_types will be encoded as utf-8.\n        bytes_buffer = []\n        for chunk in mixed_buffer:\n            if isinstance(chunk, six.text_type):\n                bytes_buffer.append(chunk.encode('utf-8'))\n            else:\n                bytes_buffer.append(chunk)\n        msg = b\"\\r\\n\".join(bytes_buffer)\n        return msg\n\n    def _send_output(self, message_body=None):\n        self._buffer.extend((b\"\", b\"\"))\n        msg = self._convert_to_bytes(self._buffer)\n        del self._buffer[:]\n        # If msg and message_body are sent in a single send() call,",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 448,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "294:def create_request_object(request_dict):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "botocore/awsrequest.py",
  "content": "            url += '&%s' % encoded_query_string\n    r['url'] = url\n\n\ndef create_request_object(request_dict):\n    \"\"\"\n    This method takes a request dict and creates an AWSRequest object\n    from it.\n\n    :type request_dict: dict\n    :param request_dict:  The request dict (created from the\n        ``prepare_request_dict`` method).\n\n    :rtype: ``botocore.awsrequest.AWSRequest``\n    :return: An AWSRequest object based on the request_dict.\n\n    \"\"\"\n    r = request_dict\n    return AWSRequest(method=r['method'], url=r['url'],\n                      data=r['body'],\n                      headers=r['headers'])\n\n\ndef _urljoin(endpoint_url, url_path):\n    p = urlsplit(endpoint_url)\n    # <part>   - <index>\n    # scheme   - p[0]\n    # netloc   - p[1]\n    # path     - p[2]\n    # query    - p[3]\n    # fragment - p[4]\n    if not url_path or url_path == '/':\n        # If there's no path component, ensure the URL ends with\n        # a '/' for backwards compatibility.\n        if not p[2]:\n            return endpoint_url + '/'\n        return endpoint_url\n    if p[2].endswith('/') and url_path.startswith('/'):\n        new_path = p[2][:-1] + url_path\n    else:\n        new_path = p[2] + url_path\n    reconstructed = urlunsplit((p[0], p[1], new_path, p[3], p[4]))\n    return reconstructed\n\n\nclass AWSRequest(models.RequestEncodingMixin, models.Request):\n    def __init__(self, *args, **kwargs):\n        self.auth_path = None\n        if 'auth_path' in kwargs:\n            self.auth_path = kwargs['auth_path']\n            del kwargs['auth_path']\n        models.Request.__init__(self, *args, **kwargs)\n        headers = HTTPHeaders()\n        if self.headers is not None:\n            for key, value in self.headers.items():\n                headers[key] = value\n        self.headers = headers\n        # This is a dictionary to hold information that is used when\n        # processing the request. What is inside of ``context`` is open-ended.\n        # For example, it may have a timestamp key that is used for holding\n        # what the timestamp is when signing the request. Note that none",
  "start_line": 290,
  "end_line": 350,
  "total_lines": 448,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "263:def prepare_request_dict(request_dict, endpoint_url, user_agent=None):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "botocore/awsrequest.py",
  "content": "def prepare_request_dict(request_dict, endpoint_url, user_agent=None):\n    \"\"\"\n    This method prepares a request dict to be created into an\n    AWSRequestObject. This prepares the request dict by adding the\n    url and the user agent to the request dict.\n\n    :type request_dict: dict\n    :param request_dict:  The request dict (created from the\n        ``serialize`` module).\n\n    :type user_agent: string\n    :param user_agent: The user agent to use for this request.\n\n    :type endpoint_url: string\n    :param endpoint_url: The full endpoint url, which contains at least\n        the scheme, the hostname, and optionally any path components.\n    \"\"\"\n    r = request_dict\n    if user_agent is not None:\n        headers = r['headers']\n        headers['User-Agent'] = user_agent\n    url = _urljoin(endpoint_url, r['url_path'])\n    if r['query_string']:\n        encoded_query_string = percent_encode_sequence(r['query_string'])\n        if '?' not in url:\n            url += '?%s' % encoded_query_string\n        else:\n            url += '&%s' % encoded_query_string\n    r['url'] = url\n\n",
  "start_line": 263,
  "end_line": 293,
  "total_lines": 448,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "botocore/awsrequest.py:263:def prepare_request_dict(request_dict, endpoint_url, user_agent=None):\nbotocore/awsrequest.py:301:        ``prepare_request_dict`` method).\nbotocore/client.py:20:from botocore.awsrequest import prepare_request_dict\nbotocore/client.py:516:        prepare_request_dict(request_dict, endpoint_url=self._endpoint.host,\nbotocore/signers.py:21:from botocore.awsrequest import create_request_object, prepare_request_dict\nbotocore/signers.py:178:            ``botocore.awsrequest.prepare_request_dict()``\nbotocore/signers.py:356:            ``botocore.awsrequest.prepare_request_dict()``\nbotocore/signers.py:494:    prepare_request_dict(\nbotocore/signers.py:595:    prepare_request_dict(\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "# Copyright 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.\nimport copy\nimport logging\n\nimport botocore.serialize\nimport botocore.validate\nfrom botocore import waiter, xform_name\nfrom botocore.auth import AUTH_TYPE_MAPS\nfrom botocore.awsrequest import prepare_request_dict\nfrom botocore.config import Config\nfrom botocore.docs.docstring import ClientMethodDocstring\nfrom botocore.docs.docstring import PaginatorDocstring\nfrom botocore.endpoint import EndpointCreator\nfrom botocore.exceptions import ClientError, DataNotFoundError\nfrom botocore.exceptions import OperationNotPageableError\nfrom botocore.exceptions import UnknownSignatureVersionError\nfrom botocore.hooks import first_non_none_response\nfrom botocore.model import ServiceModel\nfrom botocore.paginate import Paginator\nfrom botocore.signers import RequestSigner\nfrom botocore.utils import CachedProperty\nfrom botocore.utils import fix_s3_host\nfrom botocore.utils import get_service_module_name\nfrom botocore.utils import switch_to_virtual_host_style\n\nlogger = logging.getLogger(__name__)\n\n\nclass ClientCreator(object):\n    \"\"\"Creates client objects for a service.\"\"\"\n    def __init__(self, loader, endpoint_resolver, user_agent, event_emitter,\n                 retry_handler_factory, retry_config_translator,\n                 response_parser_factory=None):\n        self._loader = loader\n        self._endpoint_resolver = endpoint_resolver\n        self._user_agent = user_agent\n        self._event_emitter = event_emitter\n        self._retry_handler_factory = retry_handler_factory\n        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)\n        py_name_to_operation_name = self._create_name_mapping(service_model)\n        class_attributes['_PY_TO_OP_NAME'] = py_name_to_operation_name\n        bases = [BaseClient]\n        self._event_emitter.emit('creating-client-class.%s' % service_name,\n                                 class_attributes=class_attributes,\n                                 base_classes=bases)\n        class_name = get_service_module_name(service_model)\n        cls = type(str(class_name), tuple(bases), class_attributes)\n        return cls\n\n    def _load_service_model(self, service_name, api_version=None):\n        json_model = self._loader.load_service_model(service_name, 'service-2',\n                                                     api_version=api_version)\n        service_model = ServiceModel(json_model, service_name=service_name)\n        self._register_retries(service_model)\n        return service_model\n\n    def _register_retries(self, service_model):\n        endpoint_prefix = service_model.endpoint_prefix\n\n        # First, we load the entire retry config for all services,\n        # then pull out just the information we need.\n        original_config = self._loader.load_data('_retry')\n        if not original_config:\n            return\n\n        retry_config = self._retry_config_translator.build_retry_config(\n            endpoint_prefix, original_config.get('retry', {}),\n            original_config.get('definitions', {}))\n\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\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)",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 679,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "246:class ClientEndpointBridge(object):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "class 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,\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={})\n\n    def _create_result(self, service_name, region_name, signing_region,\n                       signing_name, endpoint_url, signature_version,\n                       metadata):\n        return {\n            'service_name': service_name,\n            'region_name': region_name,\n            'signing_region': signing_region,\n            'signing_name': signing_name,\n            '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:\n            return self.service_signing_name\n        # Just assume is the same as the service name.\n        return service_name\n\n    def _pick_region_values(self, resolved, region_name, endpoint_url):\n        signing_region = region_name\n        if endpoint_url is None:\n            # Do not use the region name or signing name from the resolved\n            # endpoint if the user explicitly provides an endpoint_url. This\n            # would happen if we resolve to an endpoint where the service has\n            # a \"defaults\" section that overrides all endpoint with a single\n            # hostname and credentialScope. This has been the case historically\n            # for how STS has worked. The only way to resolve an STS endpoint\n            # was to provide a region_name and an endpoint_url. In that case,\n            # we would still resolve an endpoint, but we would not use the\n            # resolved endpointName or signingRegion because we want to allow\n            # custom endpoints.\n            region_name = resolved['endpointName']\n            signing_region = region_name\n            if 'credentialScope' in resolved \\\n                    and 'region' in resolved['credentialScope']:\n                signing_region = resolved['credentialScope']['region']\n        return region_name, signing_region\n\n    def _resolve_signature_version(self, service_name, resolved):\n        # Client config overrides everything.\n        client = self.client_config\n        if client and client.signature_version is not None:\n            return client.signature_version\n        # Scoped config overrides picking from the endpoint metadata.\n        scoped = self.scoped_config\n        if scoped is not None:\n            service_config = scoped.get(service_name)\n            if service_config is not None and isinstance(service_config, dict):\n                version = service_config.get('signature_version')\n                if version:\n                    logger.debug(\n                        \"Switching signature version for service %s \"\n                        \"to version %s based on config file override.\",\n                        service_name, version)\n                    return version\n        # Pick a signature version from the endpoint metadata if present.\n        if 'signatureVersions' in resolved:\n            potential_versions = resolved['signatureVersions']\n            if service_name == 's3':\n                # We currently prefer s3 over s3v4.\n                if 's3' in potential_versions:\n                    return 's3'\n                elif 's3v4' in potential_versions:\n                    return 's3v4'",
  "start_line": 246,
  "end_line": 395,
  "total_lines": 679,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "# Copyright 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.\nimport copy\nimport logging\n\nimport botocore.serialize\nimport botocore.validate\nfrom botocore import waiter, xform_name\nfrom botocore.auth import AUTH_TYPE_MAPS\nfrom botocore.awsrequest import prepare_request_dict\nfrom botocore.config import Config\nfrom botocore.docs.docstring import ClientMethodDocstring\nfrom botocore.docs.docstring import PaginatorDocstring\nfrom botocore.endpoint import EndpointCreator\nfrom botocore.exceptions import ClientError, DataNotFoundError\nfrom botocore.exceptions import OperationNotPageableError\nfrom botocore.exceptions import UnknownSignatureVersionError\nfrom botocore.hooks import first_non_none_response\nfrom botocore.model import ServiceModel\nfrom botocore.paginate import Paginator\nfrom botocore.signers import RequestSigner\nfrom botocore.utils import CachedProperty\nfrom botocore.utils import fix_s3_host\nfrom botocore.utils import get_service_module_name\nfrom botocore.utils import switch_to_virtual_host_style\n\nlogger = logging.getLogger(__name__)\n\n\nclass ClientCreator(object):\n    \"\"\"Creates client objects for a service.\"\"\"\n    def __init__(self, loader, endpoint_resolver, user_agent, event_emitter,\n                 retry_handler_factory, retry_config_translator,\n                 response_parser_factory=None):\n        self._loader = loader\n        self._endpoint_resolver = endpoint_resolver\n        self._user_agent = user_agent\n        self._event_emitter = event_emitter\n        self._retry_handler_factory = retry_handler_factory\n        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)\n        py_name_to_operation_name = self._create_name_mapping(service_model)\n        class_attributes['_PY_TO_OP_NAME'] = py_name_to_operation_name\n        bases = [BaseClient]\n        self._event_emitter.emit('creating-client-class.%s' % service_name,\n                                 class_attributes=class_attributes,\n                                 base_classes=bases)\n        class_name = get_service_module_name(service_model)\n        cls = type(str(class_name), tuple(bases), class_attributes)\n        return cls\n\n    def _load_service_model(self, service_name, api_version=None):\n        json_model = self._loader.load_service_model(service_name, 'service-2',\n                                                     api_version=api_version)\n        service_model = ServiceModel(json_model, service_name=service_name)\n        self._register_retries(service_model)\n        return service_model\n\n    def _register_retries(self, service_model):\n        endpoint_prefix = service_model.endpoint_prefix\n\n        # First, we load the entire retry config for all services,\n        # then pull out just the information we need.\n        original_config = self._loader.load_data('_retry')\n        if not original_config:\n            return\n\n        retry_config = self._retry_config_translator.build_retry_config(\n            endpoint_prefix, original_config.get('retry', {}),\n            original_config.get('definitions', {}))\n\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\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)",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 679,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "\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,\n            signing_region=signing_region, signing_name=signing_name,",
  "start_line": 151,
  "end_line": 300,
  "total_lines": 679,
  "is_truncated": true
}

{
  "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",
  "filepath": "botocore/endpoint.py",
  "content": "            # body.\n            request.reset_stream()\n            # Create a new request when retried (including a new signature).\n            request = self.create_request(\n                request_dict, operation_model=operation_model)\n            success_response, exception = self._get_response(\n                request, operation_model, attempts)\n        if exception is not None:\n            raise exception\n        else:\n            return success_response\n\n    def _get_response(self, request, operation_model, attempts):\n        # This will return a tuple of (success_response, exception)\n        # and success_response is itself a tuple of\n        # (http_response, parsed_dict).\n        # If an exception occurs then the success_response is None.\n        # If no exception occurs then exception is None.\n        try:\n            logger.debug(\"Sending http request: %s\", request)\n            http_response = self.http_session.send(\n                request, verify=self.verify,\n                stream=operation_model.has_streaming_output,\n                proxies=self.proxies, timeout=self.timeout)\n        except ConnectionError as e:\n            # For a connection error, if it looks like it's a DNS\n            # lookup issue, 99% of the time this is due to a misconfigured\n            # region/endpoint so we'll raise a more specific error message\n            # to help users.\n            logger.debug(\"ConnectionError received when sending HTTP request.\",\n                         exc_info=True)\n            if self._looks_like_dns_error(e):\n                endpoint_url = e.request.url\n                better_exception = EndpointConnectionError(\n                    endpoint_url=endpoint_url, error=e)\n                return (None, better_exception)\n            elif self._looks_like_bad_status_line(e):\n                better_exception = ConnectionClosedError(\n                    endpoint_url=e.request.url, request=e.request)\n                return (None, better_exception)\n            else:\n                return (None, e)\n        except Exception as e:\n            logger.debug(\"Exception received when sending HTTP request.\",\n                         exc_info=True)\n            return (None, e)\n        # This returns the http_response and the parsed_data.\n        response_dict = convert_to_response_dict(http_response,\n                                                 operation_model)\n        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": 151,
  "end_line": 266,
  "total_lines": 266,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "botocore/awsrequest.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.\nimport sys\nimport logging\nimport select\nimport functools\nimport socket\nimport inspect\n\nfrom botocore.compat import six\nfrom botocore.compat import HTTPHeaders, HTTPResponse, urlunsplit, urlsplit\nfrom botocore.exceptions import UnseekableStreamError\nfrom botocore.utils import percent_encode_sequence\nfrom botocore.vendored.requests import models\nfrom botocore.vendored.requests.sessions import REDIRECT_STATI\nfrom botocore.vendored.requests.packages.urllib3.connection import \\\n    VerifiedHTTPSConnection\nfrom botocore.vendored.requests.packages.urllib3.connection import \\\n    HTTPConnection\nfrom botocore.vendored.requests.packages.urllib3.connectionpool import \\\n    HTTPConnectionPool\nfrom botocore.vendored.requests.packages.urllib3.connectionpool import \\\n    HTTPSConnectionPool\n\n\nlogger = logging.getLogger(__name__)\n\n\nclass AWSHTTPResponse(HTTPResponse):\n    # The *args, **kwargs is used because the args are slightly\n    # different in py2.6 than in py2.7/py3.\n    def __init__(self, *args, **kwargs):\n        self._status_tuple = kwargs.pop('status_tuple')\n        HTTPResponse.__init__(self, *args, **kwargs)\n\n    def _read_status(self):\n        if self._status_tuple is not None:\n            status_tuple = self._status_tuple\n            self._status_tuple = None\n            return status_tuple\n        else:\n            return HTTPResponse._read_status(self)\n\n\nclass AWSHTTPConnection(HTTPConnection):\n    \"\"\"HTTPConnection that supports Expect 100-continue.\n\n    This is conceptually a subclass of httplib.HTTPConnection (though\n    technically we subclass from urllib3, which subclasses\n    httplib.HTTPConnection) and we only override this class to support Expect\n    100-continue, which we need for S3.  As far as I can tell, this is\n    general purpose enough to not be specific to S3, but I'm being\n    tentative and keeping it in botocore because I've only tested\n    this against AWS services.\n\n    \"\"\"\n    def __init__(self, *args, **kwargs):\n        HTTPConnection.__init__(self, *args, **kwargs)\n        self._original_response_cls = self.response_class\n        # We'd ideally hook into httplib's states, but they're all\n        # __mangled_vars so we use our own state var.  This variable is set\n        # when we receive an early response from the server.  If this value is\n        # set to True, any calls to send() are noops.  This value is reset to\n        # false every time _send_request is called.  This is to workaround the\n        # fact that py2.6 (and only py2.6) has a separate send() call for the\n        # body in _send_request, as opposed to endheaders(), which is where the\n        # body is sent in all versions > 2.6.\n        self._response_received = False\n        self._expect_header_set = False\n\n    def close(self):\n        HTTPConnection.close(self)\n        # Reset all of our instance state we were tracking.\n        self._response_received = False\n        self._expect_header_set = False\n        self.response_class = self._original_response_cls\n\n    def _tunnel(self):\n        # Works around a bug in py26 which is fixed in later versions of\n        # python. Bug involves hitting an infinite loop if readline() returns\n        # nothing as opposed to just ``\\r\\n``.\n        # As much as I don't like having if py2: <foo> code blocks, this seems\n        # the cleanest way to handle this workaround.  Fortunately, the\n        # difference from py26 to py3 is very minimal.  We're essentially\n        # just overriding the while loop.\n        if sys.version_info[:2] != (2, 6):\n            return HTTPConnection._tunnel(self)\n\n        # Otherwise we workaround the issue.\n        self._set_hostport(self._tunnel_host, self._tunnel_port)\n        self.send(\"CONNECT %s:%d HTTP/1.0\\r\\n\" % (self.host, self.port))\n        for header, value in self._tunnel_headers.iteritems():\n            self.send(\"%s: %s\\r\\n\" % (header, value))\n        self.send(\"\\r\\n\")\n        response = self.response_class(self.sock, strict=self.strict,\n                                       method=self._method)\n        (version, code, message) = response._read_status()\n\n        if code != 200:\n            self.close()\n            raise socket.error(\"Tunnel connection failed: %d %s\" %\n                               (code, message.strip()))\n        while True:\n            line = response.fp.readline()\n            if not line:\n                break\n            if line in (b'\\r\\n', b'\\n', b''):\n                break\n\n    def _send_request(self, method, url, body, headers):\n        self._response_received = False\n        if headers.get('Expect', b'') == b'100-continue':\n            self._expect_header_set = True\n        else:\n            self._expect_header_set = False\n            self.response_class = self._original_response_cls\n        rval = HTTPConnection._send_request(\n            self, method, url, body, headers)\n        self._expect_header_set = False\n        return rval\n\n    def _convert_to_bytes(self, mixed_buffer):\n        # Take a list of mixed str/bytes and convert it\n        # all into a single bytestring.\n        # Any six.text_types will be encoded as utf-8.\n        bytes_buffer = []\n        for chunk in mixed_buffer:\n            if isinstance(chunk, six.text_type):\n                bytes_buffer.append(chunk.encode('utf-8'))\n            else:\n                bytes_buffer.append(chunk)\n        msg = b\"\\r\\n\".join(bytes_buffer)\n        return msg\n\n    def _send_output(self, message_body=None):\n        self._buffer.extend((b\"\", b\"\"))\n        msg = self._convert_to_bytes(self._buffer)\n        del self._buffer[:]\n        # If msg and message_body are sent in a single send() call,",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 448,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "294:def create_request_object(request_dict):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "botocore/awsrequest.py",
  "content": "def create_request_object(request_dict):\n    \"\"\"\n    This method takes a request dict and creates an AWSRequest object\n    from it.\n\n    :type request_dict: dict\n    :param request_dict:  The request dict (created from the\n        ``prepare_request_dict`` method).\n\n    :rtype: ``botocore.awsrequest.AWSRequest``\n    :return: An AWSRequest object based on the request_dict.\n\n    \"\"\"\n    r = request_dict\n    return AWSRequest(method=r['method'], url=r['url'],\n                      data=r['body'],\n                      headers=r['headers'])\n\n\ndef _urljoin(endpoint_url, url_path):\n    p = urlsplit(endpoint_url)\n    # <part>   - <index>\n    # scheme   - p[0]\n    # netloc   - p[1]\n    # path     - p[2]\n    # query    - p[3]\n    # fragment - p[4]\n    if not url_path or url_path == '/':\n        # If there's no path component, ensure the URL ends with\n        # a '/' for backwards compatibility.\n        if not p[2]:\n            return endpoint_url + '/'\n        return endpoint_url\n    if p[2].endswith('/') and url_path.startswith('/'):\n        new_path = p[2][:-1] + url_path\n    else:\n        new_path = p[2] + url_path\n    reconstructed = urlunsplit((p[0], p[1], new_path, p[3], p[4]))\n    return reconstructed\n\n\nclass AWSRequest(models.RequestEncodingMixin, models.Request):\n    def __init__(self, *args, **kwargs):\n        self.auth_path = None\n        if 'auth_path' in kwargs:\n            self.auth_path = kwargs['auth_path']\n            del kwargs['auth_path']\n        models.Request.__init__(self, *args, **kwargs)\n        headers = HTTPHeaders()\n        if self.headers is not None:\n            for key, value in self.headers.items():\n                headers[key] = value\n        self.headers = headers\n        # This is a dictionary to hold information that is used when\n        # processing the request. What is inside of ``context`` is open-ended.\n        # For example, it may have a timestamp key that is used for holding\n        # what the timestamp is when signing the request. Note that none",
  "start_line": 294,
  "end_line": 350,
  "total_lines": 448,
  "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": "263:def prepare_request_dict(request_dict, endpoint_url, user_agent=None):\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",
  "filepath": "botocore/awsrequest.py",
  "content": "def prepare_request_dict(request_dict, endpoint_url, user_agent=None):\n    \"\"\"\n    This method prepares a request dict to be created into an\n    AWSRequestObject. This prepares the request dict by adding the\n    url and the user agent to the request dict.\n\n    :type request_dict: dict\n    :param request_dict:  The request dict (created from the\n        ``serialize`` module).\n\n    :type user_agent: string\n    :param user_agent: The user agent to use for this request.\n\n    :type endpoint_url: string\n    :param endpoint_url: The full endpoint url, which contains at least\n        the scheme, the hostname, and optionally any path components.\n    \"\"\"\n    r = request_dict\n    if user_agent is not None:\n        headers = r['headers']\n        headers['User-Agent'] = user_agent\n    url = _urljoin(endpoint_url, r['url_path'])\n    if r['query_string']:\n        encoded_query_string = percent_encode_sequence(r['query_string'])\n        if '?' not in url:\n            url += '?%s' % encoded_query_string\n        else:\n            url += '&%s' % encoded_query_string\n    r['url'] = url\n\n\ndef create_request_object(request_dict):\n    \"\"\"\n    This method takes a request dict and creates an AWSRequest object\n    from it.\n\n    :type request_dict: dict\n    :param request_dict:  The request dict (created from the",
  "start_line": 263,
  "end_line": 300,
  "total_lines": 448,
  "is_truncated": false,
  "budget_warning": "Only 8 tool call(s) remaining (22/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "grep: botocore/endpoint_resolver.py: No such file or directory\n",
  "details": {
    "stdout": "",
    "stderr": "grep: botocore/endpoint_resolver.py: No such file or directory\n",
    "exit_code": 2
  },
  "budget_warning": "Only 7 tool call(s) remaining (23/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "./botocore/regions.py:88:class EndpointResolver(BaseEndpointResolver):\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 6 tool call(s) remaining (24/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "filepath": "botocore/regions.py",
  "content": "class EndpointResolver(BaseEndpointResolver):\n    \"\"\"Resolves endpoints based on partition endpoint metadata\"\"\"\n    def __init__(self, endpoint_data):\n        \"\"\"\n        :param endpoint_data: A dict of partition data.\n        \"\"\"\n        if 'partitions' not in endpoint_data:\n            raise ValueError('Missing \"partitions\" in endpoint data')\n        self._endpoint_data = endpoint_data\n\n    def get_available_partitions(self):\n        result = []\n        for partition in self._endpoint_data['partitions']:\n            result.append(partition['partition'])\n        return result\n\n    def get_available_endpoints(self, service_name, partition_name='aws',\n                                allow_non_regional=False):\n        result = []\n        for partition in self._endpoint_data['partitions']:\n            if partition['partition'] != partition_name:\n                continue\n            services = partition['services']\n            if service_name not in services:\n                continue\n            for endpoint_name in services[service_name]['endpoints']:\n                if allow_non_regional or endpoint_name in partition['regions']:\n                    result.append(endpoint_name)\n        return result\n\n    def construct_endpoint(self, service_name, region_name=None):\n        # Iterate over each partition until a match is found.\n        for partition in self._endpoint_data['partitions']:\n            result = self._endpoint_for_partition(\n                partition, service_name, region_name)\n            if result:\n                return result\n\n    def _endpoint_for_partition(self, partition, service_name, region_name):\n        # Get the service from the partition, or an empty template.\n        service_data = partition['services'].get(\n            service_name, DEFAULT_SERVICE_DATA)\n        # Use the partition endpoint if no region is supplied.\n        if region_name is None:\n            if 'partitionEndpoint' in service_data:\n                region_name = service_data['partitionEndpoint']\n            else:\n                raise NoRegionError()\n        # Attempt to resolve the exact region for this partition.\n        if region_name in service_data['endpoints']:\n            return self._resolve(\n                partition, service_name, service_data, region_name)\n        # Check to see if the endpoint provided is valid for the partition.\n        if self._region_match(partition, region_name):\n            # Use the partition endpoint if set and not regionalized.\n            partition_endpoint = service_data.get('partitionEndpoint')\n            is_regionalized = service_data.get('isRegionalized', True)\n            if partition_endpoint and not is_regionalized:\n                LOG.debug('Using partition endpoint for %s, %s: %s',\n                          service_name, region_name, partition_endpoint)\n                return self._resolve(\n                    partition, service_name, service_data, partition_endpoint)\n            LOG.debug('Creating a regex based endpoint for %s, %s',\n                      service_name, region_name)\n            return self._resolve(\n                partition, service_name, service_data, region_name)\n\n    def _region_match(self, partition, region_name):\n        if region_name in partition['regions']:\n            return True\n        if 'regionRegex' in partition:\n            return re.compile(partition['regionRegex']).match(region_name)\n        return False\n\n    def _resolve(self, partition, service_name, service_data, endpoint_name):\n        result = service_data['endpoints'].get(endpoint_name, {})\n        result['partition'] = partition['partition']\n        result['endpointName'] = endpoint_name\n        # Merge in the service defaults then the partition defaults.\n        self._merge_keys(service_data.get('defaults', {}), result)\n        self._merge_keys(partition.get('defaults', {}), result)\n        hostname = result.get('hostname', DEFAULT_URI_TEMPLATE)\n        result['hostname'] = self._expand_template(\n            partition, result['hostname'], service_name, endpoint_name)\n        if 'sslCommonName' in result:\n            result['sslCommonName'] = self._expand_template(\n                partition, result['sslCommonName'], service_name,\n                endpoint_name)\n        return result\n\n    def _merge_keys(self, from_data, result):\n        for key in from_data:\n            if key not in result:\n                result[key] = from_data[key]\n\n    def _expand_template(self, partition, template, service_name,\n                         endpoint_name):\n        return template.format(\n            service=service_name, region=endpoint_name,\n            dnsSuffix=partition['dnsSuffix'])",
  "start_line": 88,
  "end_line": 187,
  "total_lines": 187,
  "is_truncated": false,
  "budget_warning": "Only 5 tool call(s) remaining (25/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "287:    def _create_endpoint(self, resolved, service_name, region_name,\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 4 tool call(s) remaining (26/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "    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)",
  "start_line": 287,
  "end_line": 310,
  "total_lines": 679,
  "is_truncated": false,
  "budget_warning": "Only 3 tool call(s) remaining (27/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "335:    def _make_url(self, hostname, is_secure):\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 2 tool call(s) remaining (28/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "    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:\n            return self.service_signing_name\n        # Just assume is the same as the service name.\n        return service_name\n\n    def _pick_region_values(self, resolved, region_name, endpoint_url):",
  "start_line": 335,
  "end_line": 350,
  "total_lines": 679,
  "is_truncated": false,
  "budget_warning": "Only 1 tool call(s) remaining (29/30 used). Finalize your edits and call submit_patch soon."
}