boto__botocore-830

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

{
  "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": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "stdout": "1:# Copyright (c) 2012-2013 Mitch Garnaat http://garnaat.org/\n8:# http://aws.amazon.com/apache2.0/\n47:def convert_to_response_dict(http_response, operation_model):\n53:    :type http_response: botocore.vendored.requests.model.Response\n54:    :param http_response: The HTTP response from an AWS service request.\n64:        'headers': http_response.headers,\n65:        'status_code': http_response.status_code,\n68:        response_dict['body'] = http_response.content\n71:            http_response.raw, response_dict['headers'].get('content-length'))\n73:        response_dict['body'] = http_response.content\n103:        self.http_session = PreserveAuthSession()\n166:        # (http_response, parsed_dict).\n170:            logger.debug(\"Sending http request: %s\", request)\n171:            http_response = self.http_session.send(\n197:        # This returns the http_response and the parsed_data.\n198:        response_dict = convert_to_response_dict(http_response,\n202:        return ((http_response,\n257:        # https://github.com/kennethreitz/requests/issues/1436\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "filepath": "botocore/session.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\"\"\"\nThis module contains the main interface to the botocore package, the\nSession object.\n\"\"\"\n\nimport copy\nimport logging\nimport os\nimport platform\n\nfrom botocore import __version__\nimport botocore.configloader\nimport botocore.credentials\nimport botocore.client\nfrom botocore.exceptions import ConfigNotFound, ProfileNotFound\nfrom botocore.exceptions import UnknownServiceError\nfrom botocore import handlers\nfrom botocore.hooks import HierarchicalEmitter, first_non_none_response\nfrom botocore.loaders import create_loader\nfrom botocore.parsers import ResponseParserFactory\nfrom botocore.regions import EndpointResolver\nfrom botocore.model import ServiceModel\nfrom botocore import paginate\nfrom botocore import waiter\nfrom botocore import retryhandler, translate\n\n\nclass Session(object):\n    \"\"\"\n    The Session object collects together useful functionality\n    from `botocore` as well as important data such as configuration\n    information and credentials into a single, easy-to-use object.\n\n    :ivar available_profiles: A list of profiles defined in the config\n        file associated with this session.\n    :ivar profile: The current profile.\n    \"\"\"\n\n    #: A default dictionary that maps the logical names for session variables\n    #: to the specific environment variables and configuration file names\n    #: that contain the values for these variables.\n    #: When creating a new Session object, you can pass in your own dictionary\n    #: to remap the logical names or to add new logical names.  You can then\n    #: get the current value for these variables by using the\n    #: ``get_config_variable`` method of the :class:`botocore.session.Session`\n    #: class.\n    #: These form the keys of the dictionary.  The values in the dictionary\n    #: are tuples of (<config_name>, <environment variable>, <default value>,\n    #: <conversion func>).\n    #: The conversion func is a function that takes the configuration value\n    #: as an argument and returns the converted value.  If this value is\n    #: None, then the configuration value is returned unmodified.  This\n    #: conversion function can be used to type convert config values to\n    #: values other than the default values of strings.\n    #: The ``profile`` and ``config_file`` variables should always have a\n    #: None value for the first entry in the tuple because it doesn't make\n    #: sense to look inside the config file for the location of the config\n    #: file or for the default profile to use.\n    #: The ``config_name`` is the name to look for in the configuration file,\n    #: the ``env var`` is the OS environment variable (``os.environ``) to\n    #: use, and ``default_value`` is the value to use if no value is otherwise\n    #: found.\n    SESSION_VARIABLES = {\n        # logical:  config_file, env_var,        default_value, conversion_func\n        'profile': (None, ['AWS_DEFAULT_PROFILE', 'AWS_PROFILE'], None, None),\n        'region': ('region', 'AWS_DEFAULT_REGION', None, None),\n        'data_path': ('data_path', 'AWS_DATA_PATH', None, None),\n        'config_file': (None, 'AWS_CONFIG_FILE', '~/.aws/config', None),\n        'ca_bundle': ('ca_bundle', 'AWS_CA_BUNDLE', None, None),\n\n        # This is the shared credentials file amongst sdks.\n        'credentials_file': (None, 'AWS_SHARED_CREDENTIALS_FILE',\n                             '~/.aws/credentials', None),\n\n        # These variables only exist in the config file.\n\n        # This is the number of seconds until we time out a request to\n        # the instance metadata service.\n        'metadata_service_timeout': ('metadata_service_timeout',\n                                     'AWS_METADATA_SERVICE_TIMEOUT', 1, int),\n        # This is the number of request attempts we make until we give\n        # up trying to retrieve data from the instance metadata service.\n        'metadata_service_num_attempts': ('metadata_service_num_attempts',\n                                          'AWS_METADATA_SERVICE_NUM_ATTEMPTS', 1, int),\n    }\n\n    #: The default format string to use when configuring the botocore logger.\n    LOG_FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'\n\n    def __init__(self, session_vars=None, event_hooks=None,\n                 include_builtin_handlers=True, profile=None):\n        \"\"\"\n        Create a new Session object.\n\n        :type session_vars: dict\n        :param session_vars: A dictionary that is used to override some or all\n            of the environment variables associated with this session.  The\n            key/value pairs defined in this dictionary will override the\n            corresponding variables defined in ``SESSION_VARIABLES``.\n\n        :type event_hooks: BaseEventHooks\n        :param event_hooks: The event hooks object to use. If one is not\n            provided, an event hooks object will be automatically created\n            for you.\n\n        :type include_builtin_handlers: bool\n        :param include_builtin_handlers: Indicates whether or not to\n            automatically register builtin handlers.\n\n        :type profile: str\n        :param profile: The name of the profile to use for this\n            session.  Note that the profile can only be set when\n            the session is created.\n\n        \"\"\"\n        self.session_var_map = copy.copy(self.SESSION_VARIABLES)\n        if session_vars:\n            self.session_var_map.update(session_vars)\n        if event_hooks is None:\n            self._events = HierarchicalEmitter()\n        else:\n            self._events = event_hooks\n        if include_builtin_handlers:\n            self._register_builtin_handlers(self._events)\n        self.user_agent_name = 'Botocore'\n        self.user_agent_version = __version__\n        self.user_agent_extra = ''\n        # The _profile attribute is just used to cache the value\n        # of the current profile to avoid going through the normal\n        # config lookup process each access time.\n        self._profile = None\n        self._config = None\n        self._credentials = None\n        self._profile_map = None\n        # This is a dict that stores per session specific config variable\n        # overrides via set_config_variable().\n        self._session_instance_vars = {}",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 892,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "botocore/session.py",
  "content": "        if profile is not None:\n            self._session_instance_vars['profile'] = profile\n        self._client_config = None\n        self._components = ComponentLocator()\n        self._register_components()\n\n    def _register_components(self):\n        self._register_credential_provider()\n        self._register_data_loader()\n        self._register_endpoint_resolver()\n        self._register_event_emitter()\n        self._register_response_parser_factory()\n\n    def _register_event_emitter(self):\n        self._components.register_component('event_emitter', self._events)\n\n    def _register_credential_provider(self):\n        self._components.lazy_register_component(\n            'credential_provider',\n            lambda:  botocore.credentials.create_credential_resolver(self))\n\n    def _register_data_loader(self):\n        self._components.lazy_register_component(\n            'data_loader',\n            lambda:  create_loader(self.get_config_variable('data_path')))\n\n    def _register_endpoint_resolver(self):\n        def create_default_resolver():\n            loader = self.get_component('data_loader')\n            endpoints = loader.load_data('endpoints')\n            return EndpointResolver(endpoints)\n        self._components.lazy_register_component(\n            'endpoint_resolver', create_default_resolver)\n\n    def _register_response_parser_factory(self):\n        self._components.register_component('response_parser_factory',\n                                            ResponseParserFactory())\n\n    def _register_builtin_handlers(self, events):\n        for spec in handlers.BUILTIN_HANDLERS:\n            if len(spec) == 2:\n                event_name, handler = spec\n                self.register(event_name, handler)\n            else:\n                event_name, handler, register_type = spec\n                if register_type is handlers.REGISTER_FIRST:\n                    self._events.register_first(event_name, handler)\n                elif register_type is handlers.REGISTER_LAST:\n                    self._events.register_last(event_name, handler)\n\n    @property\n    def available_profiles(self):\n        return list(self._build_profile_map().keys())\n\n    def _build_profile_map(self):\n        # This will build the profile map if it has not been created,\n        # otherwise it will return the cached value.  The profile map\n        # is a list of profile names, to the config values for the profile.\n        if self._profile_map is None:\n            self._profile_map = self.full_config['profiles']\n        return self._profile_map\n\n    @property\n    def profile(self):\n        if self._profile is None:\n            profile = self.get_config_variable('profile')\n            self._profile = profile\n        return self._profile\n\n    def get_config_variable(self, logical_name,\n                            methods=('instance', 'env', 'config')):\n        \"\"\"\n        Retrieve the value associated with the specified logical_name\n        from the environment or the config file.  Values found in the\n        environment variable take precedence of values found in the\n        config file.  If no value can be found, a None will be returned.\n\n        :type logical_name: str\n        :param logical_name: The logical name of the session variable\n            you want to retrieve.  This name will be mapped to the\n            appropriate environment variable name for this session as\n            well as the appropriate config file entry.\n\n        :type method: tuple\n        :param method: Defines which methods will be used to find\n            the variable value.  By default, all available methods\n            are tried but you can limit which methods are used\n            by supplying a different value to this parameter.\n            Valid choices are: instance|env|config\n\n        :returns: value of variable or None if not defined.\n\n        \"\"\"\n        # Handle all the short circuit special cases first.\n        if logical_name not in self.session_var_map:\n            return\n        # Do the actual lookups.  We need to handle\n        # 'instance', 'env', and 'config' locations, in that order.\n        value = None\n        var_config = self.session_var_map[logical_name]\n        if self._found_in_instance_vars(methods, logical_name):\n            return self._session_instance_vars[logical_name]\n        elif self._found_in_env(methods, var_config):\n            value = self._retrieve_from_env(var_config[1], os.environ)\n        elif self._found_in_config_file(methods, var_config):\n            value = self.get_scoped_config()[var_config[0]]\n        if value is None:\n            value = var_config[2]\n        if var_config[3] is not None:\n            value = var_config[3](value)\n        return value\n\n    def _found_in_instance_vars(self, methods, logical_name):\n        if 'instance' in methods:\n            return logical_name in self._session_instance_vars\n        return False\n\n    def _found_in_env(self, methods, var_config):\n        return (\n            'env' in methods and\n            var_config[1] is not None and\n            self._retrieve_from_env(var_config[1], os.environ) is not None)\n\n    def _found_in_config_file(self, methods, var_config):\n        if 'config' in methods and var_config[0] is not None:\n            return var_config[0] in self.get_scoped_config()\n        return False\n\n    def _retrieve_from_env(self, names, environ):\n        # We need to handle the case where names is either\n        # a single value or a list of variables.\n        if not isinstance(names, list):\n            names = [names]\n        for name in names:\n            if name in environ:\n                return environ[name]\n        return None\n\n    def set_config_variable(self, logical_name, value):\n        \"\"\"Set a configuration variable to a specific value.\n\n        By using this method, you can override the normal lookup\n        process used in ``get_config_variable`` by explicitly setting\n        a value.  Subsequent calls to ``get_config_variable`` will\n        use the ``value``.  This gives you per-session specific\n        configuration values.\n\n        ::\n            >>> # Assume logical name 'foo' maps to env var 'FOO'\n            >>> os.environ['FOO'] = 'myvalue'",
  "start_line": 151,
  "end_line": 300,
  "total_lines": 892,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "694:    def create_client(self, service_name, region_name=None, api_version=None,\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "botocore/session.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\"\"\"\nThis module contains the main interface to the botocore package, the\nSession object.\n\"\"\"\n\nimport copy\nimport logging\nimport os\nimport platform\n\nfrom botocore import __version__\nimport botocore.configloader\nimport botocore.credentials\nimport botocore.client\nfrom botocore.exceptions import ConfigNotFound, ProfileNotFound\nfrom botocore.exceptions import UnknownServiceError\nfrom botocore import handlers\nfrom botocore.hooks import HierarchicalEmitter, first_non_none_response\nfrom botocore.loaders import create_loader\nfrom botocore.parsers import ResponseParserFactory\nfrom botocore.regions import EndpointResolver\nfrom botocore.model import ServiceModel\nfrom botocore import paginate\nfrom botocore import waiter\nfrom botocore import retryhandler, translate\n\n\nclass Session(object):\n    \"\"\"\n    The Session object collects together useful functionality\n    from `botocore` as well as important data such as configuration\n    information and credentials into a single, easy-to-use object.\n\n    :ivar available_profiles: A list of profiles defined in the config\n        file associated with this session.\n    :ivar profile: The current profile.\n    \"\"\"\n\n    #: A default dictionary that maps the logical names for session variables\n    #: to the specific environment variables and configuration file names\n    #: that contain the values for these variables.\n    #: When creating a new Session object, you can pass in your own dictionary\n    #: to remap the logical names or to add new logical names.  You can then\n    #: get the current value for these variables by using the\n    #: ``get_config_variable`` method of the :class:`botocore.session.Session`\n    #: class.\n    #: These form the keys of the dictionary.  The values in the dictionary\n    #: are tuples of (<config_name>, <environment variable>, <default value>,\n    #: <conversion func>).\n    #: The conversion func is a function that takes the configuration value\n    #: as an argument and returns the converted value.  If this value is\n    #: None, then the configuration value is returned unmodified.  This\n    #: conversion function can be used to type convert config values to\n    #: values other than the default values of strings.\n    #: The ``profile`` and ``config_file`` variables should always have a\n    #: None value for the first entry in the tuple because it doesn't make\n    #: sense to look inside the config file for the location of the config\n    #: file or for the default profile to use.\n    #: The ``config_name`` is the name to look for in the configuration file,\n    #: the ``env var`` is the OS environment variable (``os.environ``) to\n    #: use, and ``default_value`` is the value to use if no value is otherwise\n    #: found.\n    SESSION_VARIABLES = {\n        # logical:  config_file, env_var,        default_value, conversion_func\n        'profile': (None, ['AWS_DEFAULT_PROFILE', 'AWS_PROFILE'], None, None),\n        'region': ('region', 'AWS_DEFAULT_REGION', None, None),\n        'data_path': ('data_path', 'AWS_DATA_PATH', None, None),\n        'config_file': (None, 'AWS_CONFIG_FILE', '~/.aws/config', None),\n        'ca_bundle': ('ca_bundle', 'AWS_CA_BUNDLE', None, None),\n\n        # This is the shared credentials file amongst sdks.\n        'credentials_file': (None, 'AWS_SHARED_CREDENTIALS_FILE',\n                             '~/.aws/credentials', None),\n\n        # These variables only exist in the config file.\n\n        # This is the number of seconds until we time out a request to\n        # the instance metadata service.\n        'metadata_service_timeout': ('metadata_service_timeout',\n                                     'AWS_METADATA_SERVICE_TIMEOUT', 1, int),\n        # This is the number of request attempts we make until we give\n        # up trying to retrieve data from the instance metadata service.\n        'metadata_service_num_attempts': ('metadata_service_num_attempts',\n                                          'AWS_METADATA_SERVICE_NUM_ATTEMPTS', 1, int),\n    }\n\n    #: The default format string to use when configuring the botocore logger.\n    LOG_FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'\n\n    def __init__(self, session_vars=None, event_hooks=None,\n                 include_builtin_handlers=True, profile=None):\n        \"\"\"\n        Create a new Session object.\n\n        :type session_vars: dict\n        :param session_vars: A dictionary that is used to override some or all\n            of the environment variables associated with this session.  The\n            key/value pairs defined in this dictionary will override the\n            corresponding variables defined in ``SESSION_VARIABLES``.\n\n        :type event_hooks: BaseEventHooks\n        :param event_hooks: The event hooks object to use. If one is not\n            provided, an event hooks object will be automatically created\n            for you.\n\n        :type include_builtin_handlers: bool\n        :param include_builtin_handlers: Indicates whether or not to\n            automatically register builtin handlers.\n\n        :type profile: str\n        :param profile: The name of the profile to use for this\n            session.  Note that the profile can only be set when\n            the session is created.\n\n        \"\"\"\n        self.session_var_map = copy.copy(self.SESSION_VARIABLES)\n        if session_vars:\n            self.session_var_map.update(session_vars)\n        if event_hooks is None:\n            self._events = HierarchicalEmitter()\n        else:\n            self._events = event_hooks\n        if include_builtin_handlers:\n            self._register_builtin_handlers(self._events)\n        self.user_agent_name = 'Botocore'\n        self.user_agent_version = __version__\n        self.user_agent_extra = ''\n        # The _profile attribute is just used to cache the value\n        # of the current profile to avoid going through the normal\n        # config lookup process each access time.\n        self._profile = None\n        self._config = None\n        self._credentials = None\n        self._profile_map = None\n        # This is a dict that stores per session specific config variable\n        # overrides via set_config_variable().\n        self._session_instance_vars = {}",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 892,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "botocore/session.py",
  "content": "    def create_client(self, service_name, region_name=None, api_version=None,\n                      use_ssl=True, verify=None, endpoint_url=None,\n                      aws_access_key_id=None, aws_secret_access_key=None,\n                      aws_session_token=None, config=None):\n        \"\"\"Create a botocore client.\n\n        :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": 694,
  "end_line": 800,
  "total_lines": 892,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "botocore/session.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\"\"\"\nThis module contains the main interface to the botocore package, the\nSession object.\n\"\"\"\n\nimport copy\nimport logging\nimport os\nimport platform\n\nfrom botocore import __version__\nimport botocore.configloader\nimport botocore.credentials\nimport botocore.client\nfrom botocore.exceptions import ConfigNotFound, ProfileNotFound\nfrom botocore.exceptions import UnknownServiceError\nfrom botocore import handlers\nfrom botocore.hooks import HierarchicalEmitter, first_non_none_response\nfrom botocore.loaders import create_loader\nfrom botocore.parsers import ResponseParserFactory\nfrom botocore.regions import EndpointResolver\nfrom botocore.model import ServiceModel\nfrom botocore import paginate\nfrom botocore import waiter\nfrom botocore import retryhandler, translate\n\n\nclass Session(object):\n    \"\"\"\n    The Session object collects together useful functionality\n    from `botocore` as well as important data such as configuration\n    information and credentials into a single, easy-to-use object.\n\n    :ivar available_profiles: A list of profiles defined in the config\n        file associated with this session.\n    :ivar profile: The current profile.\n    \"\"\"\n\n    #: A default dictionary that maps the logical names for session variables\n    #: to the specific environment variables and configuration file names\n    #: that contain the values for these variables.\n    #: When creating a new Session object, you can pass in your own dictionary\n    #: to remap the logical names or to add new logical names.  You can then\n    #: get the current value for these variables by using the\n    #: ``get_config_variable`` method of the :class:`botocore.session.Session`\n    #: class.\n    #: These form the keys of the dictionary.  The values in the dictionary\n    #: are tuples of (<config_name>, <environment variable>, <default value>,\n    #: <conversion func>).\n    #: The conversion func is a function that takes the configuration value\n    #: as an argument and returns the converted value.  If this value is\n    #: None, then the configuration value is returned unmodified.  This\n    #: conversion function can be used to type convert config values to\n    #: values other than the default values of strings.\n    #: The ``profile`` and ``config_file`` variables should always have a\n    #: None value for the first entry in the tuple because it doesn't make\n    #: sense to look inside the config file for the location of the config\n    #: file or for the default profile to use.\n    #: The ``config_name`` is the name to look for in the configuration file,\n    #: the ``env var`` is the OS environment variable (``os.environ``) to\n    #: use, and ``default_value`` is the value to use if no value is otherwise\n    #: found.\n    SESSION_VARIABLES = {\n        # logical:  config_file, env_var,        default_value, conversion_func\n        'profile': (None, ['AWS_DEFAULT_PROFILE', 'AWS_PROFILE'], None, None),\n        'region': ('region', 'AWS_DEFAULT_REGION', None, None),\n        'data_path': ('data_path', 'AWS_DATA_PATH', None, None),\n        'config_file': (None, 'AWS_CONFIG_FILE', '~/.aws/config', None),\n        'ca_bundle': ('ca_bundle', 'AWS_CA_BUNDLE', None, None),\n\n        # This is the shared credentials file amongst sdks.\n        'credentials_file': (None, 'AWS_SHARED_CREDENTIALS_FILE',\n                             '~/.aws/credentials', None),\n\n        # These variables only exist in the config file.\n\n        # This is the number of seconds until we time out a request to\n        # the instance metadata service.\n        'metadata_service_timeout': ('metadata_service_timeout',\n                                     'AWS_METADATA_SERVICE_TIMEOUT', 1, int),\n        # This is the number of request attempts we make until we give\n        # up trying to retrieve data from the instance metadata service.\n        'metadata_service_num_attempts': ('metadata_service_num_attempts',\n                                          'AWS_METADATA_SERVICE_NUM_ATTEMPTS', 1, int),\n    }\n\n    #: The default format string to use when configuring the botocore logger.\n    LOG_FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'\n\n    def __init__(self, session_vars=None, event_hooks=None,\n                 include_builtin_handlers=True, profile=None):\n        \"\"\"\n        Create a new Session object.\n\n        :type session_vars: dict\n        :param session_vars: A dictionary that is used to override some or all\n            of the environment variables associated with this session.  The\n            key/value pairs defined in this dictionary will override the\n            corresponding variables defined in ``SESSION_VARIABLES``.\n\n        :type event_hooks: BaseEventHooks\n        :param event_hooks: The event hooks object to use. If one is not\n            provided, an event hooks object will be automatically created\n            for you.\n\n        :type include_builtin_handlers: bool\n        :param include_builtin_handlers: Indicates whether or not to\n            automatically register builtin handlers.\n\n        :type profile: str\n        :param profile: The name of the profile to use for this\n            session.  Note that the profile can only be set when\n            the session is created.\n\n        \"\"\"\n        self.session_var_map = copy.copy(self.SESSION_VARIABLES)\n        if session_vars:\n            self.session_var_map.update(session_vars)\n        if event_hooks is None:\n            self._events = HierarchicalEmitter()\n        else:\n            self._events = event_hooks\n        if include_builtin_handlers:\n            self._register_builtin_handlers(self._events)\n        self.user_agent_name = 'Botocore'\n        self.user_agent_version = __version__\n        self.user_agent_extra = ''\n        # The _profile attribute is just used to cache the value\n        # of the current profile to avoid going through the normal\n        # config lookup process each access time.\n        self._profile = None\n        self._config = None\n        self._credentials = None\n        self._profile_map = None\n        # This is a dict that stores per session specific config variable\n        # overrides via set_config_variable().\n        self._session_instance_vars = {}",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 892,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "botocore/session.py",
  "content": "        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\n        return results\n\n\nclass ComponentLocator(object):\n    \"\"\"Service locator for session components.\"\"\"\n    def __init__(self):\n        self._components = {}\n        self._deferred = {}\n\n    def get_component(self, name):\n        if name in self._deferred:\n            factory = self._deferred[name]\n            self._components[name] = factory()\n            # Only delete the component from the deferred dict after\n            # successfully creating the object from the factory as well as\n            # injecting the instantiated value into the _components dict.\n            del self._deferred[name]\n        try:\n            return self._components[name]\n        except KeyError:\n            raise ValueError(\"Unknown component: %s\" % name)\n\n    def register_component(self, name, component):\n        self._components[name] = component\n        try:\n            del self._deferred[name]\n        except KeyError:\n            pass\n\n    def lazy_register_component(self, name, no_arg_factory):\n        self._deferred[name] = no_arg_factory\n        try:\n            del self._components[name]\n        except KeyError:\n            pass\n\n\ndef get_session(env_vars=None):\n    \"\"\"\n    Return a new session object.\n    \"\"\"\n    return Session(env_vars)",
  "start_line": 801,
  "end_line": 892,
  "total_lines": 892,
  "is_truncated": false
}

