boto__botocore-830

{
  "status": "ok",
  "stdout": "botocore/session.py:695:                      use_ssl=True, verify=None, endpoint_url=None,\nbotocore/session.py:731:        :type endpoint_url: string\nbotocore/session.py:732:        :param endpoint_url: The complete URL to use for the constructed\nbotocore/session.py:807:            is_secure=use_ssl, endpoint_url=endpoint_url, verify=verify,\nbotocore/endpoint.py:30:from botocore.utils import is_valid_endpoint_url\nbotocore/endpoint.py:183:                endpoint_url = e.request.url\nbotocore/endpoint.py:185:                    endpoint_url=endpoint_url, error=e)\nbotocore/endpoint.py:189:                    endpoint_url=e.request.url, request=e.request)\nbotocore/endpoint.py:236:    def create_endpoint(self, service_model, region_name, endpoint_url,\nbotocore/endpoint.py:239:        if not is_valid_endpoint_url(endpoint_url):\nbotocore/endpoint.py:240:            raise ValueError(\"Invalid endpoint: %s\" % endpoint_url)\nbotocore/endpoint.py:242:            endpoint_url,\nbotocore/endpoint.py:245:            proxies=self._get_proxies(endpoint_url),\nbotocore/utils.py:596:def is_valid_endpoint_url(endpoint_url):\nbotocore/utils.py:597:    \"\"\"Verify the endpoint_url is valid.\nbotocore/utils.py:599:    :type endpoint_url: string\nbotocore/utils.py:600:    :param endpoint_url: An endpoint_url.  Must have at least a scheme\nbotocore/utils.py:603:    :return: True if the endpoint url is valid. False otherwise.\nbotocore/utils.py:606:    parts = urlsplit(endpoint_url)\nbotocore/utils.py:671:                                 default_endpoint_url=None, **kwargs):\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",
  "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": "            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": 180,
  "end_line": 300,
  "total_lines": 679,
  "is_truncated": false
}

