gcloud 0.0.7 → 0.1.0

data/packages/gsutil/boto/boto/s3/tagging.py

@@ -1,71 +0,0 @@
-from boto import handler
-import xml.sax
-
-
-class Tag(object):
-    def __init__(self, key=None, value=None):
-        self.key = key
-        self.value = value
-
-    def startElement(self, name, attrs, connection):
-        return None
-
-    def endElement(self, name, value, connection):
-        if name == 'Key':
-            self.key = value
-        elif name == 'Value':
-            self.value = value
-
-    def to_xml(self):
-        return '<Tag><Key>%s</Key><Value>%s</Value></Tag>' % (
-            self.key, self.value)
-
-    def __eq__(self, other):
-        return (self.key == other.key and self.value == other.value)
-
-
-class TagSet(list):
-    def startElement(self, name, attrs, connection):
-        if name == 'Tag':
-            tag = Tag()
-            self.append(tag)
-            return tag
-        return None
-
-    def endElement(self, name, value, connection):
-        setattr(self, name, value)
-
-    def add_tag(self, key, value):
-        tag = Tag(key, value)
-        self.append(tag)
-
-    def to_xml(self):
-        xml = '<TagSet>'
-        for tag in self:
-            xml += tag.to_xml()
-        xml += '</TagSet>'
-        return xml
-
-
-class Tags(list):
-    """A container for the tags associated with a bucket."""
-
-    def startElement(self, name, attrs, connection):
-        if name == 'TagSet':
-            tag_set = TagSet()
-            self.append(tag_set)
-            return tag_set
-        return None
-
-    def endElement(self, name, value, connection):
-        setattr(self, name, value)
-
-    def to_xml(self):
-        xml = '<Tagging>'
-        for tag_set in self:
-            xml += tag_set.to_xml()
-        xml +='</Tagging>'
-        return xml
-
-    def add_tag_set(self, tag_set):
-        self.append(tag_set)

data/packages/gsutil/boto/boto/s3/user.py

@@ -1,49 +0,0 @@
-# Copyright (c) 2006,2007 Mitch Garnaat http://garnaat.org/
-#
-# 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.
-
-class User:
-    def __init__(self, parent=None, id='', display_name=''):
-        if parent:
-            parent.owner = self
-        self.type = None
-        self.id = id
-        self.display_name = display_name
-
-    def startElement(self, name, attrs, connection):
-        return None
-
-    def endElement(self, name, value, connection):
-        if name == 'DisplayName':
-            self.display_name = value
-        elif name == 'ID':
-            self.id = value
-        else:
-            setattr(self, name, value)
-
-    def to_xml(self, element_name='Owner'):
-        if self.type:
-            s = '<%s xsi:type="%s">' % (element_name, self.type)
-        else:
-            s = '<%s>' % element_name
-        s += '<ID>%s</ID>' % self.id
-        s += '<DisplayName>%s</DisplayName>' % self.display_name
-        s += '</%s>' % element_name
-        return s        

data/packages/gsutil/boto/boto/s3/website.py

