--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/env/lib/python3.7/site-packages/boto/sns/connection.py	Sat May 02 07:14:21 2020 -0400
@@ -0,0 +1,765 @@
+# Copyright (c) 2010-2012 Mitch Garnaat http://garnaat.org/
+# Copyright (c) 2012 Amazon.com, Inc. or its affiliates.  All Rights Reserved
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+import uuid
+import hashlib
+
+from boto.connection import AWSQueryConnection
+from boto.regioninfo import RegionInfo
+from boto.compat import json
+import boto
+
+
+class SNSConnection(AWSQueryConnection):
+    """
+    Amazon Simple Notification Service
+    Amazon Simple Notification Service (Amazon SNS) is a web service
+    that enables you to build distributed web-enabled applications.
+    Applications can use Amazon SNS to easily push real-time
+    notification messages to interested subscribers over multiple
+    delivery protocols. For more information about this product see
+    `http://aws.amazon.com/sns`_. For detailed information about
+    Amazon SNS features and their associated API calls, see the
+    `Amazon SNS Developer Guide`_.
+
+    We also provide SDKs that enable you to access Amazon SNS from
+    your preferred programming language. The SDKs contain
+    functionality that automatically takes care of tasks such as:
+    cryptographically signing your service requests, retrying
+    requests, and handling error responses. For a list of available
+    SDKs, go to `Tools for Amazon Web Services`_.
+    """
+    DefaultRegionName = boto.config.get('Boto', 'sns_region_name', 'us-east-1')
+    DefaultRegionEndpoint = boto.config.get('Boto', 'sns_region_endpoint', 
+                                            'sns.us-east-1.amazonaws.com')
+    APIVersion = boto.config.get('Boto', 'sns_version', '2010-03-31')
+
+
+    def __init__(self, aws_access_key_id=None, aws_secret_access_key=None,
+                 is_secure=True, port=None, proxy=None, proxy_port=None,
+                 proxy_user=None, proxy_pass=None, debug=0,
+                 https_connection_factory=None, region=None, path='/',
+                 security_token=None, validate_certs=True,
+                 profile_name=None):
+        if not region:
+            region = RegionInfo(self, self.DefaultRegionName,
+                                self.DefaultRegionEndpoint,
+                                connection_cls=SNSConnection)
+        self.region = region
+        super(SNSConnection, self).__init__(aws_access_key_id,
+                                    aws_secret_access_key,
+                                    is_secure, port, proxy, proxy_port,
+                                    proxy_user, proxy_pass,
+                                    self.region.endpoint, debug,
+                                    https_connection_factory, path,
+                                    security_token=security_token,
+                                    validate_certs=validate_certs,
+                                    profile_name=profile_name)
+
+    def _build_dict_as_list_params(self, params, dictionary, name):
+      """
+            Serialize a parameter 'name' which value is a 'dictionary' into a list of parameters.
+
+            See: http://docs.aws.amazon.com/sns/latest/api/API_SetPlatformApplicationAttributes.html
+            For example::
+
+                dictionary = {'PlatformPrincipal': 'foo', 'PlatformCredential': 'bar'}
+                name = 'Attributes'
+
+            would result in params dict being populated with:
+                Attributes.entry.1.key    = PlatformPrincipal
+                Attributes.entry.1.value  = foo
+                Attributes.entry.2.key    = PlatformCredential
+                Attributes.entry.2.value  = bar
+
+      :param params: the resulting parameters will be added to this dict
+      :param dictionary: dict - value of the serialized parameter
+      :param name: name of the serialized parameter
+      """
+      items = sorted(dictionary.items(), key=lambda x:x[0])
+      for kv, index in zip(items, list(range(1, len(items)+1))):
+        key, value = kv
+        prefix = '%s.entry.%s' % (name, index)
+        params['%s.key' % prefix] = key
+        params['%s.value' % prefix] = value
+
+    def _required_auth_capability(self):
+        return ['hmac-v4']
+
+    def get_all_topics(self, next_token=None):
+        """
+        :type next_token: string
+        :param next_token: Token returned by the previous call to
+                           this method.
+
+        """
+        params = {}
+        if next_token:
+            params['NextToken'] = next_token
+        return self._make_request('ListTopics', params)
+
+    def get_topic_attributes(self, topic):
+        """
+        Get attributes of a Topic
+
+        :type topic: string
+        :param topic: The ARN of the topic.
+
+        """
+        params = {'TopicArn': topic}
+        return self._make_request('GetTopicAttributes', params)
+
+    def set_topic_attributes(self, topic, attr_name, attr_value):
+        """
+        Get attributes of a Topic
+
+        :type topic: string
+        :param topic: The ARN of the topic.
+
+        :type attr_name: string
+        :param attr_name: The name of the attribute you want to set.
+                          Only a subset of the topic's attributes are mutable.
+                          Valid values: Policy | DisplayName
+
+        :type attr_value: string
+        :param attr_value: The new value for the attribute.
+
+        """
+        params = {'TopicArn': topic,
+                  'AttributeName': attr_name,
+                  'AttributeValue': attr_value}
+        return self._make_request('SetTopicAttributes', params)
+
+    def add_permission(self, topic, label, account_ids, actions):
+        """
+        Adds a statement to a topic's access control policy, granting
+        access for the specified AWS accounts to the specified actions.
+
+        :type topic: string
+        :param topic: The ARN of the topic.
+
+        :type label: string
+        :param label: A unique identifier for the new policy statement.
+
+        :type account_ids: list of strings
+        :param account_ids: The AWS account ids of the users who will be
+                            give access to the specified actions.
+
+        :type actions: list of strings
+        :param actions: The actions you want to allow for each of the
+                        specified principal(s).
+
+        """
+        params = {'TopicArn': topic,
+                  'Label': label}
+        self.build_list_params(params, account_ids, 'AWSAccountId.member')
+        self.build_list_params(params, actions, 'ActionName.member')
+        return self._make_request('AddPermission', params)
+
+    def remove_permission(self, topic, label):
+        """
+        Removes a statement from a topic's access control policy.
+
+        :type topic: string
+        :param topic: The ARN of the topic.
+
+        :type label: string
+        :param label: A unique identifier for the policy statement
+                      to be removed.
+
+        """
+        params = {'TopicArn': topic,
+                  'Label': label}
+        return self._make_request('RemovePermission', params)
+
+    def create_topic(self, topic):
+        """
+        Create a new Topic.
+
+        :type topic: string
+        :param topic: The name of the new topic.
+
+        """
+        params = {'Name': topic}
+        return self._make_request('CreateTopic', params)
+
+    def delete_topic(self, topic):
+        """
+        Delete an existing topic
+
+        :type topic: string
+        :param topic: The ARN of the topic
+
+        """
+        params = {'TopicArn': topic}
+        return self._make_request('DeleteTopic', params, '/', 'GET')
+
+    def publish(self, topic=None, message=None, subject=None, target_arn=None,
+                message_structure=None, message_attributes=None):
+        """
+        Sends a message to all of a topic's subscribed endpoints
+
+        :type topic: string
+        :param topic: The topic you want to publish to.
+
+        :type message: string
+        :param message: The message you want to send to the topic.
+                        Messages must be UTF-8 encoded strings and
+                        be at most 4KB in size.
+
+        :type message_structure: string
+        :param message_structure: Optional parameter. If left as ``None``,
+                                  plain text will be sent. If set to ``json``,
+                                  your message should be a JSON string that
+                                  matches the structure described at
+                                  http://docs.aws.amazon.com/sns/latest/dg/PublishTopic.html#sns-message-formatting-by-protocol
+
+        :type message_attributes: dict
+        :param message_attributes: Message attributes to set. Should be
+            of the form:
+
+            .. code-block:: python
+
+                {
+                    "name1": {
+                        "data_type": "Number",
+                        "string_value": "42"
+                    },
+                    "name2": {
+                        "data_type": "String",
+                        "string_value": "Bob"
+                    }
+                }
+
+        :type subject: string
+        :param subject: Optional parameter to be used as the "Subject"
+                        line of the email notifications.
+
+        :type target_arn: string
+        :param target_arn: Optional parameter for either TopicArn or
+                           EndpointArn, but not both.
+
+        """
+        if message is None:
+            # To be backwards compatible when message did not have
+            # a default value and topic and message were required
+            # args.
+            raise TypeError("'message' is a required parameter")
+        params = {'Message': message}
+        if subject is not None:
+            params['Subject'] = subject
+        if topic is not None:
+            params['TopicArn'] = topic
+        if target_arn is not None:
+            params['TargetArn'] = target_arn
+        if message_structure is not None:
+            params['MessageStructure'] = message_structure
+        if message_attributes is not None:
+            keys = sorted(message_attributes.keys())
+            for i, name in enumerate(keys, start=1):
+                attribute = message_attributes[name]
+                params['MessageAttributes.entry.{0}.Name'.format(i)] = name
+                if 'data_type' in attribute:
+                    params['MessageAttributes.entry.{0}.Value.DataType'.format(i)] = \
+                        attribute['data_type']
+                if 'string_value' in attribute:
+                    params['MessageAttributes.entry.{0}.Value.StringValue'.format(i)] = \
+                        attribute['string_value']
+                if 'binary_value' in attribute:
+                    params['MessageAttributes.entry.{0}.Value.BinaryValue'.format(i)] = \
+                        attribute['binary_value']
+        return self._make_request('Publish', params, '/', 'POST')
+
+    def subscribe(self, topic, protocol, endpoint):
+        """
+        Subscribe to a Topic.
+
+        :type topic: string
+        :param topic: The ARN of the new topic.
+
+        :type protocol: string
+        :param protocol: The protocol used to communicate with
+                         the subscriber.  Current choices are:
+                         email|email-json|http|https|sqs|sms|application
+
+        :type endpoint: string
+        :param endpoint: The location of the endpoint for
+                         the subscriber.
+                         * For email, this would be a valid email address
+                         * For email-json, this would be a valid email address
+                         * For http, this would be a URL beginning with http
+                         * For https, this would be a URL beginning with https
+                         * For sqs, this would be the ARN of an SQS Queue
+                         * For sms, this would be a phone number of an
+                           SMS-enabled device
+                         * For application, the endpoint is the EndpointArn
+                           of a mobile app and device.
+        """
+        params = {'TopicArn': topic,
+                  'Protocol': protocol,
+                  'Endpoint': endpoint}
+        return self._make_request('Subscribe', params)
+
+    def subscribe_sqs_queue(self, topic, queue):
+        """
+        Subscribe an SQS queue to a topic.
+
+        This is convenience method that handles most of the complexity involved
+        in using an SQS queue as an endpoint for an SNS topic.  To achieve this
+        the following operations are performed:
+
+        * The correct ARN is constructed for the SQS queue and that ARN is
+          then subscribed to the topic.
+        * A JSON policy document is contructed that grants permission to
+          the SNS topic to send messages to the SQS queue.
+        * This JSON policy is then associated with the SQS queue using
+          the queue's set_attribute method.  If the queue already has
+          a policy associated with it, this process will add a Statement to
+          that policy.  If no policy exists, a new policy will be created.
+
+        :type topic: string
+        :param topic: The ARN of the new topic.
+
+        :type queue: A boto Queue object
+        :param queue: The queue you wish to subscribe to the SNS Topic.
+        """
+        t = queue.id.split('/')
+        q_arn = queue.arn
+        sid = hashlib.md5((topic + q_arn).encode('utf-8')).hexdigest()
+        sid_exists = False
+        resp = self.subscribe(topic, 'sqs', q_arn)
+        attr = queue.get_attributes('Policy')
+        if 'Policy' in attr:
+            policy = json.loads(attr['Policy'])
+        else:
+            policy = {}
+        if 'Version' not in policy:
+            policy['Version'] = '2008-10-17'
+        if 'Statement' not in policy:
+            policy['Statement'] = []
+        # See if a Statement with the Sid exists already.
+        for s in policy['Statement']:
+            if s['Sid'] == sid:
+                sid_exists = True
+        if not sid_exists:
+            statement = {'Action': 'SQS:SendMessage',
+                         'Effect': 'Allow',
+                         'Principal': {'AWS': '*'},
+                         'Resource': q_arn,
+                         'Sid': sid,
+                         'Condition': {'StringLike': {'aws:SourceArn': topic}}}
+            policy['Statement'].append(statement)
+        queue.set_attribute('Policy', json.dumps(policy))
+        return resp
+
+    def confirm_subscription(self, topic, token,
+                             authenticate_on_unsubscribe=False):
+        """
+        Get properties of a Topic
+
+        :type topic: string
+        :param topic: The ARN of the new topic.
+
+        :type token: string
+        :param token: Short-lived token sent to and endpoint during
+                      the Subscribe operation.
+
+        :type authenticate_on_unsubscribe: bool
+        :param authenticate_on_unsubscribe: Optional parameter indicating
+                                            that you wish to disable
+                                            unauthenticated unsubscription
+                                            of the subscription.
+
+        """
+        params = {'TopicArn': topic, 'Token': token}
+        if authenticate_on_unsubscribe:
+            params['AuthenticateOnUnsubscribe'] = 'true'
+        return self._make_request('ConfirmSubscription', params)
+
+    def unsubscribe(self, subscription):
+        """
+        Allows endpoint owner to delete subscription.
+        Confirmation message will be delivered.
+
+        :type subscription: string
+        :param subscription: The ARN of the subscription to be deleted.
+
+        """
+        params = {'SubscriptionArn': subscription}
+        return self._make_request('Unsubscribe', params)
+
+    def get_all_subscriptions(self, next_token=None):
+        """
+        Get list of all subscriptions.
+
+        :type next_token: string
+        :param next_token: Token returned by the previous call to
+                           this method.
+
+        """
+        params = {}
+        if next_token:
+            params['NextToken'] = next_token
+        return self._make_request('ListSubscriptions', params)
+
+    def get_all_subscriptions_by_topic(self, topic, next_token=None):
+        """
+        Get list of all subscriptions to a specific topic.
+
+        :type topic: string
+        :param topic: The ARN of the topic for which you wish to
+                      find subscriptions.
+
+        :type next_token: string
+        :param next_token: Token returned by the previous call to
+                           this method.
+
+        """
+        params = {'TopicArn': topic}
+        if next_token:
+            params['NextToken'] = next_token
+        return self._make_request('ListSubscriptionsByTopic', params)
+
+    def create_platform_application(self, name=None, platform=None,
+                                    attributes=None):
+        """
+        The `CreatePlatformApplication` action creates a platform
+        application object for one of the supported push notification
+        services, such as APNS and GCM, to which devices and mobile
+        apps may register. You must specify PlatformPrincipal and
+        PlatformCredential attributes when using the
+        `CreatePlatformApplication` action. The PlatformPrincipal is
+        received from the notification service. For APNS/APNS_SANDBOX,
+        PlatformPrincipal is "SSL certificate". For GCM,
+        PlatformPrincipal is not applicable. For ADM,
+        PlatformPrincipal is "client id". The PlatformCredential is
+        also received from the notification service. For
+        APNS/APNS_SANDBOX, PlatformCredential is "private key". For
+        GCM, PlatformCredential is "API key". For ADM,
+        PlatformCredential is "client secret". The
+        PlatformApplicationArn that is returned when using
+        `CreatePlatformApplication` is then used as an attribute for
+        the `CreatePlatformEndpoint` action. For more information, see
+        `Using Amazon SNS Mobile Push Notifications`_.
+
+        :type name: string
+        :param name: Application names must be made up of only uppercase and
+            lowercase ASCII letters, numbers, underscores, hyphens, and
+            periods, and must be between 1 and 256 characters long.
+
+        :type platform: string
+        :param platform: The following platforms are supported: ADM (Amazon
+            Device Messaging), APNS (Apple Push Notification Service),
+            APNS_SANDBOX, and GCM (Google Cloud Messaging).
+
+        :type attributes: map
+        :param attributes: For a list of attributes, see
+            `SetPlatformApplicationAttributes`_
+
+        """
+        params = {}
+        if name is not None:
+            params['Name'] = name
+        if platform is not None:
+            params['Platform'] = platform
+        if attributes is not None:
+            self._build_dict_as_list_params(params, attributes, 'Attributes')
+        return self._make_request(action='CreatePlatformApplication',
+                                  params=params)
+
+    def set_platform_application_attributes(self,
+                                            platform_application_arn=None,
+                                            attributes=None):
+        """
+        The `SetPlatformApplicationAttributes` action sets the
+        attributes of the platform application object for the
+        supported push notification services, such as APNS and GCM.
+        For more information, see `Using Amazon SNS Mobile Push
+        Notifications`_.
+
+        :type platform_application_arn: string
+        :param platform_application_arn: PlatformApplicationArn for
+            SetPlatformApplicationAttributes action.
+
+        :type attributes: map
+        :param attributes:
+        A map of the platform application attributes. Attributes in this map
+            include the following:
+
+
+        + `PlatformCredential` -- The credential received from the notification
+              service. For APNS/APNS_SANDBOX, PlatformCredential is "private
+              key". For GCM, PlatformCredential is "API key". For ADM,
+              PlatformCredential is "client secret".
+        + `PlatformPrincipal` -- The principal received from the notification
+              service. For APNS/APNS_SANDBOX, PlatformPrincipal is "SSL
+              certificate". For GCM, PlatformPrincipal is not applicable. For
+              ADM, PlatformPrincipal is "client id".
+        + `EventEndpointCreated` -- Topic ARN to which EndpointCreated event
+              notifications should be sent.
+        + `EventEndpointDeleted` -- Topic ARN to which EndpointDeleted event
+              notifications should be sent.
+        + `EventEndpointUpdated` -- Topic ARN to which EndpointUpdate event
+              notifications should be sent.
+        + `EventDeliveryFailure` -- Topic ARN to which DeliveryFailure event
+              notifications should be sent upon Direct Publish delivery failure
+              (permanent) to one of the application's endpoints.
+
+        """
+        params = {}
+        if platform_application_arn is not None:
+            params['PlatformApplicationArn'] = platform_application_arn
+        if attributes is not None:
+            self._build_dict_as_list_params(params, attributes, 'Attributes')
+        return self._make_request(action='SetPlatformApplicationAttributes',
+                                  params=params)
+
+    def get_platform_application_attributes(self,
+                                            platform_application_arn=None):
+        """
+        The `GetPlatformApplicationAttributes` action retrieves the
+        attributes of the platform application object for the
+        supported push notification services, such as APNS and GCM.
+        For more information, see `Using Amazon SNS Mobile Push
+        Notifications`_.
+
+        :type platform_application_arn: string
+        :param platform_application_arn: PlatformApplicationArn for
+            GetPlatformApplicationAttributesInput.
+
+        """
+        params = {}
+        if platform_application_arn is not None:
+            params['PlatformApplicationArn'] = platform_application_arn
+        return self._make_request(action='GetPlatformApplicationAttributes',
+                                  params=params)
+
+    def list_platform_applications(self, next_token=None):
+        """
+        The `ListPlatformApplications` action lists the platform
+        application objects for the supported push notification
+        services, such as APNS and GCM. The results for
+        `ListPlatformApplications` are paginated and return a limited
+        list of applications, up to 100. If additional records are
+        available after the first page results, then a NextToken
+        string will be returned. To receive the next page, you call
+        `ListPlatformApplications` using the NextToken string received
+        from the previous call. When there are no more records to
+        return, NextToken will be null. For more information, see
+        `Using Amazon SNS Mobile Push Notifications`_.
+
+        :type next_token: string
+        :param next_token: NextToken string is used when calling
+            ListPlatformApplications action to retrieve additional records that
+            are available after the first page results.
+
+        """
+        params = {}
+        if next_token is not None:
+            params['NextToken'] = next_token
+        return self._make_request(action='ListPlatformApplications',
+                                  params=params)
+
+    def list_endpoints_by_platform_application(self,
+                                               platform_application_arn=None,
+                                               next_token=None):
+        """
+        The `ListEndpointsByPlatformApplication` action lists the
+        endpoints and endpoint attributes for devices in a supported
+        push notification service, such as GCM and APNS. The results
+        for `ListEndpointsByPlatformApplication` are paginated and
+        return a limited list of endpoints, up to 100. If additional
+        records are available after the first page results, then a
+        NextToken string will be returned. To receive the next page,
+        you call `ListEndpointsByPlatformApplication` again using the
+        NextToken string received from the previous call. When there
+        are no more records to return, NextToken will be null. For
+        more information, see `Using Amazon SNS Mobile Push
+        Notifications`_.
+
+        :type platform_application_arn: string
+        :param platform_application_arn: PlatformApplicationArn for
+            ListEndpointsByPlatformApplicationInput action.
+
+        :type next_token: string
+        :param next_token: NextToken string is used when calling
+            ListEndpointsByPlatformApplication action to retrieve additional
+            records that are available after the first page results.
+
+        """
+        params = {}
+        if platform_application_arn is not None:
+            params['PlatformApplicationArn'] = platform_application_arn
+        if next_token is not None:
+            params['NextToken'] = next_token
+        return self._make_request(action='ListEndpointsByPlatformApplication',
+                                  params=params)
+
+    def delete_platform_application(self, platform_application_arn=None):
+        """
+        The `DeletePlatformApplication` action deletes a platform
+        application object for one of the supported push notification
+        services, such as APNS and GCM. For more information, see
+        `Using Amazon SNS Mobile Push Notifications`_.
+
+        :type platform_application_arn: string
+        :param platform_application_arn: PlatformApplicationArn of platform
+            application object to delete.
+
+        """
+        params = {}
+        if platform_application_arn is not None:
+            params['PlatformApplicationArn'] = platform_application_arn
+        return self._make_request(action='DeletePlatformApplication',
+                                  params=params)
+
+    def create_platform_endpoint(self, platform_application_arn=None,
+                                 token=None, custom_user_data=None,
+                                 attributes=None):
+        """
+        The `CreatePlatformEndpoint` creates an endpoint for a device
+        and mobile app on one of the supported push notification
+        services, such as GCM and APNS. `CreatePlatformEndpoint`
+        requires the PlatformApplicationArn that is returned from
+        `CreatePlatformApplication`. The EndpointArn that is returned
+        when using `CreatePlatformEndpoint` can then be used by the
+        `Publish` action to send a message to a mobile app or by the
+        `Subscribe` action for subscription to a topic. For more
+        information, see `Using Amazon SNS Mobile Push
+        Notifications`_.
+
+        :type platform_application_arn: string
+        :param platform_application_arn: PlatformApplicationArn returned from
+            CreatePlatformApplication is used to create a an endpoint.
+
+        :type token: string
+        :param token: Unique identifier created by the notification service for
+            an app on a device. The specific name for Token will vary,
+            depending on which notification service is being used. For example,
+            when using APNS as the notification service, you need the device
+            token. Alternatively, when using GCM or ADM, the device token
+            equivalent is called the registration ID.
+
+        :type custom_user_data: string
+        :param custom_user_data: Arbitrary user data to associate with the
+            endpoint. SNS does not use this data. The data must be in UTF-8
+            format and less than 2KB.
+
+        :type attributes: map
+        :param attributes: For a list of attributes, see
+            `SetEndpointAttributes`_.
+
+        """
+        params = {}
+        if platform_application_arn is not None:
+            params['PlatformApplicationArn'] = platform_application_arn
+        if token is not None:
+            params['Token'] = token
+        if custom_user_data is not None:
+            params['CustomUserData'] = custom_user_data
+        if attributes is not None:
+            self._build_dict_as_list_params(params, attributes, 'Attributes')
+        return self._make_request(action='CreatePlatformEndpoint',
+                                  params=params)
+
+    def delete_endpoint(self, endpoint_arn=None):
+        """
+        The `DeleteEndpoint` action, which is idempotent, deletes the
+        endpoint from SNS. For more information, see `Using Amazon SNS
+        Mobile Push Notifications`_.
+
+        :type endpoint_arn: string
+        :param endpoint_arn: EndpointArn of endpoint to delete.
+
+        """
+        params = {}
+        if endpoint_arn is not None:
+            params['EndpointArn'] = endpoint_arn
+        return self._make_request(action='DeleteEndpoint', params=params)
+
+    def set_endpoint_attributes(self, endpoint_arn=None, attributes=None):
+        """
+        The `SetEndpointAttributes` action sets the attributes for an
+        endpoint for a device on one of the supported push
+        notification services, such as GCM and APNS. For more
+        information, see `Using Amazon SNS Mobile Push
+        Notifications`_.
+
+        :type endpoint_arn: string
+        :param endpoint_arn: EndpointArn used for SetEndpointAttributes action.
+
+        :type attributes: map
+        :param attributes:
+        A map of the endpoint attributes. Attributes in this map include the
+            following:
+
+
+        + `CustomUserData` -- arbitrary user data to associate with the
+              endpoint. SNS does not use this data. The data must be in UTF-8
+              format and less than 2KB.
+        + `Enabled` -- flag that enables/disables delivery to the endpoint.
+              Message Processor will set this to false when a notification
+              service indicates to SNS that the endpoint is invalid. Users can
+              set it back to true, typically after updating Token.
+        + `Token` -- device token, also referred to as a registration id, for
+              an app and mobile device. This is returned from the notification
+              service when an app and mobile device are registered with the
+              notification service.
+
+        """
+        params = {}
+        if endpoint_arn is not None:
+            params['EndpointArn'] = endpoint_arn
+        if attributes is not None:
+            self._build_dict_as_list_params(params, attributes, 'Attributes')
+        return self._make_request(action='SetEndpointAttributes',
+                                  params=params)
+
+    def get_endpoint_attributes(self, endpoint_arn=None):
+        """
+        The `GetEndpointAttributes` retrieves the endpoint attributes
+        for a device on one of the supported push notification
+        services, such as GCM and APNS. For more information, see
+        `Using Amazon SNS Mobile Push Notifications`_.
+
+        :type endpoint_arn: string
+        :param endpoint_arn: EndpointArn for GetEndpointAttributes input.
+
+        """
+        params = {}
+        if endpoint_arn is not None:
+            params['EndpointArn'] = endpoint_arn
+        return self._make_request(action='GetEndpointAttributes',
+                                  params=params)
+
+    def _make_request(self, action, params, path='/', verb='GET'):
+        params['ContentType'] = 'JSON'
+        response = self.make_request(action=action, verb=verb,
+                                     path=path, params=params)
+        body = response.read().decode('utf-8')
+        boto.log.debug(body)
+        if response.status == 200:
+            return json.loads(body)
+        else:
+            boto.log.error('%s %s' % (response.status, response.reason))
+            boto.log.error('%s' % body)
+            raise self.ResponseError(response.status, response.reason, body)