{
  "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.",
  "start_line": 330,
  "end_line": 340,
  "total_lines": 679,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "160:        self._register_endpoint_resolver()\n177:    def _register_endpoint_resolver(self):\n183:            'endpoint_resolver', create_default_resolver)\n801:        endpoint_resolver = self.get_component('endpoint_resolver')\n803:            loader, endpoint_resolver, self.user_agent(), event_emitter,\n818:        resolver = self.get_component('endpoint_resolver')\n841:        resolver = self.get_component('endpoint_resolver')\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "botocore/session.py",
  "content": "            if config and config.region_name is not None:\n                region_name = config.region_name\n            else:\n                region_name = self.get_config_variable('region')\n\n        # Figure out the verify value base on the various\n        # configuration options.\n        if verify is None:\n            verify = self.get_config_variable('ca_bundle')\n\n        loader = self.get_component('data_loader')\n        event_emitter = self.get_component('event_emitter')\n        response_parser_factory = self.get_component(\n            'response_parser_factory')\n        if aws_secret_access_key is not None:\n            credentials = botocore.credentials.Credentials(\n                access_key=aws_access_key_id,\n                secret_key=aws_secret_access_key,\n                token=aws_session_token)\n        else:\n            credentials = self.get_credentials()\n        endpoint_resolver = self.get_component('endpoint_resolver')\n        client_creator = botocore.client.ClientCreator(\n            loader, endpoint_resolver, self.user_agent(), event_emitter,\n            retryhandler, translate, response_parser_factory)\n        client = client_creator.create_client(\n            service_name=service_name, region_name=region_name,\n            is_secure=use_ssl, endpoint_url=endpoint_url, verify=verify,\n            credentials=credentials, scoped_config=self.get_scoped_config(),\n            client_config=config, api_version=api_version)\n        return client\n\n    def get_available_partitions(self):\n        \"\"\"Lists the available partitions found on disk\n\n        :rtype: list\n        :return: Returns a list of partition names (e.g., [\"aws\", \"aws-cn\"])\n        \"\"\"\n        resolver = self.get_component('endpoint_resolver')\n        return resolver.get_available_partitions()\n\n    def get_available_regions(self, service_name, partition_name='aws',\n                              allow_non_regional=False):\n        \"\"\"Lists the region and endpoint names of a particular partition.\n\n        :type service_name: string\n        :param service_name: Name of a service to list endpoint for (e.g., s3).\n            This parameter accepts a service name (e.g., \"elb\") or endpoint\n            prefix (e.g., \"elasticloadbalancing\").\n\n        :type partition_name: string\n        :param partition_name: Name of the partition to limit endpoints to.\n            (e.g., aws for the public AWS endpoints, aws-cn for AWS China\n            endpoints, aws-us-gov for AWS GovCloud (US) Endpoints, etc.\n\n        :type allow_non_regional: bool\n        :param allow_non_regional: Set to True to include endpoints that are\n             not regional endpoints (e.g., s3-external-1,\n             fips-us-gov-west-1, etc).\n        :return: Returns a list of endpoint names (e.g., [\"us-east-1\"]).\n        \"\"\"\n        resolver = self.get_component('endpoint_resolver')\n        results = []\n        try:\n            service_data = self.get_service_data(service_name)\n            endpoint_prefix = service_data['metadata'].get(\n                'endpointPrefix', service_name)\n            results = resolver.get_available_endpoints(\n                endpoint_prefix, partition_name, allow_non_regional)\n        except UnknownServiceError:\n            pass",
  "start_line": 780,
  "end_line": 850,
  "total_lines": 892,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "botocore/session.py",
  "content": "        :type service_name: string\n        :param service_name: The name of the service for which a client will\n            be created.  You can use the ``Sesssion.get_available_services()``\n            method to get a list of all available service names.\n\n        :type region_name: string\n        :param region_name: The name of the region associated with the client.\n            A client is associated with a single region.\n\n        :type api_version: string\n        :param api_version: The API version to use.  By default, botocore will\n            use the latest API version when creating a client.  You only need\n            to specify this parameter if you want to use a previous API version\n            of the client.\n\n        :type use_ssl: boolean\n        :param use_ssl: Whether or not to use SSL.  By default, SSL is used.\n            Note that not all services support non-ssl connections.\n\n        :type verify: boolean/string\n        :param verify: Whether or not to verify SSL certificates.\n            By default SSL certificates are verified.  You can provide the\n            following values:\n\n            * False - do not validate SSL certificates.  SSL will still be\n              used (unless use_ssl is False), but SSL certificates\n              will not be verified.\n            * path/to/cert/bundle.pem - A filename of the CA cert bundle to\n              uses.  You can specify this argument if you want to use a\n              different CA cert bundle than the one used by botocore.\n\n        :type endpoint_url: string\n        :param endpoint_url: The complete URL to use for the constructed\n            client.  Normally, botocore will automatically construct the\n            appropriate URL to use when communicating with a service.  You can\n            specify a complete URL (including the \"http/https\" scheme) to\n            override this behavior.  If this value is provided, then\n            ``use_ssl`` is ignored.\n\n        :type aws_access_key_id: string\n        :param aws_access_key_id: The access key to use when creating\n            the client.  This is entirely optional, and if not provided,\n            the credentials configured for the session will automatically\n            be used.  You only need to provide this argument if you want\n            to override the credentials used for this specific client.\n\n        :type aws_secret_access_key: string\n        :param aws_secret_access_key: The secret key to use when creating\n            the client.  Same semantics as aws_access_key_id above.\n\n        :type aws_session_token: string\n        :param aws_session_token: The session token to use when creating\n            the client.  Same semantics as aws_access_key_id above.\n\n        :type config: botocore.client.Config\n        :param config: Advanced client configuration options. If a value\n            is specified in the client config, its value will take precedence\n            over environment variables and configuration values, but not over\n            a value passed explicitly to the method. If a default config\n            object is set on the session, the config object used when creating\n            the client will be the result of calling ``merge()`` on the\n            default config with the config provided to this call.\n\n        :rtype: botocore.client.BaseClient\n        :return: A botocore client instance\n\n        \"\"\"\n        default_client_config = self.get_default_client_config()\n        # If a config is provided and a default config is set, then\n        # use the config resulting from merging the two.\n        if config is not None and default_client_config is not None:\n            config = default_client_config.merge(config)\n        # If a config was not provided then use the default\n        # client config from the session\n        elif default_client_config is not None:\n            config = default_client_config\n\n        # Figure out the user-provided region based on the various\n        # configuration options.\n        if region_name is None:\n            if config and config.region_name is not None:\n                region_name = config.region_name\n            else:\n                region_name = self.get_config_variable('region')\n\n        # Figure out the verify value base on the various\n        # configuration options.\n        if verify is None:\n            verify = self.get_config_variable('ca_bundle')\n\n        loader = self.get_component('data_loader')\n        event_emitter = self.get_component('event_emitter')\n        response_parser_factory = self.get_component(\n            'response_parser_factory')\n        if aws_secret_access_key is not None:\n            credentials = botocore.credentials.Credentials(\n                access_key=aws_access_key_id,\n                secret_key=aws_secret_access_key,\n                token=aws_session_token)\n        else:\n            credentials = self.get_credentials()",
  "start_line": 700,
  "end_line": 800,
  "total_lines": 892,
  "is_truncated": false
}

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

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "class 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)\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",
  "start_line": 40,
  "end_line": 189,
  "total_lines": 679,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "        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,\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": 190,
  "end_line": 310,
  "total_lines": 679,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "botocore/client.py",
  "content": "        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):",
  "start_line": 311,
  "end_line": 350,
  "total_lines": 679,
  "is_truncated": false
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 2, in <module>\nImportError: cannot import name 'EndpointResolver' from 'botocore.endpoint' (/workspace/botocore/endpoint.py)\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 2, in <module>\nImportError: cannot import name 'EndpointResolver' from 'botocore.endpoint' (/workspace/botocore/endpoint.py)\n",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "stdout": "Resolved: OrderedDict([('hostname', 'localhost:8000'), ('protocols', ['http']), ('credentialScope', OrderedDict([('region', 'us-east-1')])), ('partition', 'aws'), ('endpointName', 'local'), ('signatureVersions', ['v4'])])\n",
  "stderr": "",
  "exit_code": 0
}