@@ -1,237 +0,0 @@
-# Copyright (c) 2013 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.
-#
-
-def tag(key, value):
-    start = '<%s>' % key
-    end = '</%s>' % key
-    return '%s%s%s' % (start, value, end)
-
-
-class WebsiteConfiguration(object):
-    """
-    Website configuration for a bucket.
-
-    :ivar suffix: Suffix that is appended to a request that is for a
-        "directory" on the website endpoint (e.g. if the suffix is
-        index.html and you make a request to samplebucket/images/
-        the data that is returned will be for the object with the
-        key name images/index.html).  The suffix must not be empty
-        and must not include a slash character.
-
-    :ivar error_key: The object key name to use when a 4xx class error
-        occurs.  This key identifies the page that is returned when
-        such an error occurs.
-
-    :ivar redirect_all_requests_to: Describes the redirect behavior for every
-        request to this bucket's website endpoint. If this value is non None,
-        no other values are considered when configuring the website
-        configuration for the bucket. This is an instance of
-        ``RedirectLocation``.
-
-    :ivar routing_rules: ``RoutingRules`` object which specifies conditions
-        and redirects that apply when the conditions are met.
-
-    """
-    WEBSITE_SKELETON = """<?xml version="1.0" encoding="UTF-8"?>
-      <WebsiteConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
-      %(body)s
-      </WebsiteConfiguration>"""
-
-
-    def __init__(self, suffix=None, error_key=None,
-                 redirect_all_requests_to=None, routing_rules=None):
-        self.suffix = suffix
-        self.error_key = error_key
-        self.redirect_all_requests_to = redirect_all_requests_to
-        self.routing_rules = routing_rules
-
-    def to_xml(self):
-        body_parts = []
-        if self.suffix is not None:
-            body_parts.append(tag('IndexDocument', tag('Suffix', self.suffix)))
-        if self.error_key is not None:
-            body_parts.append(tag('ErrorDocument', tag('Key', self.error_key)))
-        if self.redirect_all_requests_to is not None:
-            body_parts.append(self.redirect_all_requests_to.to_xml())
-        if self.routing_rules is not None:
-            body_parts.append(self.routing_rules.to_xml())
-        body = '\n'.join(body_parts)
-        return self.WEBSITE_SKELETON % {'body': body}
-
-
-class RedirectLocation(object):
-    """Specify redirect behavior for every request to a bucket's endpoint.
-
-    :ivar hostname: Name of the host where requests will be redirected.
-
-    :ivar protocol: Protocol to use (http, https) when redirecting requests.
-        The default is the protocol that is used in the original request.
-
-    """
-
-    def __init__(self, hostname, protocol=None):
-        self.hostname = hostname
-        self.protocol = protocol
-
-    def to_xml(self):
-        inner_text = []
-        if self.hostname is not None:
-            inner_text.append(tag('HostName', self.hostname))
-        if self.protocol is not None:
-            inner_text.append(tag('Protocol', self.protocol))
-        return tag('RedirectAllRequestsTo', '\n'.join(inner_text))
-
-
-class RoutingRules(object):
-    def __init__(self):
-        self._rules = []
-
-    def add_rule(self, rule):
-        """
-
-        :type rule: :class:`boto.s3.website.RoutingRule`
-        :param rule: A routing rule.
-
-        :return: This ``RoutingRules`` object is returned,
-            so that it can chain subsequent calls.
-
-        """
-        self._rules.append(rule)
-        return self
-
-    def to_xml(self):
-        inner_text = []
-        for rule in self._rules:
-            inner_text.append(rule.to_xml())
-        return tag('RoutingRules', '\n'.join(inner_text))
-
-
-class RoutingRule(object):
-    """Represents a single routing rule.
-
-    There are convenience methods to making creating rules
-    more concise::
-
-        rule = RoutingRule.when(key_prefix='foo/').then_redirect('example.com')
-
-    :ivar condition: Describes condition that must be met for the
-        specified redirect to apply.
-
-    :ivar redirect: Specifies redirect behavior.  You can redirect requests to
-        another host, to another page, or with another protocol. In the event
-        of an error, you can can specify a different error code to return.
-
-    """
-    def __init__(self, condition, redirect):
-        self.condition = condition
-        self.redirect = redirect
-
-    def to_xml(self):
-        return tag('RoutingRule',
-                   self.condition.to_xml() + self.redirect.to_xml())
-
-    @classmethod
-    def when(cls, key_prefix=None, http_error_code=None):
-        return cls(Condition(key_prefix=key_prefix,
-                             http_error_code=http_error_code), None)
-
-    def then_redirect(self, hostname=None, protocol=None, replace_key=None,
-                      replace_key_prefix=None, http_redirect_code=None):
-        self.redirect = Redirect(
-                hostname=hostname, protocol=protocol,
-                replace_key=replace_key,
-                replace_key_prefix=replace_key_prefix,
-                http_redirect_code=http_redirect_code)
-        return self
-
-
-class Condition(object):
-    """
-
-    :ivar key_prefix: The object key name prefix when the redirect is applied.
-        For example, to redirect requests for ExamplePage.html, the key prefix
-        will be ExamplePage.html. To redirect request for all pages with the
-        prefix docs/, the key prefix will be /docs, which identifies all
-        objects in the docs/ folder.
-
-    :ivar http_error_code: The HTTP error code when the redirect is applied. In
-        the event of an error, if the error code equals this value, then the
-        specified redirect is applied.
-
-    """
-    def __init__(self, key_prefix=None, http_error_code=None):
-        self.key_prefix = key_prefix
-        self.http_error_code = http_error_code
-
-    def to_xml(self):
-        inner_text = []
-        if self.key_prefix is not None:
-            inner_text.append(tag('KeyPrefixEquals', self.key_prefix))
-        if self.http_error_code is not None:
-            inner_text.append(
-                tag('HttpErrorCodeReturnedEquals',
-                self.http_error_code))
-        return tag('Condition', '\n'.join(inner_text))
-
-
-class Redirect(object):
-    """
-
-    :ivar hostname: The host name to use in the redirect request.
-
-    :ivar protocol: The protocol to use in the redirect request.  Can be either
-    'http' or 'https'.
-
-    :ivar replace_key: The specific object key to use in the redirect request.
-        For example, redirect request to error.html.
-
-    :ivar replace_key_prefix: The object key prefix to use in the redirect
-        request. For example, to redirect requests for all pages with prefix
-        docs/ (objects in the docs/ folder) to documents/, you can set a
-        condition block with KeyPrefixEquals set to docs/ and in the Redirect
-        set ReplaceKeyPrefixWith to /documents.
-
-    :ivar http_redirect_code: The HTTP redirect code to use on the response.
-
-    """
-    def __init__(self, hostname=None, protocol=None, replace_key=None,
-                 replace_key_prefix=None, http_redirect_code=None):
-        self.hostname = hostname
-        self.protocol = protocol
-        self.replace_key = replace_key
-        self.replace_key_prefix = replace_key_prefix
-        self.http_redirect_code = http_redirect_code
-
-    def to_xml(self):
-        inner_text = []
-        if self.hostname is not None:
-            inner_text.append(tag('HostName', self.hostname))
-        if self.protocol is not None:
-            inner_text.append(tag('Protocol', self.protocol))
-        if self.replace_key is not None:
-            inner_text.append(tag('ReplaceKeyWith', self.replace_key))
-        if self.replace_key_prefix is not None:
-            inner_text.append(tag('ReplaceKeyPrefixWith',
-                                  self.replace_key_prefix))
-        if self.http_redirect_code is not None:
-            inner_text.append(tag('HttpRedirectCode', self.http_redirect_code))
-        return tag('Redirect', '\n'.join(inner_text))