{
  "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/client.py",
  "content": "            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'\n            if 'v4' in potential_versions:\n                return 'v4'\n            # Now just iterate over the signature versions in order until we\n            # find the first one that is known to Botocore.\n            for known in AUTH_TYPE_MAPS:\n                if known in potential_versions:\n                    return known\n        raise UnknownSignatureVersionError(\n            signature_version=resolved.get('signatureVersions'))\n\n\nclass BaseClient(object):\n\n    # This is actually reassigned with the py->op_name mapping\n    # when the client creator creates the subclass.  This value is used\n    # because calls such as client.get_paginator('list_objects') use the\n    # snake_case name, but we need to know the ListObjects form.\n    # xform_name() does the ListObjects->list_objects conversion, but\n    # we need the reverse mapping here.\n    _PY_TO_OP_NAME = {}\n\n    def __init__(self, serializer, endpoint, response_parser,\n                 event_emitter, request_signer, service_model, loader,\n                 client_config):\n        self._serializer = serializer\n        self._endpoint = endpoint\n        self._response_parser = response_parser\n        self._request_signer = request_signer\n        self._cache = {}\n        self._loader = loader\n        self._client_config = client_config\n        self.meta = ClientMeta(event_emitter, self._client_config,\n                               endpoint.host, service_model,\n                               self._PY_TO_OP_NAME)\n        self._register_handlers()\n\n    def _register_handlers(self):\n        # Register the handler required to sign requests.\n        self.meta.events.register('request-created.%s' %\n                                  self.meta.service_model.endpoint_prefix,\n                                  self._request_signer.handler)\n\n        # If the virtual host addressing style is being forced,\n        # switch the default fix_s3_host handler for the more general\n        # switch_to_virtual_host_style handler that does not have opt out\n        # cases (other than throwing an error if the name is DNS incompatible)\n        if self.meta.config.s3 is None:\n            s3_addressing_style = None\n        else:\n            s3_addressing_style = self.meta.config.s3.get('addressing_style')\n\n        if s3_addressing_style == 'path':\n            self.meta.events.unregister('before-sign.s3', fix_s3_host)\n        elif s3_addressing_style == 'virtual':\n            self.meta.events.unregister('before-sign.s3', fix_s3_host)",
  "start_line": 301,
  "end_line": 450,
  "total_lines": 679,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "botocore/regions.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.\n\"\"\"Resolves regions and endpoints.\n\nThis module implements endpoint resolution, including resolving endpoints for a\ngiven service and region and resolving the available endpoints for a service\nin a specific AWS partition.\n\"\"\"\nimport logging\nimport re\n\nfrom botocore.exceptions import NoRegionError\n\nLOG = logging.getLogger(__name__)\nDEFAULT_URI_TEMPLATE = '{service}.{region}.{dnsSuffix}'\nDEFAULT_SERVICE_DATA = {'endpoints': {}}\n\n\nclass BaseEndpointResolver(object):\n    \"\"\"Resolves regions and endpoints. Must be subclassed.\"\"\"\n    def construct_endpoint(self, service_name, region_name=None):\n        \"\"\"Resolves an endpoint for a service and region combination.\n\n        :type service_name: string\n        :param service_name: Name of the service to resolve an endpoint for\n            (e.g., s3)\n\n        :type region_name: string\n        :param region_name: Region/endpoint name to resolve (e.g., us-east-1)\n            if no region is provided, the first found partition-wide endpoint\n            will be used if available.\n\n        :rtype: dict\n        :return: Returns a dict containing the following keys:\n            - partition: (string, required) Resolved partition name\n            - endpointName: (string, required) Resolved endpoint name\n            - hostname: (string, required) Hostname to use for this endpoint\n            - sslCommonName: (string) sslCommonName to use for this endpoint.\n            - credentialScope: (dict) Signature version 4 credential scope\n              - region: (string) region name override when signing.\n              - service: (string) service name override when signing.\n            - signatureVersions: (list<string>) A list of possible signature\n              versions, including s3, v4, v2, and s3v4\n            - protocols: (list<string>) A list of supported protocols\n              (e.g., http, https)\n            - ...: Other keys may be included as well based on the metadata\n        \"\"\"\n        raise NotImplementedError\n\n    def get_available_partitions(self):\n        \"\"\"Lists the partitions available to the endpoint resolver.\n\n        :return: Returns a list of partition names (e.g., [\"aws\", \"aws-cn\"]).\n        \"\"\"\n        raise NotImplementedError\n\n    def get_available_endpoints(self, service_name, partition_name='aws',\n                                allow_non_regional=False):\n        \"\"\"Lists the 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\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        raise NotImplementedError\n\n\nclass 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',",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 187,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "botocore/regions.py",
  "content": "                      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": 151,
  "end_line": 187,
  "total_lines": 187,
  "is_truncated": false
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 20, in <module>\nImportError: cannot import name 'endpoints' from 'botocore.data' (unknown location)\n",
  "details": {
    "stdout": "Error: _send_request() takes 5 positional arguments but 6 were given\n",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 20, in <module>\nImportError: cannot import name 'endpoints' from 'botocore.data' (unknown location)\n",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "stdout": "Caught expected error: _send_request() takes 5 positional arguments but 6 were given\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "botocore/regions.py:90:    def __init__(self, endpoint_data):\nbotocore/regions.py:92:        :param endpoint_data: A dict of partition data.\nbotocore/regions.py:94:        if 'partitions' not in endpoint_data:\nbotocore/regions.py:96:        self._endpoint_data = endpoint_data\nbotocore/regions.py:100:        for partition in self._endpoint_data['partitions']:\nbotocore/regions.py:107:        for partition in self._endpoint_data['partitions']:\nbotocore/regions.py:120:        for partition in self._endpoint_data['partitions']:\n",
  "stderr": "grep: botocore/__pycache__/regions.cpython-37.pyc: binary file matches\n",
  "exit_code": 0,
  "budget_warning": "Only 10 tool call(s) remaining (20/30 used). Finalize your edits and call submit_patch soon."
}