text: from __future__ import unicode_literals
  
  import re
  from six.moves.urllib.parse import urlparse
  
  from moto.core.responses import BaseResponse
  from moto.core.utils import amz_crc32, amzn_request_id
  from .utils import parse_message_attributes
  from .models import sqs_backends
  from .exceptions import (
      MessageAttributesInvalid,
      MessageNotInflight,
      QueueDoesNotExist,
      ReceiptHandleIsInvalid,
  )
  
  MAXIMUM_VISIBILTY_TIMEOUT = 43200
  MAXIMUM_MESSAGE_LENGTH = 262144  # 256 KiB
  DEFAULT_RECEIVED_MESSAGES = 1
  
  
  class SQSResponse(BaseResponse):
  
      region_regex = re.compile(r'://(.+?)\.queue\.amazonaws\.com')
  
      @property
      def sqs_backend(self):
          region = 'sa-east-1'
          return sqs_backends[region]
  
      @property
      def attribute(self):
          if not hasattr(self, '_attribute'):
              self._attribute = self._get_map_prefix('Attribute', key_end='.Name', value_end='.Value')
          return self._attribute
  
      def _get_queue_name(self):
          try:
              queue_name = self.querystring.get('QueueUrl')[0].split("/")[-1]
          except TypeError:
              # Fallback to reading from the URL
              queue_name = self.path.split("/")[-1]
          return queue_name
  
      def _get_validated_visibility_timeout(self, timeout=None):
          """
          :raises ValueError: If specified visibility timeout exceeds MAXIMUM_VISIBILTY_TIMEOUT
          :raises TypeError: If visibility timeout was not specified
          """
          if timeout is not None:
              visibility_timeout = int(timeout)
          else:
              visibility_timeout = int(self.querystring.get("VisibilityTimeout")[0])
  
          if visibility_timeout > MAXIMUM_VISIBILTY_TIMEOUT:
              raise ValueError
  
          return visibility_timeout
  
      @amz_crc32  # crc last as request_id can edit XML
      @amzn_request_id
      def call_action(self):
          status_code, headers, body = super(SQSResponse, self).call_action()
          if status_code == 404:
              return 404, headers, ERROR_INEXISTENT_QUEUE
          return status_code, headers, body
  
      def _error(self, code, message, status=400):
          template = self.response_template(ERROR_TEMPLATE)
          return template.render(code=code, message=message), dict(status=status)
  
      def create_queue(self):
          request_url = urlparse(self.uri)
          queue_name = self._get_param("QueueName")
  
          try:
              queue = self.sqs_backend.create_queue(queue_name, **self.attribute)
          except MessageAttributesInvalid as e:
              return self._error('InvalidParameterValue', e.description)
  
          template = self.response_template(CREATE_QUEUE_RESPONSE)
          return template.render(queue=queue, request_url=request_url)
  
      def get_queue_url(self):
          request_url = urlparse(self.uri)
          queue_name = self._get_param("QueueName")
  
          try:
              queue = self.sqs_backend.get_queue(queue_name)
          except QueueDoesNotExist as e:
              return self._error('AWS.SimpleQueueService.NonExistentQueue',
                                 e.description)
  
          if queue:
              template = self.response_template(GET_QUEUE_URL_RESPONSE)
              return template.render(queue=queue, request_url=request_url)
          else:
              return "", dict(status=404)
  
      def list_queues(self):
          request_url = urlparse(self.uri)
          queue_name_prefix = self._get_param('QueueNamePrefix')
          queues = self.sqs_backend.list_queues(queue_name_prefix)
          template = self.response_template(LIST_QUEUES_RESPONSE)
          return template.render(queues=queues, request_url=request_url)
  
      def change_message_visibility(self):
          queue_name = self._get_queue_name()
          receipt_handle = self._get_param('ReceiptHandle')
  
          try:
              visibility_timeout = self._get_validated_visibility_timeout()
          except ValueError:
              return ERROR_MAX_VISIBILITY_TIMEOUT_RESPONSE, dict(status=400)
  
          try:
              self.sqs_backend.change_message_visibility(
                  queue_name=queue_name,
                  receipt_handle=receipt_handle,
                  visibility_timeout=visibility_timeout
              )
          except (ReceiptHandleIsInvalid, MessageNotInflight) as e:
              return "Invalid request: {0}".format(e.description), dict(status=e.status_code)
  
          template = self.response_template(CHANGE_MESSAGE_VISIBILITY_RESPONSE)
          return template.render()
  
      def change_message_visibility_batch(self):
          queue_name = self._get_queue_name()
          entries = self._get_list_prefix('ChangeMessageVisibilityBatchRequestEntry')
  
          success = []
          error = []
          for entry in entries:
              try:
                  visibility_timeout = self._get_validated_visibility_timeout(entry['visibility_timeout'])
              except ValueError:
                  error.append({
                      'Id': entry['id'],
                      'SenderFault': 'true',
                      'Code': 'InvalidParameterValue',
                      'Message': 'Visibility timeout invalid'
                  })
                  continue
  
              try:
                  self.sqs_backend.change_message_visibility(
                      queue_name=queue_name,
                      receipt_handle=entry['receipt_handle'],
                      visibility_timeout=visibility_timeout
                  )
                  success.append(entry['id'])
              except ReceiptHandleIsInvalid as e:
                  error.append({
                      'Id': entry['id'],
                      'SenderFault': 'true',
                      'Code': 'ReceiptHandleIsInvalid',
                      'Message': e.description
                  })
              except MessageNotInflight as e:
                  error.append({
                      'Id': entry['id'],
                      'SenderFault': 'false',
                      'Code': 'AWS.SimpleQueueService.MessageNotInflight',
                      'Message': e.description
                  })
  
          template = self.response_template(CHANGE_MESSAGE_VISIBILITY_BATCH_RESPONSE)
          return template.render(success=success, errors=error)
  
      def get_queue_attributes(self):
          queue_name = self._get_queue_name()
          try:
              queue = self.sqs_backend.get_queue(queue_name)
          except QueueDoesNotExist as e:
              return self._error('AWS.SimpleQueueService.NonExistentQueue',
                                 e.description)
  
          template = self.response_template(GET_QUEUE_ATTRIBUTES_RESPONSE)
          return template.render(queue=queue)
  
      def set_queue_attributes(self):
          # TODO validate self.get_param('QueueUrl')
          queue_name = self._get_queue_name()
          self.sqs_backend.set_queue_attributes(queue_name, self.attribute)
  
          return SET_QUEUE_ATTRIBUTE_RESPONSE
  
      def delete_queue(self):
          # TODO validate self.get_param('QueueUrl')
          queue_name = self._get_queue_name()
          queue = self.sqs_backend.delete_queue(queue_name)
          if not queue:
              return "A queue with name {0} does not exist".format(queue_name), dict(status=404)
  
          template = self.response_template(DELETE_QUEUE_RESPONSE)
          return template.render(queue=queue)
  
      def send_message(self):
          message = self._get_param('MessageBody')
          delay_seconds = int(self._get_param('DelaySeconds', 0))
          message_group_id = self._get_param("MessageGroupId")
          message_dedupe_id = self._get_param("MessageDeduplicationId")
  
          if len(message) > MAXIMUM_MESSAGE_LENGTH:
              return ERROR_TOO_LONG_RESPONSE, dict(status=400)
  
          try:
              message_attributes = parse_message_attributes(self.querystring)
          except MessageAttributesInvalid as e:
              return e.description, dict(status=e.status_code)
  
          queue_name = self._get_queue_name()
  
          message = self.sqs_backend.send_message(
              queue_name,
              message,
              message_attributes=message_attributes,
              delay_seconds=delay_seconds,
              deduplication_id=message_dedupe_id,
              group_id=message_group_id
          )
          template = self.response_template(SEND_MESSAGE_RESPONSE)
          return template.render(message=message, message_attributes=message_attributes)
  
      def send_message_batch(self):
          """
          The querystring comes like this
  
          'SendMessageBatchRequestEntry.1.DelaySeconds': ['0'],
          'SendMessageBatchRequestEntry.1.MessageBody': ['test message 1'],
          'SendMessageBatchRequestEntry.1.Id': ['6d0f122d-4b13-da2c-378f-e74244d8ad11']
          'SendMessageBatchRequestEntry.2.Id': ['ff8cbf59-70a2-c1cb-44c7-b7469f1ba390'],
          'SendMessageBatchRequestEntry.2.MessageBody': ['test message 2'],
          'SendMessageBatchRequestEntry.2.DelaySeconds': ['0'],
          """
  
          queue_name = self._get_queue_name()
  
          messages = []
          for index in range(1, 11):
              # Loop through looking for messages
              message_key = 'SendMessageBatchRequestEntry.{0}.MessageBody'.format(
                  index)
              message_body = self.querystring.get(message_key)
              if not message_body:
                  # Found all messages
                  break
  
              message_user_id_key = 'SendMessageBatchRequestEntry.{0}.Id'.format(
                  index)
              message_user_id = self.querystring.get(message_user_id_key)[0]
              delay_key = 'SendMessageBatchRequestEntry.{0}.DelaySeconds'.format(
                  index)
              delay_seconds = self.querystring.get(delay_key, [None])[0]
              message = self.sqs_backend.send_message(
                  queue_name, message_body[0], delay_seconds=delay_seconds)
              message.user_id = message_user_id
  
              message_attributes = parse_message_attributes(
                  self.querystring, base='SendMessageBatchRequestEntry.{0}.'.format(index))
              if type(message_attributes) == tuple:
                  return message_attributes[0], message_attributes[1]
              message.message_attributes = message_attributes
  
              messages.append(message)
  
          template = self.response_template(SEND_MESSAGE_BATCH_RESPONSE)
          return template.render(messages=messages)
  
      def delete_message(self):
          queue_name = self._get_queue_name()
          receipt_handle = self.querystring.get("ReceiptHandle")[0]
          self.sqs_backend.delete_message(queue_name, receipt_handle)
          template = self.response_template(DELETE_MESSAGE_RESPONSE)
          return template.render()
  
      def delete_message_batch(self):
          """
          The querystring comes like this
  
          'DeleteMessageBatchRequestEntry.1.Id': ['message_1'],
          'DeleteMessageBatchRequestEntry.1.ReceiptHandle': ['asdfsfs...'],
          'DeleteMessageBatchRequestEntry.2.Id': ['message_2'],
          'DeleteMessageBatchRequestEntry.2.ReceiptHandle': ['zxcvfda...'],
          ...
          """
          queue_name = self._get_queue_name()
  
          message_ids = []
          for index in range(1, 11):
              # Loop through looking for messages
              receipt_key = 'DeleteMessageBatchRequestEntry.{0}.ReceiptHandle'.format(
                  index)
              receipt_handle = self.querystring.get(receipt_key)
              if not receipt_handle:
                  # Found all messages
                  break
  
              self.sqs_backend.delete_message(queue_name, receipt_handle[0])
  
              message_user_id_key = 'DeleteMessageBatchRequestEntry.{0}.Id'.format(
                  index)
              message_user_id = self.querystring.get(message_user_id_key)[0]
              message_ids.append(message_user_id)
  
          template = self.response_template(DELETE_MESSAGE_BATCH_RESPONSE)
          return template.render(message_ids=message_ids)
  
      def purge_queue(self):
          queue_name = self._get_queue_name()
          self.sqs_backend.purge_queue(queue_name)
          template = self.response_template(PURGE_QUEUE_RESPONSE)
          return template.render()
  
      def receive_message(self):
          queue_name = self._get_queue_name()
  
          try:
              queue = self.sqs_backend.get_queue(queue_name)
          except QueueDoesNotExist as e:
              return self._error('QueueDoesNotExist', e.description)
  
          try:
              message_count = int(self.querystring.get("MaxNumberOfMessages")[0])
          except TypeError:
              message_count = DEFAULT_RECEIVED_MESSAGES
  
          if message_count < 1 or message_count > 10:
              return self._error(
                  "InvalidParameterValue",
                  "An error occurred (InvalidParameterValue) when calling "
                  "the ReceiveMessage operation: Value %s for parameter "
                  "MaxNumberOfMessages is invalid. Reason: must be between "
                  "1 and 10, if provided." % message_count)
  
          try:
              wait_time = int(self.querystring.get("WaitTimeSeconds")[0])
          except TypeError:
              wait_time = int(queue.receive_message_wait_time_seconds)
  
          if wait_time < 0 or wait_time > 20:
              return self._error(
                  "InvalidParameterValue",
                  "An error occurred (InvalidParameterValue) when calling "
                  "the ReceiveMessage operation: Value %s for parameter "
                  "WaitTimeSeconds is invalid. Reason: must be &lt;= 0 and "
                  "&gt;= 20 if provided." % wait_time)
  
          try:
              visibility_timeout = self._get_validated_visibility_timeout()
          except TypeError:
              visibility_timeout = queue.visibility_timeout
          except ValueError:
              return ERROR_MAX_VISIBILITY_TIMEOUT_RESPONSE, dict(status=400)
  
          messages = self.sqs_backend.receive_messages(
              queue_name, message_count, wait_time, visibility_timeout)
          template = self.response_template(RECEIVE_MESSAGE_RESPONSE)
          return template.render(messages=messages)
  
      def list_dead_letter_source_queues(self):
          request_url = urlparse(self.uri)
          queue_name = self._get_queue_name()
  
          source_queue_urls = self.sqs_backend.list_dead_letter_source_queues(queue_name)
  
          template = self.response_template(LIST_DEAD_LETTER_SOURCE_QUEUES_RESPONSE)
          return template.render(queues=source_queue_urls, request_url=request_url)
  
      def add_permission(self):
          queue_name = self._get_queue_name()
          actions = self._get_multi_param('ActionName')
          account_ids = self._get_multi_param('AWSAccountId')
          label = self._get_param('Label')
  
          self.sqs_backend.add_permission(queue_name, actions, account_ids, label)
  
          template = self.response_template(ADD_PERMISSION_RESPONSE)
          return template.render()
  
      def remove_permission(self):
          queue_name = self._get_queue_name()
          label = self._get_param('Label')
  
          self.sqs_backend.remove_permission(queue_name, label)
  
          template = self.response_template(REMOVE_PERMISSION_RESPONSE)
          return template.render()
  
      def tag_queue(self):
          queue_name = self._get_queue_name()
          tags = self._get_map_prefix('Tag', key_end='.Key', value_end='.Value')
  
          self.sqs_backend.tag_queue(queue_name, tags)
  
          template = self.response_template(TAG_QUEUE_RESPONSE)
          return template.render()
  
      def untag_queue(self):
          queue_name = self._get_queue_name()
          tag_keys = self._get_multi_param('TagKey')
  
          self.sqs_backend.untag_queue(queue_name, tag_keys)
  
          template = self.response_template(UNTAG_QUEUE_RESPONSE)
          return template.render()
  
      def list_queue_tags(self):
          queue_name = self._get_queue_name()
  
          queue = self.sqs_backend.get_queue(queue_name)
  
          template = self.response_template(LIST_QUEUE_TAGS_RESPONSE)
          return template.render(tags=queue.tags)
  
  
  CREATE_QUEUE_RESPONSE = """<CreateQueueResponse>
      <CreateQueueResult>
          <QueueUrl>{{ queue.url(request_url) }}</QueueUrl>
          <VisibilityTimeout>{{ queue.visibility_timeout }}</VisibilityTimeout>
      </CreateQueueResult>
      <ResponseMetadata>
          <RequestId></RequestId>
      </ResponseMetadata>
  </CreateQueueResponse>"""
  
  GET_QUEUE_URL_RESPONSE = """<GetQueueUrlResponse>
      <GetQueueUrlResult>
          <QueueUrl>{{ queue.url(request_url) }}</QueueUrl>
      </GetQueueUrlResult>
      <ResponseMetadata>
          <RequestId></RequestId>
      </ResponseMetadata>
  </GetQueueUrlResponse>"""
  
  LIST_QUEUES_RESPONSE = """<ListQueuesResponse>
      <ListQueuesResult>
          {% for queue in queues %}
              <QueueUrl>{{ queue.url(request_url) }}</QueueUrl>
          {% endfor %}
      </ListQueuesResult>
      <ResponseMetadata>
          <RequestId></RequestId>
      </ResponseMetadata>
  </ListQueuesResponse>"""
  
  DELETE_QUEUE_RESPONSE = """<DeleteQueueResponse>
      <ResponseMetadata>
          <RequestId></RequestId>
      </ResponseMetadata>
  </DeleteQueueResponse>"""
  
  GET_QUEUE_ATTRIBUTES_RESPONSE = """<GetQueueAttributesResponse>
    <GetQueueAttributesResult>
      {% for key, value in queue.attributes.items() %}
          <Attribute>
            <Name>{{ key }}</Name>
            <Value>{{ value }}</Value>
          </Attribute>
      {% endfor %}
    </GetQueueAttributesResult>
    <ResponseMetadata>
      <RequestId></RequestId>
    </ResponseMetadata>
  </GetQueueAttributesResponse>"""
  
  SET_QUEUE_ATTRIBUTE_RESPONSE = """<SetQueueAttributesResponse>
      <ResponseMetadata>
          <RequestId></RequestId>
      </ResponseMetadata>
  </SetQueueAttributesResponse>"""
  
  SEND_MESSAGE_RESPONSE = """<SendMessageResponse>
      <SendMessageResult>
          <MD5OfMessageBody>
              {{- message.body_md5 -}}
          </MD5OfMessageBody>
          {% if message.message_attributes.items()|count > 0 %}
          <MD5OfMessageAttributes>{{- message.attribute_md5 -}}</MD5OfMessageAttributes>
          {% endif %}
          <MessageId>
              {{- message.id -}}
          </MessageId>
      </SendMessageResult>
      <ResponseMetadata>
          <RequestId></RequestId>
      </ResponseMetadata>
  </SendMessageResponse>"""
  
  RECEIVE_MESSAGE_RESPONSE = """<ReceiveMessageResponse>
    <ReceiveMessageResult>
      {% for message in messages %}
          <Message>
            <MessageId>{{ message.id }}</MessageId>
            <ReceiptHandle>{{ message.receipt_handle }}</ReceiptHandle>
            <MD5OfBody>{{ message.body_md5 }}</MD5OfBody>
            <Body>{{ message.body }}</Body>
            <Attribute>
              <Name>SenderId</Name>
              <Value>{{ message.sender_id }}</Value>
            </Attribute>
            <Attribute>
              <Name>SentTimestamp</Name>
              <Value>{{ message.sent_timestamp }}</Value>
            </Attribute>
            <Attribute>
              <Name>ApproximateReceiveCount</Name>
              <Value>{{ message.approximate_receive_count }}</Value>
            </Attribute>
            <Attribute>
              <Name>ApproximateFirstReceiveTimestamp</Name>
              <Value>{{ message.approximate_first_receive_timestamp }}</Value>
            </Attribute>
            {% if message.deduplication_id is not none %}
            <Attribute>
              <Name>MessageDeduplicationId</Name>
              <Value>{{ message.deduplication_id }}</Value>
            </Attribute>
            {% endif %}
            {% if message.group_id is not none %}
            <Attribute>
              <Name>MessageGroupId</Name>
              <Value>{{ message.group_id }}</Value>
            </Attribute>
            {% endif %}
            {% if message.message_attributes.items()|count > 0 %}
            <MD5OfMessageAttributes>{{- message.attribute_md5 -}}</MD5OfMessageAttributes>
            {% endif %}
            {% for name, value in message.message_attributes.items() %}
              <MessageAttribute>
                <Name>{{ name }}</Name>
                <Value>
                  <DataType>{{ value.data_type }}</DataType>
                  {% if 'Binary' in value.data_type %}
                  <BinaryValue>{{ value.binary_value }}</BinaryValue>
                  {% else %}
                  <StringValue>{{ value.string_value }}</StringValue>
                  {% endif %}
                </Value>
              </MessageAttribute>
            {% endfor %}
          </Message>
      {% endfor %}
    </ReceiveMessageResult>
    <ResponseMetadata>
      <RequestId></RequestId>
    </ResponseMetadata>
  </ReceiveMessageResponse>"""
  
  SEND_MESSAGE_BATCH_RESPONSE = """<SendMessageBatchResponse>
  <SendMessageBatchResult>
      {% for message in messages %}
          <SendMessageBatchResultEntry>
              <Id>{{ message.user_id }}</Id>
              <MessageId>{{ message.id }}</MessageId>
              <MD5OfMessageBody>{{ message.body_md5 }}</MD5OfMessageBody>
              {% if message.message_attributes.items()|count > 0 %}
              <MD5OfMessageAttributes>{{- message.attribute_md5 -}}</MD5OfMessageAttributes>
              {% endif %}
          </SendMessageBatchResultEntry>
      {% endfor %}
  </SendMessageBatchResult>
  <ResponseMetadata>
      <RequestId></RequestId>
  </ResponseMetadata>
  </SendMessageBatchResponse>"""
  
  DELETE_MESSAGE_RESPONSE = """<DeleteMessageResponse>
      <ResponseMetadata>
          <RequestId></RequestId>
      </ResponseMetadata>
  </DeleteMessageResponse>"""
  
  DELETE_MESSAGE_BATCH_RESPONSE = """<DeleteMessageBatchResponse>
      <DeleteMessageBatchResult>
          {% for message_id in message_ids %}
              <DeleteMessageBatchResultEntry>
                  <Id>{{ message_id }}</Id>
              </DeleteMessageBatchResultEntry>
          {% endfor %}
      </DeleteMessageBatchResult>
      <ResponseMetadata>
          <RequestId></RequestId>
      </ResponseMetadata>
  </DeleteMessageBatchResponse>"""
  
  CHANGE_MESSAGE_VISIBILITY_RESPONSE = """<ChangeMessageVisibilityResponse>
      <ResponseMetadata>
          <RequestId></RequestId>
      </ResponseMetadata>
  </ChangeMessageVisibilityResponse>"""
  
  CHANGE_MESSAGE_VISIBILITY_BATCH_RESPONSE = """<ChangeMessageVisibilityBatchResponse>
      <ChangeMessageVisibilityBatchResult>
          {% for success_id in success %}
          <ChangeMessageVisibilityBatchResultEntry>
              <Id>{{ success_id }}</Id>
          </ChangeMessageVisibilityBatchResultEntry>
          {% endfor %}
          {% for error_dict in errors %}
          <BatchResultErrorEntry>
              <Id>{{ error_dict['Id'] }}</Id>
              <Code>{{ error_dict['Code'] }}</Code>
              <Message>{{ error_dict['Message'] }}</Message>
              <SenderFault>{{ error_dict['SenderFault'] }}</SenderFault>
          </BatchResultErrorEntry>
          {% endfor %}
      </ChangeMessageVisibilityBatchResult>
      <ResponseMetadata>
          <RequestId>{{ request_id }}</RequestId>
      </ResponseMetadata>
  </ChangeMessageVisibilityBatchResponse>"""
  
  PURGE_QUEUE_RESPONSE = """<PurgeQueueResponse>
      <ResponseMetadata>
          <RequestId></RequestId>
      </ResponseMetadata>
  </PurgeQueueResponse>"""
  
  LIST_DEAD_LETTER_SOURCE_QUEUES_RESPONSE = """<ListDeadLetterSourceQueuesResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/">
      <ListDeadLetterSourceQueuesResult>
          {% for queue in queues %}
          <QueueUrl>{{ queue.url(request_url) }}</QueueUrl>
          {% endfor %}
      </ListDeadLetterSourceQueuesResult>
      <ResponseMetadata>
          <RequestId>8ffb921f-b85e-53d9-abcf-d8d0057f38fc</RequestId>
      </ResponseMetadata>
  </ListDeadLetterSourceQueuesResponse>"""
  
  ADD_PERMISSION_RESPONSE = """<AddPermissionResponse>
      <ResponseMetadata>
          <RequestId>{{ request_id }}</RequestId>
      </ResponseMetadata>
  </AddPermissionResponse>"""
  
  REMOVE_PERMISSION_RESPONSE = """<RemovePermissionResponse>
      <ResponseMetadata>
          <RequestId>{{ request_id }}</RequestId>
      </ResponseMetadata>
  </RemovePermissionResponse>"""
  
  TAG_QUEUE_RESPONSE = """<TagQueueResponse>
     <ResponseMetadata>
        <RequestId>{{ request_id }}</RequestId>
     </ResponseMetadata>
  </TagQueueResponse>"""
  
  UNTAG_QUEUE_RESPONSE = """<UntagQueueResponse>
     <ResponseMetadata>
        <RequestId>{{ request_id }}</RequestId>
     </ResponseMetadata>
  </UntagQueueResponse>"""
  
  LIST_QUEUE_TAGS_RESPONSE = """<ListQueueTagsResponse>
     <ListQueueTagsResult>
        {% for key, value in tags.items() %}
        <Tag>
           <Key>{{ key }}</Key>
           <Value>{{ value }}</Value>
        </Tag>
        {% endfor %}
     </ListQueueTagsResult>
     <ResponseMetadata>
        <RequestId>{{ request_id }}</RequestId>
     </ResponseMetadata>
  </ListQueueTagsResponse>"""
  
  ERROR_TOO_LONG_RESPONSE = """<ErrorResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/">
      <Error>
          <Type>Sender</Type>
          <Code>InvalidParameterValue</Code>
          <Message>One or more parameters are invalid. Reason: Message must be shorter than 262144 bytes.</Message>
          <Detail/>
      </Error>
      <RequestId>6fde8d1e-52cd-4581-8cd9-c512f4c64223</RequestId>
  </ErrorResponse>"""
  
  ERROR_MAX_VISIBILITY_TIMEOUT_RESPONSE = "Invalid request, maximum visibility timeout is {0}".format(
      MAXIMUM_VISIBILTY_TIMEOUT)
  
  ERROR_INEXISTENT_QUEUE = """<ErrorResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/">
      <Error>
          <Type>Sender</Type>
          <Code>AWS.SimpleQueueService.NonExistentQueue</Code>
          <Message>The specified queue does not exist for this wsdl version.</Message>
          <Detail/>
      </Error>
      <RequestId>b8bc806b-fa6b-53b5-8be8-cfa2f9836bc3</RequestId>
  </ErrorResponse>"""
  
  ERROR_TEMPLATE = """<ErrorResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/">
      <Error>
          <Type>Sender</Type>
          <Code>{{ code }}</Code>
          <Message>{{ message }}</Message>
          <Detail/>
      </Error>
      <RequestId>6fde8d1e-52cd-4581-8cd9-c512f4c64223</RequestId>
  </ErrorResponse>"""
  