data/packages/gsutil/boto/boto/sdb/__init__.py

@@ -1,67 +0,0 @@
-# Copyright (c) 2006-2009 Mitch Garnaat http://garnaat.org/
-#
-# 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.
-#
-
-from .regioninfo import SDBRegionInfo
-
-
-def regions():
-    """
-    Get all available regions for the SDB service.
-
-    :rtype: list
-    :return: A list of :class:`boto.sdb.regioninfo.RegionInfo` instances
-    """
-    return [SDBRegionInfo(name='us-east-1',
-                          endpoint='sdb.amazonaws.com'),
-            SDBRegionInfo(name='eu-west-1',
-                          endpoint='sdb.eu-west-1.amazonaws.com'),
-            SDBRegionInfo(name='us-west-1',
-                          endpoint='sdb.us-west-1.amazonaws.com'),
-            SDBRegionInfo(name='sa-east-1',
-                          endpoint='sdb.sa-east-1.amazonaws.com'),
-            SDBRegionInfo(name='us-west-2',
-                          endpoint='sdb.us-west-2.amazonaws.com'),
-            SDBRegionInfo(name='ap-northeast-1',
-                          endpoint='sdb.ap-northeast-1.amazonaws.com'),
-            SDBRegionInfo(name='ap-southeast-1',
-                          endpoint='sdb.ap-southeast-1.amazonaws.com'),
-            SDBRegionInfo(name='ap-southeast-2',
-                          endpoint='sdb.ap-southeast-2.amazonaws.com')
-            ]
-
-
-def connect_to_region(region_name, **kw_params):
-    """
-    Given a valid region name, return a
-    :class:`boto.sdb.connection.SDBConnection`.
-
-    :type: str
-    :param region_name: The name of the region to connect to.
-
-    :rtype: :class:`boto.sdb.connection.SDBConnection` or ``None``
-    :return: A connection to the given region, or None if an invalid region
-             name is given
-    """
-    for region in regions():
-        if region.name == region_name:
-            return region.connect(**kw_params)
-    return None

data/packages/gsutil/boto/boto/sdb/connection.py

@@ -1,617 +0,0 @@
-# Copyright (c) 2006,2007 Mitch Garnaat http://garnaat.org/
-#
-# 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 xml.sax
-import threading
-import boto
-from boto import handler
-from boto.connection import AWSQueryConnection
-from boto.sdb.domain import Domain, DomainMetaData
-from boto.sdb.item import Item
-from boto.sdb.regioninfo import SDBRegionInfo
-from boto.exception import SDBResponseError
-
-class ItemThread(threading.Thread):
-    """
-    A threaded :class:`Item <boto.sdb.item.Item>` retriever utility class.
-    Retrieved :class:`Item <boto.sdb.item.Item>` objects are stored in the
-    ``items`` instance variable after :py:meth:`run() <run>` is called.
-
-    .. tip:: The item retrieval will not start until
-        the :func:`run() <boto.sdb.connection.ItemThread.run>` method is called.
-    """
-    def __init__(self, name, domain_name, item_names):
-        """
-        :param str name: A thread name. Used for identification.
-        :param str domain_name: The name of a SimpleDB
-            :class:`Domain <boto.sdb.domain.Domain>`
-        :type item_names: string or list of strings
-        :param item_names: The name(s) of the items to retrieve from the specified
-            :class:`Domain <boto.sdb.domain.Domain>`.
-        :ivar list items: A list of items retrieved. Starts as empty list.
-        """
-        threading.Thread.__init__(self, name=name)
-        #print 'starting %s with %d items' % (name, len(item_names))
-        self.domain_name = domain_name
-        self.conn = SDBConnection()
-        self.item_names = item_names
-        self.items = []
-
-    def run(self):
-        """
-        Start the threaded retrieval of items. Populates the
-        ``items`` list with :class:`Item <boto.sdb.item.Item>` objects.
-        """
-        for item_name in self.item_names:
-            item = self.conn.get_attributes(self.domain_name, item_name)
-            self.items.append(item)
-
-#boto.set_stream_logger('sdb')
-
-class SDBConnection(AWSQueryConnection):
-    """
-    This class serves as a gateway to your SimpleDB region (defaults to
-    us-east-1). Methods within allow access to SimpleDB
-    :class:`Domain <boto.sdb.domain.Domain>` objects and their associated
-    :class:`Item <boto.sdb.item.Item>` objects.
-
-    .. tip::
-        While you may instantiate this class directly, it may be easier to
-        go through :py:func:`boto.connect_sdb`.
-    """
-    DefaultRegionName = 'us-east-1'
-    DefaultRegionEndpoint = 'sdb.us-east-1.amazonaws.com'
-    APIVersion = '2009-04-15'
-    ResponseError = SDBResponseError
-
-    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='/',
-                 converter=None, security_token=None, validate_certs=True):
-        """
-        For any keywords that aren't documented, refer to the parent class,
-        :py:class:`boto.connection.AWSAuthConnection`. You can avoid having
-        to worry about these keyword arguments by instantiating these objects
-        via :py:func:`boto.connect_sdb`.
-
-        :type region: :class:`boto.sdb.regioninfo.SDBRegionInfo`
-        :keyword region: Explicitly specify a region. Defaults to ``us-east-1``
-            if not specified. You may also specify the region in your ``boto.cfg``:
-
-            .. code-block:: cfg
-
-                [SDB]
-                region = eu-west-1
-
-        """
-        if not region:
-            region_name = boto.config.get('SDB', 'region', self.DefaultRegionName)
-            for reg in boto.sdb.regions():
-                if reg.name == region_name:
-                    region = reg
-                    break
-
-        self.region = region
-        AWSQueryConnection.__init__(self, 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)
-        self.box_usage = 0.0
-        self.converter = converter
-        self.item_cls = Item
-
-    def _required_auth_capability(self):
-        return ['sdb']
-
-    def set_item_cls(self, cls):
-        """
-        While the default item class is :py:class:`boto.sdb.item.Item`, this
-        default may be overridden. Use this method to change a connection's
-        item class.
-
-        :param object cls: The new class to set as this connection's item
-            class. See the default item class for inspiration as to what your
-            replacement should/could look like.
-        """
-        self.item_cls = cls
-
-    def _build_name_value_list(self, params, attributes, replace=False,
-                              label='Attribute'):
-        keys = sorted(attributes.keys())
-        i = 1
-        for key in keys:
-            value = attributes[key]
-            if isinstance(value, list):
-                for v in value:
-                    params['%s.%d.Name' % (label, i)] = key
-                    if self.converter:
-                        v = self.converter.encode(v)
-                    params['%s.%d.Value' % (label, i)] = v
-                    if replace:
-                        params['%s.%d.Replace' % (label, i)] = 'true'
-                    i += 1
-            else:
-                params['%s.%d.Name' % (label, i)] = key
-                if self.converter:
-                    value = self.converter.encode(value)
-                params['%s.%d.Value' % (label, i)] = value
-                if replace:
-                    params['%s.%d.Replace' % (label, i)] = 'true'
-            i += 1
-
-    def _build_expected_value(self, params, expected_value):
-        params['Expected.1.Name'] = expected_value[0]
-        if expected_value[1] is True:
-            params['Expected.1.Exists'] = 'true'
-        elif expected_value[1] is False:
-            params['Expected.1.Exists'] = 'false'
-        else:
-            params['Expected.1.Value'] = expected_value[1]
-
-    def _build_batch_list(self, params, items, replace=False):
-        item_names = items.keys()
-        i = 0
-        for item_name in item_names:
-            params['Item.%d.ItemName' % i] = item_name
-            j = 0
-            item = items[item_name]
-            if item is not None:
-                attr_names = item.keys()
-                for attr_name in attr_names:
-                    value = item[attr_name]
-                    if isinstance(value, list):
-                        for v in value:
-                            if self.converter:
-                                v = self.converter.encode(v)
-                            params['Item.%d.Attribute.%d.Name' % (i, j)] = attr_name
-                            params['Item.%d.Attribute.%d.Value' % (i, j)] = v
-                            if replace:
-                                params['Item.%d.Attribute.%d.Replace' % (i, j)] = 'true'
-                            j += 1
-                    else:
-                        params['Item.%d.Attribute.%d.Name' % (i, j)] = attr_name
-                        if self.converter:
-                            value = self.converter.encode(value)
-                        params['Item.%d.Attribute.%d.Value' % (i, j)] = value
-                        if replace:
-                            params['Item.%d.Attribute.%d.Replace' % (i, j)] = 'true'
-                        j += 1
-            i += 1
-
-    def _build_name_list(self, params, attribute_names):
-        i = 1
-        attribute_names.sort()
-        for name in attribute_names:
-            params['Attribute.%d.Name' % i] = name
-            i += 1
-
-    def get_usage(self):
-        """
-        Returns the BoxUsage (in USD) accumulated on this specific SDBConnection
-        instance.
-
-        .. tip:: This can be out of date, and should only be treated as a
-            rough estimate. Also note that this estimate only applies to the
-            requests made on this specific connection instance. It is by
-            no means an account-wide estimate.
-
-        :rtype: float
-        :return: The accumulated BoxUsage of all requests made on the connection.
-        """
-        return self.box_usage
-
-    def print_usage(self):
-        """
-        Print the BoxUsage and approximate costs of all requests made on
-        this specific SDBConnection instance.
-
-        .. tip:: This can be out of date, and should only be treated as a
-            rough estimate. Also note that this estimate only applies to the
-            requests made on this specific connection instance. It is by
-            no means an account-wide estimate.
-        """
-        print 'Total Usage: %f compute seconds' % self.box_usage
-        cost = self.box_usage * 0.14
-        print 'Approximate Cost: $%f' % cost
-
-    def get_domain(self, domain_name, validate=True):
-        """
-        Retrieves a :py:class:`boto.sdb.domain.Domain` object whose name
-        matches ``domain_name``.
-
-        :param str domain_name: The name of the domain to retrieve
-        :keyword bool validate: When ``True``, check to see if the domain
-            actually exists. If ``False``, blindly return a
-            :py:class:`Domain <boto.sdb.domain.Domain>` object with the
-            specified name set.
-
-        :raises:
-            :py:class:`boto.exception.SDBResponseError` if ``validate`` is
-            ``True`` and no match could be found.
-
-        :rtype: :py:class:`boto.sdb.domain.Domain`
-        :return: The requested domain
-        """
-        domain = Domain(self, domain_name)
-        if validate:
-            self.select(domain, """select * from `%s` limit 1""" % domain_name)
-        return domain
-
-    def lookup(self, domain_name, validate=True):
-        """
-        Lookup an existing SimpleDB domain. This differs from
-        :py:meth:`get_domain` in that ``None`` is returned if ``validate`` is
-        ``True`` and no match was found (instead of raising an exception).
-
-        :param str domain_name: The name of the domain to retrieve
-
-        :param bool validate: If ``True``, a ``None`` value will be returned
-            if the specified domain can't be found. If ``False``, a
-            :py:class:`Domain <boto.sdb.domain.Domain>` object will be dumbly
-            returned, regardless of whether it actually exists.
-
-        :rtype: :class:`boto.sdb.domain.Domain` object or ``None``
-        :return: The Domain object or ``None`` if the domain does not exist.
-        """
-        try:
-            domain = self.get_domain(domain_name, validate)
-        except:
-            domain = None
-        return domain
-
-    def get_all_domains(self, max_domains=None, next_token=None):
-        """
-        Returns a :py:class:`boto.resultset.ResultSet` containing
-        all :py:class:`boto.sdb.domain.Domain` objects associated with
-        this connection's Access Key ID.
-
-        :keyword int max_domains: Limit the returned
-            :py:class:`ResultSet <boto.resultset.ResultSet>` to the specified
-            number of members.
-        :keyword str next_token: A token string that was returned in an
-            earlier call to this method as the ``next_token`` attribute
-            on the returned :py:class:`ResultSet <boto.resultset.ResultSet>`
-            object. This attribute is set if there are more than Domains than
-            the value specified in the ``max_domains`` keyword. Pass the
-            ``next_token`` value from you earlier query in this keyword to
-            get the next 'page' of domains.
-        """
-        params = {}
-        if max_domains:
-            params['MaxNumberOfDomains'] = max_domains
-        if next_token:
-            params['NextToken'] = next_token
-        return self.get_list('ListDomains', params, [('DomainName', Domain)])
-
-    def create_domain(self, domain_name):
-        """
-        Create a SimpleDB domain.
-
-        :type domain_name: string
-        :param domain_name: The name of the new domain
-
-        :rtype: :class:`boto.sdb.domain.Domain` object
-        :return: The newly created domain
-        """
-        params = {'DomainName':domain_name}
-        d = self.get_object('CreateDomain', params, Domain)
-        d.name = domain_name
-        return d
-
-    def get_domain_and_name(self, domain_or_name):
-        """
-        Given a ``str`` or :class:`boto.sdb.domain.Domain`, return a
-        ``tuple`` with the following members (in order):
-
-            * In instance of :class:`boto.sdb.domain.Domain` for the requested
-              domain
-            * The domain's name as a ``str``
-
-        :type domain_or_name: ``str`` or :class:`boto.sdb.domain.Domain`
-        :param domain_or_name: The domain or domain name to get the domain
-            and name for.
-
-        :raises: :class:`boto.exception.SDBResponseError` when an invalid
-            domain name is specified.
-
-        :rtype: tuple
-        :return: A ``tuple`` with contents outlined as per above.
-        """
-        if (isinstance(domain_or_name, Domain)):
-            return (domain_or_name, domain_or_name.name)
-        else:
-            return (self.get_domain(domain_or_name), domain_or_name)
-
-    def delete_domain(self, domain_or_name):
-        """
-        Delete a SimpleDB domain.
-
-        .. caution:: This will delete the domain and all items within the domain.
-
-        :type domain_or_name: string or :class:`boto.sdb.domain.Domain` object.
-        :param domain_or_name: Either the name of a domain or a Domain object
-
-        :rtype: bool
-        :return: True if successful
-
-        """
-        domain, domain_name = self.get_domain_and_name(domain_or_name)
-        params = {'DomainName':domain_name}
-        return self.get_status('DeleteDomain', params)
-
-    def domain_metadata(self, domain_or_name):
-        """
-        Get the Metadata for a SimpleDB domain.
-
-        :type domain_or_name: string or :class:`boto.sdb.domain.Domain` object.
-        :param domain_or_name: Either the name of a domain or a Domain object
-
-        :rtype: :class:`boto.sdb.domain.DomainMetaData` object
-        :return: The newly created domain metadata object
-        """
-        domain, domain_name = self.get_domain_and_name(domain_or_name)
-        params = {'DomainName':domain_name}
-        d = self.get_object('DomainMetadata', params, DomainMetaData)
-        d.domain = domain
-        return d
-
-    def put_attributes(self, domain_or_name, item_name, attributes,
-                       replace=True, expected_value=None):
-        """
-        Store attributes for a given item in a domain.
-
-        :type domain_or_name: string or :class:`boto.sdb.domain.Domain` object.
-        :param domain_or_name: Either the name of a domain or a Domain object
-
-        :type item_name: string
-        :param item_name: The name of the item whose attributes are being
-                          stored.
-
-        :type attribute_names: dict or dict-like object
-        :param attribute_names: The name/value pairs to store as attributes
-
-        :type expected_value: list
-        :param expected_value: If supplied, this is a list or tuple consisting
-            of a single attribute name and expected value. The list can be
-            of the form:
-
-                * ['name', 'value']
-
-            In which case the call will first verify that the attribute "name"
-            of this item has a value of "value".  If it does, the delete
-            will proceed, otherwise a ConditionalCheckFailed error will be
-            returned. The list can also be of the form:
-
-                * ['name', True|False]
-
-            which will simply check for the existence (True) or
-            non-existence (False) of the attribute.
-
-        :type replace: bool
-        :param replace: Whether the attribute values passed in will replace
-                        existing values or will be added as addition values.
-                        Defaults to True.
-
-        :rtype: bool
-        :return: True if successful
-        """
-        domain, domain_name = self.get_domain_and_name(domain_or_name)
-        params = {'DomainName' : domain_name,
-                  'ItemName' : item_name}
-        self._build_name_value_list(params, attributes, replace)
-        if expected_value:
-            self._build_expected_value(params, expected_value)
-        return self.get_status('PutAttributes', params)
-
-    def batch_put_attributes(self, domain_or_name, items, replace=True):
-        """
-        Store attributes for multiple items in a domain.
-
-        :type domain_or_name: string or :class:`boto.sdb.domain.Domain` object.
-        :param domain_or_name: Either the name of a domain or a Domain object
-
-        :type items: dict or dict-like object
-        :param items: A dictionary-like object.  The keys of the dictionary are
-                      the item names and the values are themselves dictionaries
-                      of attribute names/values, exactly the same as the
-                      attribute_names parameter of the scalar put_attributes
-                      call.
-
-        :type replace: bool
-        :param replace: Whether the attribute values passed in will replace
-                        existing values or will be added as addition values.
-                        Defaults to True.
-
-        :rtype: bool
-        :return: True if successful
-        """
-        domain, domain_name = self.get_domain_and_name(domain_or_name)
-        params = {'DomainName' : domain_name}
-        self._build_batch_list(params, items, replace)
-        return self.get_status('BatchPutAttributes', params, verb='POST')
-
-    def get_attributes(self, domain_or_name, item_name, attribute_names=None,
-                       consistent_read=False, item=None):
-        """
-        Retrieve attributes for a given item in a domain.
-
-        :type domain_or_name: string or :class:`boto.sdb.domain.Domain` object.
-        :param domain_or_name: Either the name of a domain or a Domain object
-
-        :type item_name: string
-        :param item_name: The name of the item whose attributes are
-            being retrieved.
-
-        :type attribute_names: string or list of strings
-        :param attribute_names: An attribute name or list of attribute names.
-            This parameter is optional.  If not supplied, all attributes will
-            be retrieved for the item.
-
-        :type consistent_read: bool
-        :param consistent_read: When set to true, ensures that the most recent
-            data is returned.
-
-        :type item: :class:`boto.sdb.item.Item`
-        :keyword item: Instead of instantiating a new Item object, you may
-            specify one to update.
-
-        :rtype: :class:`boto.sdb.item.Item`
-        :return: An Item with the requested attribute name/values set on it
-        """
-        domain, domain_name = self.get_domain_and_name(domain_or_name)
-        params = {'DomainName' : domain_name,
-                  'ItemName' : item_name}
-        if consistent_read:
-            params['ConsistentRead'] = 'true'
-        if attribute_names:
-            if not isinstance(attribute_names, list):
-                attribute_names = [attribute_names]
-            self.build_list_params(params, attribute_names, 'AttributeName')
-        response = self.make_request('GetAttributes', params)
-        body = response.read()
-        if response.status == 200:
-            if item == None:
-                item = self.item_cls(domain, item_name)
-            h = handler.XmlHandler(item, self)
-            xml.sax.parseString(body, h)
-            return item
-        else:
-            raise SDBResponseError(response.status, response.reason, body)
-
-    def delete_attributes(self, domain_or_name, item_name, attr_names=None,
-                          expected_value=None):
-        """
-        Delete attributes from a given item in a domain.
-
-        :type domain_or_name: string or :class:`boto.sdb.domain.Domain` object.
-        :param domain_or_name: Either the name of a domain or a Domain object
-
-        :type item_name: string
-        :param item_name: The name of the item whose attributes are being
-                          deleted.
-
-        :type attributes: dict, list or :class:`boto.sdb.item.Item`
-        :param attributes: Either a list containing attribute names which
-                           will cause all values associated with that attribute
-                           name to be deleted or a dict or Item containing the
-                           attribute names and keys and list of values to
-                           delete as the value.  If no value is supplied,
-                           all attribute name/values for the item will be
-                           deleted.
-
-        :type expected_value: list
-        :param expected_value: If supplied, this is a list or tuple consisting
-            of a single attribute name and expected value. The list can be
-            of the form:
-
-                * ['name', 'value']
-
-            In which case the call will first verify that the attribute "name"
-            of this item has a value of "value".  If it does, the delete
-            will proceed, otherwise a ConditionalCheckFailed error will be
-            returned. The list can also be of the form:
-
-                * ['name', True|False]
-
-            which will simply check for the existence (True) or
-            non-existence (False) of the attribute.
-
-        :rtype: bool
-        :return: True if successful
-        """
-        domain, domain_name = self.get_domain_and_name(domain_or_name)
-        params = {'DomainName':domain_name,
-                  'ItemName' : item_name}
-        if attr_names:
-            if isinstance(attr_names, list):
-                self._build_name_list(params, attr_names)
-            elif isinstance(attr_names, dict) or isinstance(attr_names, self.item_cls):
-                self._build_name_value_list(params, attr_names)
-        if expected_value:
-            self._build_expected_value(params, expected_value)
-        return self.get_status('DeleteAttributes', params)
-
-    def batch_delete_attributes(self, domain_or_name, items):
-        """
-        Delete multiple items in a domain.
-
-        :type domain_or_name: string or :class:`boto.sdb.domain.Domain` object.
-        :param domain_or_name: Either the name of a domain or a Domain object
-
-        :type items: dict or dict-like object
-        :param items: A dictionary-like object.  The keys of the dictionary are
-            the item names and the values are either:
-
-                * dictionaries of attribute names/values, exactly the
-                  same as the attribute_names parameter of the scalar
-                  put_attributes call.  The attribute name/value pairs
-                  will only be deleted if they match the name/value
-                  pairs passed in.
-                * None which means that all attributes associated
-                  with the item should be deleted.
-
-        :return: True if successful
-        """
-        domain, domain_name = self.get_domain_and_name(domain_or_name)
-        params = {'DomainName' : domain_name}
-        self._build_batch_list(params, items, False)
-        return self.get_status('BatchDeleteAttributes', params, verb='POST')
-
-    def select(self, domain_or_name, query='', next_token=None,
-               consistent_read=False):
-        """
-        Returns a set of Attributes for item names within domain_name that
-        match the query.  The query must be expressed in using the SELECT
-        style syntax rather than the original SimpleDB query language.
-        Even though the select request does not require a domain object,
-        a domain object must be passed into this method so the Item objects
-        returned can point to the appropriate domain.
-
-        :type domain_or_name: string or :class:`boto.sdb.domain.Domain` object
-        :param domain_or_name: Either the name of a domain or a Domain object
-
-        :type query: string
-        :param query: The SimpleDB query to be performed.
-
-        :type consistent_read: bool
-        :param consistent_read: When set to true, ensures that the most recent
-                                data is returned.
-
-        :rtype: ResultSet
-        :return: An iterator containing the results.
-        """
-        domain, domain_name = self.get_domain_and_name(domain_or_name)
-        params = {'SelectExpression' : query}
-        if consistent_read:
-            params['ConsistentRead'] = 'true'
-        if next_token:
-            params['NextToken'] = next_token
-        try:
-            return self.get_list('Select', params, [('Item', self.item_cls)],
-                             parent=domain)
-        except SDBResponseError, e:
-            e.body = "Query: %s\n%s" % (query, e.body)
-            raise e