api.py

# -*- coding: utf-8 -*-

"""
文件上传方法中的data参数
------------------------
诸如 :func:`put_object <Bucket.put_object>` 这样的上传接口都会有 `data` 参数用于接收用户数据。`data` 可以是下述类型
    - unicode类型（对于Python3则是str类型）：内部会自动转换为UTF-8的bytes
    - bytes类型：不做任何转换
    - file-like object：对于可以seek和tell的file object，从当前位置读取直到结束。其他类型，请确保当前位置是文件开始。
    - 可迭代类型：对于无法探知长度的数据，要求一定是可迭代的。此时会通过Chunked Encoding传输。

Bucket配置修改方法中的input参数
-----------------------------
诸如 :func:`put_bucket_cors <Bucket.put_bucket_cors>` 这样的Bucket配置修改接口都会有 `input` 参数接收用户提供的配置数据。
`input` 可以是下述类型
  - Bucket配置信息相关的类，如 `BucketCors`
  - unicode类型（对于Python3则是str类型）
  - 经过utf-8编码的bytes类型
  - file-like object
  - 可迭代类型，会通过Chunked Encoding传输
也就是说 `input` 参数可以比 `data` 参数多接受第一种类型的输入。

返回值
------
:class:`Service` 和 :class:`Bucket` 类的大多数方法都是返回 :class:`RequestResult <oss2.models.RequestResult>`
及其子类。`RequestResult` 包含了HTTP响应的状态码、头部以及OSS Request ID，而它的子类则包含用户真正想要的结果。例如，
`ListBucketsResult.buckets` 就是返回的Bucket信息列表；`GetObjectResult` 则是一个file-like object，可以调用 `read()` 来获取响应的
HTTP包体。

:class:`CryptoBucket`:
加密接口
-------
CryptoBucket仅提供上传下载加密数据的接口，诸如`get_object` 、 `put_object` ，返回值与Bucket相应接口一致。


异常
----
一般来说Python SDK可能会抛出三种类型的异常，这些异常都继承于 :class:`OssError <oss2.exceptions.OssError>` ：
    - :class:`ClientError <oss2.exceptions.ClientError>` ：由于用户参数错误而引发的异常；
    - :class:`ServerError <oss2.exceptions.ServerError>` 及其子类：OSS服务器返回非成功的状态码，如4xx或5xx；
    - :class:`RequestError <oss2.exceptions.RequestError>` ：底层requests库抛出的异常，如DNS解析错误，超时等；
当然，`Bucket.put_object_from_file` 和 `Bucket.get_object_to_file` 这类函数还会抛出文件相关的异常。


.. _byte_range:

指定下载范围
------------
诸如 :func:`get_object <Bucket.get_object>` 以及 :func:`upload_part_copy <Bucket.upload_part_copy>` 这样的函数，可以接受
`byte_range` 参数，表明读取数据的范围。该参数是一个二元tuple：(start, last)。这些接口会把它转换为Range头部的值，如：
    - byte_range 为 (0, 99) 转换为 'bytes=0-99'，表示读取前100个字节
    - byte_range 为 (None, 99) 转换为 'bytes=-99'，表示读取最后99个字节
    - byte_range 为 (100, None) 转换为 'bytes=100-'，表示读取第101个字节到文件结尾的部分（包含第101个字节）


分页罗列
-------
罗列各种资源的接口，如 :func:`list_buckets <Service.list_buckets>` 、 :func:`list_objects <Bucket.list_objects>` 都支持
分页查询。通过设定分页标记（如：`marker` 、 `key_marker` ）的方式可以指定查询某一页。首次调用将分页标记设为空（缺省值，可以不设），
后续的调用使用返回值中的 `next_marker` 、 `next_key_marker` 等。每次调用后检查返回值中的 `is_truncated` ，其值为 `False` 说明
已经到了最后一页。

.. _line_range:

指定查询CSV文件范围
------------
诸如 :func:`select_object <Bucket.select_object>` 以及 :func:`select_object_to_file <Bucket.select_object_to_file>` 这样的函数的select_csv_params参数，可以接受
`LineRange` 参数，表明读取CSV数据的范围。该参数是一个二元tuple：(start, last):
    - LineRange 为 (0, 99) 表示读取前100行
    - LineRange 为 (None, 99) 表示读取最后99行
    - LineRange 为 (100, None) 表示读取第101行到文件结尾的部分（包含第101行）

.. _split_range:

指定查询CSV文件范围
------------
split可以认为是切分好的大小大致相等的csv行簇。每个Split大小大致相等，这样以便更好的做到负载均衡。
诸如 :func:`select_object <Bucket.select_object>` 以及 :func:`select_object_to_file <Bucket.select_object_to_file>` 这样的函数的select_csv_params参数，可以接受
`SplitRange` 参数，表明读取CSV数据的范围。该参数是一个二元tuple：(start, last):
    - SplitRange 为 (0, 9) 表示读取前10个Split
    - SplitRange 为 (None, 9) 表示读取最后9个split
    - SplitRange 为 (10, None) 表示读取第11个split到文件结尾的部分（包含第11个Split）

分页查询
-------
和create_csv_object_meta配合使用，有两种方法：
    - 方法1：先获取文件总的行数(create_csv_object_meta返回)，然后把文件以line_range分成若干部分并行查询
    - 方法2：先获取文件总的Split数(create_csv_object_meta返回), 然后把文件分成若干个请求，每个请求含有大致相等的Split

.. _progress_callback:

上传下载进度
-----------
上传下载接口，诸如 `get_object` 、 `put_object` 、`resumable_upload`，都支持进度回调函数，可以用它实现进度条等功能。

`progress_callback` 的函数原型如下 ::

    def progress_callback(bytes_consumed, total_bytes):
        '''进度回调函数。

        :param int bytes_consumed: 已经消费的字节数。对于上传，就是已经上传的量；对于下载，就是已经下载的量。
        :param int total_bytes: 总长度。
        '''

其中 `total_bytes` 对于上传和下载有不同的含义：
    - 上传：当输入是bytes或可以seek/tell的文件对象，那么它的值就是总的字节数；否则，其值为None
    - 下载：当返回的HTTP相应中有Content-Length头部，那么它的值就是Content-Length的值；否则，其值为None


.. _unix_time:

Unix Time
---------
OSS Python SDK会把从服务器获得时间戳都转换为自1970年1月1日UTC零点以来的秒数，即Unix Time。
参见 `Unix Time <https://en.wikipedia.org/wiki/Unix_time>`_

OSS中常用的时间格式有
    - HTTP Date格式，形如 `Sat, 05 Dec 2015 11:04:39 GMT` 这样的GMT时间。
      用在If-Modified-Since、Last-Modified这些HTTP请求、响应头里。
    - ISO8601格式，形如 `2015-12-05T00:00:00.000Z`。
      用在生命周期管理配置、列举Bucket结果中的创建时间、列举文件结果中的最后修改时间等处。

`http_date` 函数把Unix Time转换为HTTP Date；而 `http_to_unixtime` 则做相反的转换。如 ::

    >>> import oss2, time
    >>> unix_time = int(time.time())             # 当前UNIX Time，设其值为 1449313829
    >>> date_str = oss2.http_date(unix_time)     # 得到 'Sat, 05 Dec 2015 11:10:29 GMT'
    >>> oss2.http_to_unixtime(date_str)          # 得到 1449313829

.. note::

    生成HTTP协议所需的日期（即HTTP Date）时，请使用 `http_date` ， 不要使用 `strftime` 这样的函数。因为后者是和locale相关的。
    比如，`strftime` 结果中可能会出现中文，而这样的格式，OSS服务器是不能识别的。

`iso8601_to_unixtime` 把ISO8601格式转换为Unix Time；`date_to_iso8601` 和 `iso8601_to_date` 则在ISO8601格式的字符串和
datetime.date之间相互转换。如 ::

    >>> import oss2
    >>> d = oss2.iso8601_to_date('2015-12-05T00:00:00.000Z')  # 得到 datetime.date(2015, 12, 5)
    >>> date_str = oss2.date_to_iso8601(d)                    # 得到 '2015-12-05T00:00:00.000Z'
    >>> oss2.iso8601_to_unixtime(date_str)                    # 得到 1449273600

.. _select_params:

    指定OSS Select的文件格式。
    对于Csv文件，支持如下Keys:
    >>> CsvHeaderInfo: None|Use|Ignore   #None表示没有CSV Schema头，Use表示启用CSV Schema头，可以在Select语句中使用Name，Ignore表示有CSV Schema头，但忽略它（Select语句中不可以使用Name)
                        默认值是None
    >>> CommentCharacter: Comment字符,默认值是#,不支持多个字符
    >>> RecordDelimiter: 行分隔符，默认是\n,最多支持两个字符分隔符（比如:\r\n)
    >>> FieldDelimiter: 列分隔符，默认是逗号(,), 不支持多个字符
    >>> QuoteCharacter: 列Quote字符，默认是双引号("),不支持多个字符。注意转义符合Quote字符相同。
    >>> LineRange: 指定查询CSV文件的行范围，参见 `line_range`。
    >>> SplitRange: 指定查询CSV文件的Split范围，参见 `split_range`.
        注意LineRange和SplitRange两种不能同时指定。若同时指定LineRange会被忽略。
    >>> CompressionType: 文件的压缩格式，默认值是None, 支持GZIP。
    >>> OutputRawData: 指定是响应Body返回Raw数据，默认值是False.
    >>> SkipPartialDataRecord: 当CSV行数据不完整时(select语句中出现的列在该行为空)，是否跳过该行。默认是False。
    >>> OutputHeader:是否输出CSV Header，默认是False.
    >>> EnablePayloadCrc:是否启用对Payload的CRC校验,默认是False. 该选项不能和OutputRawData:True混用。
    >>> MaxSkippedRecordsAllowed: 允许跳过的最大行数。默认值是0表示一旦有一行跳过就报错。当下列两种情况下该行CSV被跳过:1）当SkipPartialDataRecord为True时且该行不完整时 2）当该行的数据类型和SQL不匹配时
    对于Json 文件, 支持如下Keys:
    >>> Json_Type: DOCUMENT | LINES . DOCUMENT就是指一般的Json文件，LINES是指每一行是一个合法的JSON对象，文件由多行Json对象组成，整个文件本身不是合法的Json对象。
    >>> LineRange: 指定查询JSON LINE文件的行范围，参见 `line_range`。注意该参数仅支持LINES类型
    >>> SplitRange: 指定查询JSON LINE文件的Split范围，参见 `split_range`.注意该参数仅支持LINES类型
    >>> CompressionType: 文件的压缩格式，默认值是None, 支持GZIP。
    >>> OutputRawData: 指定是响应Body返回Raw数据，默认值是False. 
    >>> SkipPartialDataRecord: 当一条JSON记录数据不完整时(select语句中出现的Key在该对象为空)，是否跳过该Json记录。默认是False。
    >>> EnablePayloadCrc:是否启用对Payload的CRC校验,默认是False. 该选项不能和OutputRawData:True混用。
    >>> MaxSkippedRecordsAllowed: 允许跳过的最大Json记录数。默认值是0表示一旦有一条Json记录跳过就报错。当下列两种情况下该JSON被跳过:1）当SkipPartialDataRecord为True时且该条Json记录不完整时 2）当该记录的数据类型和SQL不匹配时
    >>> ParseJsonNumberAsString: 将Json文件中的数字解析成字符串。使用场景是当Json文件中的浮点数精度较高时，系统默认的浮点数精度无法达到要求，当解析成字符串时将完整保留原始数据精度，在Sql中使用Cast可以将字符串无精度损失地转成decimal.
    >>> AllowQuotedRecordDelimiter: 允许CSV中的列包含转义过的换行符。默认为true。当值为False时，select API可以用Range：bytes来设置选取目标对象内容的范围
    ‘
.. _select_meta_params:

    create_select_object_meta参数集合，支持如下Keys:
    - RecordDelimiter: CSV换行符，最多支持两个字符
    - FieldDelimiter: CSV列分隔符，最多支持一个字符
    - QuoteCharacter: CSV转移Quote符，最多支持一个字符
    - OverwriteIfExists: true|false. true表示重新获得csv meta，并覆盖原有的meta。一般情况下不需要使用

"""
import logging

from . import xml_utils
from . import http
from . import utils
from . import exceptions
from . import defaults
from . import models
from . import select_params

from .models import *
from .compat import urlquote, urlparse, to_unicode, to_string
from .headers import *
from .select_params import *

import time
import shutil

logger = logging.getLogger(__name__)


class _Base(object):
    def __init__(self, auth, endpoint, is_cname, session, connect_timeout,
                 app_name='', enable_crc=True, proxies=None, region=None, cloudbox_id= None, is_path_style=False, is_verify_object_strict=True):
        self.auth = auth
        self.endpoint = _normalize_endpoint(endpoint.strip())
        if utils.is_valid_endpoint(self.endpoint) is not True:
            raise ClientError('The endpoint you has specified is not valid, endpoint: {0}'.format(endpoint))
        self.session = session or http.Session()
        self.timeout = defaults.get(connect_timeout, defaults.connect_timeout)
        self.app_name = app_name
        self.enable_crc = enable_crc
        self.proxies = proxies
        self.region = region
        self.product = 'oss'
        self.cloudbox_id = cloudbox_id
        if self.cloudbox_id is not None:
            self.product = 'oss-cloudbox'
        self._make_url = _UrlMaker(self.endpoint, is_cname, is_path_style)
        self.is_verify_object_strict = is_verify_object_strict
        if hasattr(self.auth, 'auth_version') and self.auth.auth_version() != 'v1' :
            self.is_verify_object_strict = False

    def _do(self, method, bucket_name, key, **kwargs):
        key = to_string(key)
        req = http.Request(method, self._make_url(bucket_name, key),
                           app_name=self.app_name,
                           proxies=self.proxies,
                           region=self.region,
                           product=self.product,
                           cloudbox_id=self.cloudbox_id,
                           **kwargs)
        self.auth._sign_request(req, bucket_name, key)

        resp = self.session.do_request(req, timeout=self.timeout)
        if resp.status // 100 != 2:
            e = exceptions.make_exception(resp)
            logger.info("Exception: {0}".format(e))
            raise e

        # Note that connections are only released back to the pool for reuse once all body data has been read;
        # be sure to either set stream to False or read the content property of the Response object.
        # For more details, please refer to http://docs.python-requests.org/en/master/user/advanced/#keep-alive.
        content_length = models._hget(resp.headers, 'content-length', int)
        if content_length is not None and content_length == 0:
            resp.read()

        return resp

    def _do_url(self, method, sign_url, **kwargs):
        req = http.Request(method, sign_url, app_name=self.app_name, proxies=self.proxies, **kwargs)
        resp = self.session.do_request(req, timeout=self.timeout)
        if resp.status // 100 != 2:
            e = exceptions.make_exception(resp)
            logger.info("Exception: {0}".format(e))
            raise e

        # Note that connections are only released back to the pool for reuse once all body data has been read;
        # be sure to either set stream to False or read the content property of the Response object.
        # For more details, please refer to http://docs.python-requests.org/en/master/user/advanced/#keep-alive.
        content_length = models._hget(resp.headers, 'content-length', int)
        if content_length is not None and content_length == 0:
            resp.read()

        return resp

    @staticmethod
    def _parse_result(resp, parse_func, klass):
        result = klass(resp)
        parse_func(result, resp.read())
        return result


class Service(_Base):
    """用于Service操作的类，如罗列用户所有的Bucket。

    用法 ::

        >>> import oss2
        >>> auth = oss2.Auth('your-access-key-id', 'your-access-key-secret')
        >>> service = oss2.Service(auth, 'oss-cn-hangzhou.aliyuncs.com')
        >>> service.list_buckets()
        <oss2.models.ListBucketsResult object at 0x0299FAB0>

    :param auth: 包含了用户认证信息的Auth对象
    :type auth: oss2.Auth

    :param str endpoint: 访问域名，如杭州区域的域名为oss-cn-hangzhou.aliyuncs.com

    :param session: 会话。如果是None表示新开会话，非None则复用传入的会话
    :type session: oss2.Session

    :param float connect_timeout: 连接超时时间，以秒为单位。
    :param str app_name: 应用名。该参数不为空，则在User Agent中加入其值。
        注意到，最终这个字符串是要作为HTTP Header的值传输的，所以必须要遵循HTTP标准。
    """

    QOS_INFO = 'qosInfo'
    REGIONS = 'regions'
    WRITE_GET_OBJECT_RESPONSE = 'x-oss-write-get-object-response'

    def __init__(self, auth, endpoint,
                 session=None,
                 connect_timeout=None,
                 app_name='',
                 proxies=None,
                 region=None,
                 cloudbox_id=None,
                 is_path_style=False):
        logger.debug("Init oss service, endpoint: {0}, connect_timeout: {1}, app_name: {2}, proxies: {3}".format(
            endpoint, connect_timeout, app_name, proxies))
        super(Service, self).__init__(auth, endpoint, False, session, connect_timeout,
                                      app_name=app_name, proxies=proxies,
                                      region=region, cloudbox_id=cloudbox_id, is_path_style=is_path_style)

    def list_buckets(self, prefix='', marker='', max_keys=100, params=None, headers=None):
        """根据前缀罗列用户的Bucket。

        :param str prefix: 只罗列Bucket名为该前缀的Bucket，空串表示罗列所有的Bucket
        :param str marker: 分页标志。首次调用传空串，后续使用返回值中的next_marker
        :param int max_keys: 每次调用最多返回的Bucket数目
        :param dict params: list操作参数，传入'tag-key','tag-value'对结果进行过滤
        :param headers: 用户指定的HTTP头部。可以指定Content-Type、Content-MD5、x-oss-meta-开头的头部等。可以是dict，建议是oss2.CaseInsensitiveDict

        :return: 罗列的结果
        :rtype: oss2.models.ListBucketsResult
        """
        logger.debug("Start to list buckets, prefix: {0}, marker: {1}, max-keys: {2}".format(prefix, marker, max_keys))

        listParam = {}
        listParam['prefix'] = prefix
        listParam['marker'] = marker
        listParam['max-keys'] = str(max_keys)

        headers = http.CaseInsensitiveDict(headers)

        if params is not None:
            listParam.update(params)

        resp = self._do('GET', '', '', params=listParam, headers=headers)
        logger.debug("List buckets done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_list_buckets, ListBucketsResult)

    def get_user_qos_info(self):
        """获取User的QoSInfo
        :return: :class:`GetUserQosInfoResult <oss2.models.GetUserQosInfoResult>`
        """
        logger.debug("Start to get user qos info.")
        resp = self._do('GET', '', '', params={Service.QOS_INFO: ''})
        logger.debug("get use qos, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_get_qos_info, GetUserQosInfoResult)

    def describe_regions(self, regions=''):
        """查询所有支持地域或者指定地域对应的Endpoint信息，包括外网Endpoint、内网Endpoint和传输加速Endpoint。

        :param str regions : 地域。
        :return: :class:`DescribeRegionsResult <oss2.models.DescribeRegionsResult>`
        """
        logger.debug("Start to describe regions")

        resp = self._do('GET', '', '', params={Service.REGIONS: regions})
        logger.debug("Describe regions done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_describe_regions, DescribeRegionsResult)

    def write_get_object_response(self, route, token, fwd_status, data, headers=None):
        """write get object response.
        :param route: fc return route
        :param token: fc return token
        :param fwd_status: fwd_status

        :param data: 待上传的内容。
        :type data: bytes，str或file-like object

        :param headers: 用户指定的HTTP头部。可以指定Content-Type、Content-MD5、x-oss-meta-开头的头部等
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """

        logger.debug("Start to write get object response, headers: {0}".format(headers))

        headers = http.CaseInsensitiveDict(headers)

        if route:
            headers['x-oss-request-route'] = route
        if token:
            headers['x-oss-request-token'] = token
        if fwd_status:
            headers['x-oss-fwd-status'] = fwd_status

        resp = self._do('POST', '', '', params={Service.WRITE_GET_OBJECT_RESPONSE: ''}, headers=headers, data=data)
        logger.debug("write get object response done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

class Bucket(_Base):
    """用于Bucket和Object操作的类，诸如创建、删除Bucket，上传、下载Object等。

    用法（假设Bucket属于杭州区域） ::

        >>> import oss2
        >>> auth = oss2.Auth('your-access-key-id', 'your-access-key-secret')
        >>> bucket = oss2.Bucket(auth, 'http://oss-cn-hangzhou.aliyuncs.com', 'your-bucket')
        >>> bucket.put_object('readme.txt', 'content of the object')
        <oss2.models.PutObjectResult object at 0x029B9930>

    :param auth: 包含了用户认证信息的Auth对象
    :type auth: oss2.Auth

    :param str endpoint: 访问域名或者CNAME
    :param str bucket_name: Bucket名
    :param bool is_cname: 如果endpoint是CNAME则设为True；反之，则为False。

    :param session: 会话。如果是None表示新开会话，非None则复用传入的会话
    :type session: oss2.Session

    :param float connect_timeout: 连接超时时间，以秒为单位。

    :param str app_name: 应用名。该参数不为空，则在User Agent中加入其值。
        注意到，最终这个字符串是要作为HTTP Header的值传输的，所以必须要遵循HTTP标准。

    :param bool is_verify_object_strict: 严格验证对象名称的标志。默认为True。
    """

    ACL = 'acl'
    CORS = 'cors'
    LIFECYCLE = 'lifecycle'
    LOCATION = 'location'
    LOGGING = 'logging'
    REFERER = 'referer'
    WEBSITE = 'website'
    LIVE = 'live'
    COMP = 'comp'
    STATUS = 'status'
    VOD = 'vod'
    SYMLINK = 'symlink'
    STAT = 'stat'
    BUCKET_INFO = 'bucketInfo'
    PROCESS = 'x-oss-process'
    TAGGING = 'tagging'
    ENCRYPTION = 'encryption'
    VERSIONS = 'versions'
    VERSIONING = 'versioning'
    VERSIONID = 'versionId'
    RESTORE = 'restore'
    OBJECTMETA = 'objectMeta'
    POLICY = 'policy'
    REQUESTPAYMENT  = 'requestPayment'
    QOS_INFO = 'qosInfo'
    USER_QOS = 'qos'
    ASYNC_FETCH = 'asyncFetch'
    SEQUENTIAL = 'sequential'
    INVENTORY = "inventory"
    INVENTORY_CONFIG_ID = "inventoryId"
    CONTINUATION_TOKEN = "continuation-token"
    WORM = "worm"
    WORM_ID = "wormId"
    WORM_EXTEND = "wormExtend"
    REPLICATION = "replication"
    REPLICATION_LOCATION = 'replicationLocation'
    REPLICATION_PROGRESS = 'replicationProgress'
    TRANSFER_ACCELERATION = 'transferAcceleration'
    CNAME = 'cname'
    META_QUERY = 'metaQuery'
    ACCESS_MONITOR = 'accessmonitor'
    RESOURCE_GROUP = 'resourceGroup'
    STYLE = 'style'
    STYLE_NAME = 'styleName'
    ASYNC_PROCESS = 'x-oss-async-process'
    CALLBACK = 'callback'


    def __init__(self, auth, endpoint, bucket_name,
                 is_cname=False,
                 session=None,
                 connect_timeout=None,
                 app_name='',
                 enable_crc=True,
                 proxies=None,
                 region=None,
                 cloudbox_id=None,
                 is_path_style=False,
                 is_verify_object_strict=True):
        logger.debug("Init Bucket: {0}, endpoint: {1}, isCname: {2}, connect_timeout: {3}, app_name: {4}, enabled_crc: {5}, region: {6}"
                     ", proxies: {6}".format(bucket_name, endpoint, is_cname, connect_timeout, app_name, enable_crc, proxies, region))
        super(Bucket, self).__init__(auth, endpoint, is_cname, session, connect_timeout, 
                                     app_name=app_name, enable_crc=enable_crc, proxies=proxies,
                                     region=region, cloudbox_id=cloudbox_id, is_path_style=is_path_style, is_verify_object_strict=is_verify_object_strict)

        self.bucket_name = bucket_name.strip()
        if utils.is_valid_bucket_name(self.bucket_name) is not True:
            raise ClientError("The bucket_name is invalid, please check it.")

    def sign_url(self, method, key, expires, headers=None, params=None, slash_safe=False):
        """生成签名URL。

        常见的用法是生成加签的URL以供授信用户下载，如为log.jpg生成一个5分钟后过期的下载链接::

            >>> bucket.sign_url('GET', 'log.jpg', 5 * 60)
            r'http://your-bucket.oss-cn-hangzhou.aliyuncs.com/logo.jpg?OSSAccessKeyId=YourAccessKeyId\&Expires=1447178011&Signature=UJfeJgvcypWq6Q%2Bm3IJcSHbvSak%3D'

        :param method: HTTP方法，如'GET'、'PUT'、'DELETE'等
        :type method: str
        :param key: 文件名
        :param expires: 过期时间（单位：秒），链接在当前时间再过expires秒后过期

        :param headers: 需要签名的HTTP头部，如名称以x-oss-meta-开头的头部（作为用户自定义元数据）、
            Content-Type头部等。对于下载，不需要填。
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :param params: 需要签名的HTTP查询参数

        :param slash_safe: 是否开启key名称中的‘/’转义保护，如果不开启'/'将会转义成%2F
        :type slash_safe: bool

        :return: 签名URL。
        """
        if key is None or len(key.strip()) <= 0:
            raise ClientError("The key is invalid, please check it.")
        key = to_string(key)

        if self.is_verify_object_strict and key.startswith('?'):
            raise ClientError("The key cannot start with `?`, please check it.")

        logger.debug(
            "Start to sign_url, method: {0}, bucket: {1}, key: {2}, expires: {3}, headers: {4}, params: {5}, slash_safe: {6}".format(
                method, self.bucket_name, to_string(key), expires, headers, params, slash_safe))
        req = http.Request(method, self._make_url(self.bucket_name, key, slash_safe),
                           headers=headers,
                           params=params,
                           region=self.region,
                           product=self.product,
                           cloudbox_id=self.cloudbox_id)
        return self.auth._sign_url(req, self.bucket_name, key, expires)

    def sign_rtmp_url(self, channel_name, playlist_name, expires):
        """生成RTMP推流的签名URL。
        常见的用法是生成加签的URL以供授信用户向OSS推RTMP流。

        :param channel_name: 直播频道的名称
        :param expires: 过期时间（单位：秒），链接在当前时间再过expires秒后过期
        :param playlist_name: 播放列表名称，注意与创建live channel时一致
        :param params: 需要签名的HTTP查询参数

        :return: 签名URL。
        """
        logger.debug("Sign RTMP url, bucket: {0}, channel_name: {1}, playlist_name: {2}, expires: {3}".format(
            self.bucket_name, channel_name, playlist_name, expires))
        url = self._make_url(self.bucket_name, 'live').replace('http://', 'rtmp://').replace(
            'https://', 'rtmp://') + '/' + channel_name
        params = {}
        if playlist_name is not None and playlist_name != "":
            params['playlistName'] = playlist_name
        return self.auth._sign_rtmp_url(url, self.bucket_name, channel_name, expires, params)

    def list_objects(self, prefix='', delimiter='', marker='', max_keys=100, headers=None):
        """根据前缀罗列Bucket里的文件。

        :param str prefix: 只罗列文件名为该前缀的文件
        :param str delimiter: 分隔符。可以用来模拟目录
        :param str marker: 分页标志。首次调用传空串，后续使用返回值的next_marker
        :param int max_keys: 最多返回文件的个数，文件和目录的和不能超过该值

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`ListObjectsResult <oss2.models.ListObjectsResult>`
        """
        headers = http.CaseInsensitiveDict(headers)
        logger.debug(
            "Start to List objects, bucket: {0}, prefix: {1}, delimiter: {2}, marker: {3}, max-keys: {4}".format(
                self.bucket_name, to_string(prefix), delimiter, to_string(marker), max_keys))
        resp = self.__do_bucket('GET',
                                params={'prefix': prefix,
                                        'delimiter': delimiter,
                                        'marker': marker,
                                        'max-keys': str(max_keys),
                                        'encoding-type': 'url'}, 
                                        headers=headers)
        logger.debug("List objects done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_list_objects, ListObjectsResult)

    def list_objects_v2(self, prefix='', delimiter='', continuation_token='', start_after='', fetch_owner=False, encoding_type='url', max_keys=100, headers=None):
        """根据前缀罗列Bucket里的文件。

        :param str prefix: 只罗列文件名为该前缀的文件
        :param str delimiter: 分隔符。可以用来模拟目录
        :param str continuation_token: 分页标志。首次调用传空串，后续使用返回值的next_continuation_token
        :param str start_after: 起始文件名称，OSS会返回按照字典序排列start_after之后的文件。
        :param bool fetch_owner: 是否获取文件的owner信息，默认不返回。
        :param int max_keys: 最多返回文件的个数，文件和目录的和不能超过该值

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`ListObjectsV2Result <oss2.models.ListObjectsV2Result>`
        """
        headers = http.CaseInsensitiveDict(headers)
        logger.debug(
            "Start to List objects, bucket: {0}, prefix: {1}, delimiter: {2}, continuation_token: {3}, "
            "start-after: {4}, fetch-owner: {5}, encoding_type: {6}, max-keys: {7}".format(
                self.bucket_name, to_string(prefix), delimiter, continuation_token, start_after, fetch_owner, encoding_type, max_keys))
        resp = self.__do_bucket('GET',
                                params={'list-type': '2',
                                        'prefix': prefix,
                                        'delimiter': delimiter,
                                        'continuation-token': continuation_token,
                                        'start-after': start_after,
                                        'fetch-owner': str(fetch_owner).lower(),
                                        'max-keys': str(max_keys),
                                        'encoding-type': encoding_type},
                                        headers=headers)
        logger.debug("List objects V2 done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_list_objects_v2, ListObjectsV2Result)

    def put_object(self, key, data,
                   headers=None,
                   progress_callback=None):
        """上传一个普通文件。

        用法 ::
            >>> bucket.put_object('readme.txt', 'content of readme.txt')
            >>> with open(u'local_file.txt', 'rb') as f:
            >>>     bucket.put_object('remote_file.txt', f)

        :param key: 上传到OSS的文件名

        :param data: 待上传的内容。
        :type data: bytes，str或file-like object

        :param headers: 用户指定的HTTP头部。可以指定Content-Type、Content-MD5、x-oss-meta-开头的头部等
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :param progress_callback: 用户指定的进度回调函数。可以用来实现进度条等功能。参考 :ref:`progress_callback` 。

        :return: :class:`PutObjectResult <oss2.models.PutObjectResult>`
        """
        headers = utils.set_content_type(http.CaseInsensitiveDict(headers), key)

        if progress_callback:
            data = utils.make_progress_adapter(data, progress_callback)

        if self.enable_crc:
            data = utils.make_crc_adapter(data)

        logger.debug("Start to put object, bucket: {0}, key: {1}, headers: {2}".format(self.bucket_name, to_string(key),
                                                                                       headers))
        resp = self.__do_object('PUT', key, data=data, headers=headers)
        logger.debug("Put object done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        result = PutObjectResult(resp)

        if self.enable_crc and result.crc is not None:
            utils.check_crc('put object', data.crc, result.crc, result.request_id)

        return result

    def put_object_from_file(self, key, filename,
                             headers=None,
                             progress_callback=None):
        """上传一个本地文件到OSS的普通文件。

        :param str key: 上传到OSS的文件名
        :param str filename: 本地文件名，需要有可读权限

        :param headers: 用户指定的HTTP头部。可以指定Content-Type、Content-MD5、x-oss-meta-开头的头部等
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :param progress_callback: 用户指定的进度回调函数。参考 :ref:`progress_callback`

        :return: :class:`PutObjectResult <oss2.models.PutObjectResult>`
        """
        headers = utils.set_content_type(http.CaseInsensitiveDict(headers), filename)
        logger.debug("Put object from file, bucket: {0}, key: {1}, file path: {2}".format(
            self.bucket_name, to_string(key), filename))
        with open(to_unicode(filename), 'rb') as f:
            return self.put_object(key, f, headers=headers, progress_callback=progress_callback)

    def put_object_with_url(self, sign_url, data, headers=None, progress_callback=None):

        """ 使用加签的url上传对象

        :param sign_url: 加签的url
        :param data: 待上传的数据
        :param headers: 用户指定的HTTP头部。可以指定Content-Type、Content-MD5、x-oss-meta-开头的头部等，必须和签名时保持一致
        :param progress_callback: 用户指定的进度回调函数。参考 :ref:`progress_callback`
        :return:
        """
        headers = http.CaseInsensitiveDict(headers)

        if progress_callback:
            data = utils.make_progress_adapter(data, progress_callback)

        if self.enable_crc:
            data = utils.make_crc_adapter(data)

        logger.debug("Start to put object with signed url, bucket: {0}, sign_url: {1}, headers: {2}".format(
            self.bucket_name, sign_url, headers))

        resp = self._do_url('PUT', sign_url, data=data, headers=headers)
        logger.debug("Put object with url done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        result = PutObjectResult(resp)

        if self.enable_crc and result.crc is not None:
            utils.check_crc('put object', data.crc, result.crc, result.request_id)

        return result

    def put_object_with_url_from_file(self, sign_url, filename,
                                      headers=None,
                                      progress_callback=None):
        """ 使用加签的url上传本地文件到oss

        :param sign_url: 加签的url
        :param filename: 本地文件路径
        :param headers: 用户指定的HTTP头部。可以指定Content-Type、Content-MD5、x-oss-meta-开头的头部等，必须和签名时保持一致
        :param progress_callback: 用户指定的进度回调函数。参考 :ref:`progress_callback`
        :return:
        """
        logger.debug("Put object from file with signed url, bucket: {0}, sign_url: {1}, file path: {2}".format(
            self.bucket_name, sign_url, filename))
        with open(to_unicode(filename), 'rb') as f:
            return self.put_object_with_url(sign_url, f, headers=headers, progress_callback=progress_callback)

    def append_object(self, key, position, data,
                      headers=None,
                      progress_callback=None,
                      init_crc=None):
        """追加上传一个文件。

        :param str key: 新的文件名，或已经存在的可追加文件名
        :param int position: 追加上传一个新的文件， `position` 设为0；追加一个已经存在的可追加文件， `position` 设为文件的当前长度。
            `position` 可以从上次追加的结果 `AppendObjectResult.next_position` 中获得。

        :param data: 用户数据
        :type data: str、bytes、file-like object或可迭代对象

        :param headers: 用户指定的HTTP头部。可以指定Content-Type、Content-MD5、x-oss-开头的头部等
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :param progress_callback: 用户指定的进度回调函数。参考 :ref:`progress_callback`

        :return: :class:`AppendObjectResult <oss2.models.AppendObjectResult>`

        :raises: 如果 `position` 和当前文件长度不一致，抛出 :class:`PositionNotEqualToLength <oss2.exceptions.PositionNotEqualToLength>` ；
                 如果当前文件不是可追加类型，抛出 :class:`ObjectNotAppendable <oss2.exceptions.ObjectNotAppendable>` ；
                 还会抛出其他一些异常
        """
        headers = utils.set_content_type(http.CaseInsensitiveDict(headers), key)

        if progress_callback:
            data = utils.make_progress_adapter(data, progress_callback)

        if self.enable_crc and init_crc is not None:
            data = utils.make_crc_adapter(data, init_crc)

        logger.debug("Start to append object, bucket: {0}, key: {1}, headers: {2}, position: {3}".format(
            self.bucket_name, to_string(key), headers, position))
        resp = self.__do_object('POST', key,
                                data=data,
                                headers=headers,
                                params={'append': '', 'position': str(position)})
        logger.debug("Append object done, req_id: {0}, statu_code: {1}".format(resp.request_id, resp.status))
        result = AppendObjectResult(resp)

        if self.enable_crc and result.crc is not None and init_crc is not None:
            utils.check_crc('append object', data.crc, result.crc, result.request_id)

        return result

    def get_object(self, key,
                   byte_range=None,
                   headers=None,
                   progress_callback=None,
                   process=None,
                   params=None):
        """下载一个文件。

        用法 ::

            >>> result = bucket.get_object('readme.txt')
            >>> print(result.read())
            'hello world'

        :param key: 文件名
        :param byte_range: 指定下载范围。参见 :ref:`byte_range`

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :param progress_callback: 用户指定的进度回调函数。参考 :ref:`progress_callback`

        :param process: oss文件处理，如图像服务等。指定后process，返回的内容为处理后的文件。

        :param params: http 请求的查询字符串参数
        :type params: dict

        :return: file-like object

        :raises: 如果文件不存在，则抛出 :class:`NoSuchKey <oss2.exceptions.NoSuchKey>` ；还可能抛出其他异常
        """
        headers = http.CaseInsensitiveDict(headers)

        range_string = _make_range_string(byte_range)
        if range_string:
            headers['range'] = range_string

        params = {} if params is None else params
        if process:
            params.update({Bucket.PROCESS: process})

        logger.debug("Start to get object, bucket: {0}， key: {1}, range: {2}, headers: {3}, params: {4}".format(
            self.bucket_name, to_string(key), range_string, headers, params))
        resp = self.__do_object('GET', key, headers=headers, params=params)
        logger.debug("Get object done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return GetObjectResult(resp, progress_callback, self.enable_crc)

    def select_object(self, key, sql,
                   progress_callback=None,
                   select_params=None,
                   byte_range=None,
                   headers=None
                   ):
        """Select一个文件内容，支持(Csv,Json Doc,Json Lines及其GZIP压缩文件).

        用法 ::
        对于Csv:
            >>> result = bucket.select_object('access.log', 'select * from ossobject where _4 > 40')
            >>> print(result.read())
            'hello world'
        对于Json Doc: { contacts:[{"firstName":"abc", "lastName":"def"},{"firstName":"abc1", "lastName":"def1"}]}
            >>> result = bucket.select_object('sample.json', 'select s.firstName, s.lastName from ossobject.contacts[*] s', select_params = {"Json_Type":"DOCUMENT"})
        
        对于Json Lines: {"firstName":"abc", "lastName":"def"},{"firstName":"abc1", "lastName":"def1"}
            >>> result = bucket.select_object('sample.json', 'select s.firstName, s.lastName from ossobject s', select_params = {"Json_Type":"LINES"})

        :param key: 文件名
        :param sql: sql statement
        :param select_params: select参数集合,对于Json文件必须制定Json_Type类型。参见 :ref:`select_params`

        :param progress_callback: 用户指定的进度回调函数。参考 :ref:`progress_callback`
        :param byte_range: select content of specific range。可以设置Bytes header指定select csv时的文件起始offset和长度。
        
        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: file-like object

        :raises: 如果文件不存在，则抛出 :class:`NoSuchKey <oss2.exceptions.NoSuchKey>` ；还可能抛出其他异常
        """
        range_select = False
        headers = http.CaseInsensitiveDict(headers)
        range_string = _make_range_string(byte_range)
        if range_string:
            headers['range'] = range_string
            range_select = True

        if (range_select == True and 
                (select_params is None or 
                        (SelectParameters.AllowQuotedRecordDelimiter not in select_params or str(select_params[SelectParameters.AllowQuotedRecordDelimiter]).lower() != 'false'))):
                        raise ClientError('"AllowQuotedRecordDelimiter" must be specified in select_params as False when "Range" is specified in header.')

        body = xml_utils.to_select_object(sql, select_params)
        params = {'x-oss-process':  'csv/select'}
        if select_params is not None and SelectParameters.Json_Type in select_params:
            params['x-oss-process'] = 'json/select'

        self.timeout = 3600
        resp = self.__do_object('POST', key, data=body, headers=headers, params=params)
        crc_enabled = False
        if select_params is not None and SelectParameters.EnablePayloadCrc in select_params:
            if str(select_params[SelectParameters.EnablePayloadCrc]).lower() == "true":
                crc_enabled = True
        return SelectObjectResult(resp, progress_callback, crc_enabled)

    def get_object_to_file(self, key, filename,
                           byte_range=None,
                           headers=None,
                           progress_callback=None,
                           process=None,
                           params=None):
        """下载一个文件到本地文件。

        :param key: 文件名
        :param filename: 本地文件名。要求父目录已经存在，且有写权限。
        :param byte_range: 指定下载范围。参见 :ref:`byte_range`

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :param progress_callback: 用户指定的进度回调函数。参考 :ref:`progress_callback`

        :param process: oss文件处理，如图像服务等。指定后process，返回的内容为处理后的文件。

        :param params: http 请求的查询字符串参数
        :type params: dict

        :return: 如果文件不存在，则抛出 :class:`NoSuchKey <oss2.exceptions.NoSuchKey>` ；还可能抛出其他异常
        """
        logger.debug("Start to get object to file, bucket: {0}, key: {1}, file path: {2}".format(
            self.bucket_name, to_string(key), filename))
        with open(to_unicode(filename), 'wb') as f:
            result = self.get_object(key, byte_range=byte_range, headers=headers, progress_callback=progress_callback,
                                     process=process, params=params)

            if result.content_length is None:
                shutil.copyfileobj(result, f)
            else:
                utils.copyfileobj_and_verify(result, f, result.content_length, request_id=result.request_id)

            if self.enable_crc and byte_range is None:
                if (headers is None) or ('Accept-Encoding' not in headers) or (headers['Accept-Encoding'] != 'gzip'):
                    utils.check_crc('get', result.client_crc, result.server_crc, result.request_id)

            return result

    def get_object_with_url(self, sign_url,
                            byte_range=None,
                            headers=None,
                            progress_callback=None):
        """使用加签的url下载文件

        :param sign_url: 加签的url
        :param byte_range: 指定下载范围。参见 :ref:`byte_range`

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict，必须和签名时保持一致

        :param progress_callback: 用户指定的进度回调函数。参考 :ref:`progress_callback`

        :return: file-like object

        :raises: 如果文件不存在，则抛出 :class:`NoSuchKey <oss2.exceptions.NoSuchKey>` ；还可能抛出其他异常
        """
        headers = http.CaseInsensitiveDict(headers)

        range_string = _make_range_string(byte_range)
        if range_string:
            headers['range'] = range_string

        logger.debug("Start to get object with url, bucket: {0}, sign_url: {1}, range: {2}, headers: {3}".format(
            self.bucket_name, sign_url, range_string, headers))
        resp = self._do_url('GET', sign_url, headers=headers)
        return GetObjectResult(resp, progress_callback, self.enable_crc)

    def get_object_with_url_to_file(self, sign_url,
                                    filename,
                                    byte_range=None,
                                    headers=None,
                                    progress_callback=None):
        """使用加签的url下载文件

        :param sign_url: 加签的url
        :param filename: 本地文件名。要求父目录已经存在，且有写权限。
        :param byte_range: 指定下载范围。参见 :ref:`byte_range`

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict，，必须和签名时保持一致

        :param progress_callback: 用户指定的进度回调函数。参考 :ref:`progress_callback`

        :return: file-like object

        :raises: 如果文件不存在，则抛出 :class:`NoSuchKey <oss2.exceptions.NoSuchKey>` ；还可能抛出其他异常
        """
        logger.debug(
            "Start to get object with url, bucket: {0}, sign_url: {1}, file path: {2}, range: {3}, headers: {4}"
            .format(self.bucket_name, sign_url, filename, byte_range, headers))

        with open(to_unicode(filename), 'wb') as f:
            result = self.get_object_with_url(sign_url, byte_range=byte_range, headers=headers,
                                              progress_callback=progress_callback)
            if result.content_length is None:
                shutil.copyfileobj(result, f)
            else:
                utils.copyfileobj_and_verify(result, f, result.content_length, request_id=result.request_id)

            return result

    def select_object_to_file(self, key, filename, sql,
                   progress_callback=None,
                   select_params=None,
                   headers=None
                   ):
        """Select一个文件的内容到本地文件

        :param key: OSS文件名
        :param filename: 本地文件名。其父亲目录已经存在且有写权限。

        :param progress_callback: 调用进度的callback。参考 :ref:`progress_callback`
        :param select_params: select参数集合。参见 :ref:`select_params`

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: 如果文件不存在, 抛出 :class:`NoSuchKey <oss2.exceptions.NoSuchKey>`
        """
        with open(to_unicode(filename), 'wb') as f:
            result = self.select_object(key, sql, progress_callback=progress_callback,
                                        select_params=select_params, headers=headers)

            for chunk in result:
                f.write(chunk)

            return result

    def head_object(self, key, headers=None, params=None):
        """获取文件元信息。

        HTTP响应的头部包含了文件元信息，可以通过 `RequestResult` 的 `headers` 成员获得。
        用法 ::

            >>> result = bucket.head_object('readme.txt')
            >>> print(result.content_type)
            text/plain

        :param key: 文件名

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :param params: HTTP请求参数，传入versionId，获取指定版本Object元信息
        :type params: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`HeadObjectResult <oss2.models.HeadObjectResult>`

        :raises: 如果Bucket不存在或者Object不存在，则抛出 :class:`NotFound <oss2.exceptions.NotFound>`
        """
        logger.debug("Start to head object, bucket: {0}, key: {1}, headers: {2}".format(
            self.bucket_name, to_string(key), headers))

        resp = self.__do_object('HEAD', key, headers=headers, params=params)

        logger.debug("Head object done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_dummy_result, HeadObjectResult)

    def create_select_object_meta(self, key, select_meta_params=None, headers=None):
        """获取或创建CSV,JSON LINES 文件元信息。如果元信息存在，返回之；不然则创建后返回之

        HTTP响应的头部包含了文件元信息，可以通过 `RequestResult` 的 `headers` 成员获得。
        CSV文件用法 ::

            >>> select_meta_params = {  'FieldDelimiter': ',',
                                'RecordDelimiter': '\r\n',
                                'QuoteCharacter': '"',
                                'OverwriteIfExists' : 'false'}
            >>> result = bucket.create_select_object_meta('csv.txt', select_meta_params)
            >>> print(result.rows)
           
        JSON LINES文件用法 ::
            >>> select_meta_params = { 'Json_Type':'LINES', 'OverwriteIfExists':'False'}
            >>> result = bucket.create_select_object_meta('jsonlines.json', select_meta_params)
        :param key: 文件名
        :param select_meta_params: 参数词典，可以是dict，参见ref:`csv_meta_params`

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`GetSelectObjectMetaResult <oss2.models.HeadObjectResult>`. 
          除了 rows 和splits 属性之外, 它也返回head object返回的其他属性。
          rows表示该文件的总记录数。
          splits表示该文件的总Split个数，一个Split包含若干条记录，每个Split的总字节数大致相当。用户可以以Split为单位进行分片查询。

        :raises: 如果Bucket不存在或者Object不存在，则抛出:class:`NotFound <oss2.exceptions.NotFound>`
        """
        headers = http.CaseInsensitiveDict(headers)

        body = xml_utils.to_get_select_object_meta(select_meta_params)
        params = {'x-oss-process':  'csv/meta'}
        if select_meta_params is not None and 'Json_Type' in select_meta_params:
            params['x-oss-process'] = 'json/meta'

        self.timeout = 3600
        resp = self.__do_object('POST', key, data=body, headers=headers, params=params)
        return GetSelectObjectMetaResult(resp)

    def get_object_meta(self, key, params=None, headers=None):
        """获取文件基本元信息，包括该Object的ETag、Size（文件大小）、LastModified，并不返回其内容。

        HTTP响应的头部包含了文件基本元信息，可以通过 `GetObjectMetaResult` 的 `last_modified`，`content_length`,`etag` 成员获得。

        :param key: 文件名
        :param dict params: 请求参数

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`GetObjectMetaResult <oss2.models.GetObjectMetaResult>`

        :raises: 如果文件不存在，则抛出 :class:`NoSuchKey <oss2.exceptions.NoSuchKey>` ；还可能抛出其他异常
        """
        headers = http.CaseInsensitiveDict(headers)
        logger.debug("Start to get object metadata, bucket: {0}, key: {1}".format(self.bucket_name, to_string(key)))

        if params is None:
            params = dict()

        if Bucket.OBJECTMETA not in params:
            params[Bucket.OBJECTMETA] = ''

        resp = self.__do_object('HEAD', key, params=params, headers=headers)
        logger.debug("Get object metadata done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return GetObjectMetaResult(resp)

    def object_exists(self, key, headers=None):
        """如果文件存在就返回True，否则返回False。如果Bucket不存在，或是发生其他错误，则抛出异常。"""
        #:param key: 文件名

        #:param headers: HTTP头部
        #:type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        # 如果我们用head_object来实现的话，由于HTTP HEAD请求没有响应体，只有响应头部，这样当发生404时，
        # 我们无法区分是NoSuchBucket还是NoSuchKey错误。
        #
        # 2.2.0之前的实现是通过get_object的if-modified-since头部，把date设为当前时间24小时后，这样如果文件存在，则会返回
        # 304 (NotModified)；不存在，则会返回NoSuchKey。get_object会受回源的影响，如果配置会404回源，get_object会判断错误。
        #
        # 目前的实现是通过get_object_meta判断文件是否存在。
        # get_object_meta 为200时，不会返回响应体，所以该接口把GET方法修改为HEAD 方式
        # 同时, 对于head 请求，服务端会通过x-oss-err 返回 错误响应信息,
        # 考虑到兼容之前的行为，增加exceptions.NotFound 异常 当作NoSuchKey

        logger.debug("Start to check if object exists, bucket: {0}, key: {1}".format(self.bucket_name, to_string(key)))
        try:
            self.get_object_meta(key, headers=headers)
        except exceptions.NoSuchKey:
            return False
        except exceptions.NoSuchBucket:
            raise
        except exceptions.NotFound:
            return False
        except:
            raise

        return True

    def copy_object(self, source_bucket_name, source_key, target_key, headers=None, params=None):
        """拷贝一个文件到当前Bucket。

        :param str source_bucket_name: 源Bucket名
        :param str source_key: 源文件名
        :param str target_key: 目标文件名
        :param dict params: 请求参数

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`PutObjectResult <oss2.models.PutObjectResult>`
        """

        headers = http.CaseInsensitiveDict(headers)

        if params and Bucket.VERSIONID in params:
            headers[OSS_COPY_OBJECT_SOURCE] = '/' + source_bucket_name + \
                '/' + urlquote(source_key, '') + '?versionId=' + params[Bucket.VERSIONID]
        else:
            headers[OSS_COPY_OBJECT_SOURCE] = '/' + source_bucket_name + '/' + urlquote(source_key, '')

        logger.debug(
            "Start to copy object, source bucket: {0}, source key: {1}, bucket: {2}, key: {3}, headers: {4}".format(
                source_bucket_name, to_string(source_key), self.bucket_name, to_string(target_key), headers))
        resp = self.__do_object('PUT', target_key, headers=headers)
        logger.debug("Copy object done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return PutObjectResult(resp)

    def update_object_meta(self, key, headers):
        """更改Object的元数据信息，包括Content-Type这类标准的HTTP头部，以及以x-oss-meta-开头的自定义元数据。

        用户可以通过 :func:`head_object` 获得元数据信息。

        :param str key: 文件名

        :param headers: HTTP头部，包含了元数据信息
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`RequestResult <oss2.models.RequestResults>`
        """

        if headers is not None:
            headers[OSS_METADATA_DIRECTIVE] = 'REPLACE'

        logger.debug("Start to update object metadata, bucket: {0}, key: {1}".format(self.bucket_name, to_string(key)))
        return self.copy_object(self.bucket_name, key, key, headers=headers)

    def delete_object(self, key, params=None, headers=None):
        """删除一个文件。

        :param str key: 文件名
        :param params: 请求参数

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        
        headers = http.CaseInsensitiveDict(headers)

        logger.info("Start to delete object, bucket: {0}, key: {1}".format(self.bucket_name, to_string(key)))
        resp = self.__do_object('DELETE', key, params=params, headers=headers)
        logger.debug("Delete object done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def restore_object(self, key, params=None, headers=None, input=None):
        """restore an object
            如果是第一次针对该object调用接口，返回RequestResult.status = 202；
            如果已经成功调用过restore接口，且服务端仍处于解冻中，抛异常RestoreAlreadyInProgress(status=409)
            如果已经成功调用过restore接口，且服务端解冻已经完成，再次调用时返回RequestResult.status = 200，且会将object的可下载时间延长一天，最多延长7天。
            如果object不存在，则抛异常NoSuchKey(status=404)；
            对非Archive类型的Object提交restore，则抛异常OperationNotSupported(status=400)

            也可以通过调用head_object接口来获取meta信息来判断是否可以restore与restore的状态
            代码示例::
            >>> meta = bucket.head_object(key)
            >>> if meta.resp.headers['x-oss-storage-class'] == oss2.BUCKET_STORAGE_CLASS_ARCHIVE:
            >>>     bucket.restore_object(key)
            >>>         while True:
            >>>             meta = bucket.head_object(key)
            >>>             if meta.resp.headers['x-oss-restore'] == 'ongoing-request="true"':
            >>>                 time.sleep(5)
            >>>             else:
            >>>                 break
        :param str key: object name
        :param params: 请求参数

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :param input: 解冻配置。
        :type input: class:`RestoreConfiguration <oss2.models.RestoreConfiguration>`

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        headers = http.CaseInsensitiveDict(headers)
        logger.debug("Start to restore object, bucket: {0}, key: {1}".format(self.bucket_name, to_string(key)))

        if params is None:
            params = dict()

        if Bucket.RESTORE not in params:
            params[Bucket.RESTORE] = ''

        data = self.__convert_data(RestoreConfiguration, xml_utils.to_put_restore_config, input)

        resp = self.__do_object('POST', key, params=params, headers=headers, data=data)
        logger.debug("Restore object done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def put_object_acl(self, key, permission, params=None, headers=None):
        """设置文件的ACL。

        :param str key: 文件名
        :param str permission: 可以是oss2.OBJECT_ACL_DEFAULT、oss2.OBJECT_ACL_PRIVATE、oss2.OBJECT_ACL_PUBLIC_READ或
            oss2.OBJECT_ACL_PUBLIC_READ_WRITE。
        :param dict params: 请求参数

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to put object acl, bucket: {0}, key: {1}, acl: {2}".format(
            self.bucket_name, to_string(key), permission))

        headers = http.CaseInsensitiveDict(headers)
        headers[OSS_OBJECT_ACL] = permission

        if params is None:
            params = dict()

        if Bucket.ACL not in params:
            params[Bucket.ACL] = ''

        resp = self.__do_object('PUT', key, params=params, headers=headers)
        logger.debug("Put object acl done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_object_acl(self, key, params=None, headers=None):
        """获取文件的ACL。

        :param key: 文件名
        :param params: 请求参数

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`GetObjectAclResult <oss2.models.GetObjectAclResult>`
        """
        logger.debug("Start to get object acl, bucket: {0}, key: {1}".format(self.bucket_name, to_string(key)))
        headers = http.CaseInsensitiveDict(headers)

        if params is None:
            params = dict()

        if Bucket.ACL not in params:
            params[Bucket.ACL] = ''

        resp = self.__do_object('GET', key, params=params, headers=headers)
        logger.debug("Get object acl done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_get_object_acl, GetObjectAclResult)

    def batch_delete_objects(self, key_list, headers=None):
        """批量删除文件。待删除文件列表不能为空。

        :param key_list: 文件名列表，不能为空。
        :type key_list: list of str

        :param headers: HTTP头部

        :return: :class:`BatchDeleteObjectsResult <oss2.models.BatchDeleteObjectsResult>`
        """
        if not key_list:
            raise ClientError('key_list should not be empty')

        logger.debug("Start to delete objects, bucket: {0}, keys: {1}".format(self.bucket_name, key_list))
        
        data = xml_utils.to_batch_delete_objects_request(key_list, False)

        headers = http.CaseInsensitiveDict(headers)
        headers['Content-MD5'] = utils.content_md5(data)

        resp = self.__do_bucket('POST',
                                data=data,
                                params={'delete': '', 'encoding-type': 'url'},
                                headers=headers)
        logger.debug("Delete objects done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_batch_delete_objects, BatchDeleteObjectsResult)

    def delete_object_versions(self, keylist_versions, headers=None):
        """批量删除带版本文件。待删除文件列表不能为空。

        :param key_list_with_version: 带版本的文件名列表，不能为空。（如果传入，则不能为空）
        :type key_list: list of BatchDeleteObjectsList 

        :param headers: HTTP头部

        :return: :class:`BatchDeleteObjectsResult <oss2.models.BatchDeleteObjectsResult>`
        """
        if not keylist_versions:
            raise ClientError('keylist_versions should not be empty')

        logger.debug("Start to delete object versions, bucket: {0}".format(self.bucket_name))
        
        data = xml_utils.to_batch_delete_objects_version_request(keylist_versions, False)

        headers = http.CaseInsensitiveDict(headers)
        headers['Content-MD5'] = utils.content_md5(data)

        resp = self.__do_bucket('POST',
                                data=data,
                                params={'delete': '', 'encoding-type': 'url'},
                                headers=headers)
        logger.debug("Delete object versions done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_batch_delete_objects, BatchDeleteObjectsResult)

    def init_multipart_upload(self, key, headers=None, params=None):
        """初始化分片上传。

        返回值中的 `upload_id` 以及Bucket名和Object名三元组唯一对应了此次分片上传事件。

        :param str key: 待上传的文件名

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`InitMultipartUploadResult <oss2.models.InitMultipartUploadResult>`
        """
        headers = utils.set_content_type(http.CaseInsensitiveDict(headers), key)

        if params is None:
            tmp_params = dict()
        else:
            tmp_params = params.copy()

        tmp_params['uploads'] = ''
        logger.debug("Start to init multipart upload, bucket: {0}, keys: {1}, headers: {2}, params: {3}".format(
            self.bucket_name, to_string(key), headers, tmp_params))
        resp = self.__do_object('POST', key, params=tmp_params, headers=headers)
        logger.debug("Init multipart upload done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_init_multipart_upload, InitMultipartUploadResult)

    def upload_part(self, key, upload_id, part_number, data, progress_callback=None, headers=None):
        """上传一个分片。

        :param str key: 待上传文件名，这个文件名要和 :func:`init_multipart_upload` 的文件名一致。
        :param str upload_id: 分片上传ID
        :param int part_number: 分片号，最小值是1.
        :param data: 待上传数据。
        :param progress_callback: 用户指定进度回调函数。可以用来实现进度条等功能。参考 :ref:`progress_callback` 。

        :param headers: 用户指定的HTTP头部。可以指定Content-MD5头部等
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`PutObjectResult <oss2.models.PutObjectResult>`
        """
        headers = http.CaseInsensitiveDict(headers)

        if progress_callback:
            data = utils.make_progress_adapter(data, progress_callback)

        if self.enable_crc:
            data = utils.make_crc_adapter(data)

        logger.debug(
            "Start to upload multipart, bucket: {0}, key: {1}, upload_id: {2}, part_number: {3}, headers: {4}".format(
                self.bucket_name, to_string(key), upload_id, part_number, headers))
        resp = self.__do_object('PUT', key,
                                params={'uploadId': upload_id, 'partNumber': str(part_number)},
                                headers=headers,
                                data=data)
        logger.debug("Upload multipart done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        result = PutObjectResult(resp)

        if self.enable_crc and result.crc is not None:
            utils.check_crc('upload part', data.crc, result.crc, result.request_id)

        return result

    def complete_multipart_upload(self, key, upload_id, parts, headers=None):
        """完成分片上传，创建文件。

        :param str key: 待上传的文件名，这个文件名要和 :func:`init_multipart_upload` 的文件名一致。
        :param str upload_id: 分片上传ID

        :param parts: PartInfo列表。PartInfo中的part_number和etag是必填项。其中的etag可以从 :func:`upload_part` 的返回值中得到。
        :type parts: list of `PartInfo <oss2.models.PartInfo>`

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`PutObjectResult <oss2.models.PutObjectResult>`
        """
        headers = http.CaseInsensitiveDict(headers)

        data = None
        if parts is not None:
            parts = sorted(parts, key=lambda p: p.part_number)
            data = xml_utils.to_complete_upload_request(parts)

        logger.debug("Start to complete multipart upload, bucket: {0}, key: {1}, upload_id: {2}, parts: {3}".format(
            self.bucket_name, to_string(key), upload_id, data))

        resp = self.__do_object('POST', key,
                                params={'uploadId': upload_id},
                                data=data,
                                headers=headers)
        logger.debug(
            "Complete multipart upload done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        result = PutObjectResult(resp)

        if self.enable_crc and parts is not None:
            object_crc = utils.calc_obj_crc_from_parts(parts)
            utils.check_crc('multipart upload', object_crc, result.crc, result.request_id)

        return result

    def abort_multipart_upload(self, key, upload_id, headers=None):
        """取消分片上传。

        :param str key: 待上传的文件名，这个文件名要和 :func:`init_multipart_upload` 的文件名一致。
        :param str upload_id: 分片上传ID

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """

        logger.debug("Start to abort multipart upload, bucket: {0}, key: {1}, upload_id: {2}".format(
            self.bucket_name, to_string(key), upload_id))

        headers = http.CaseInsensitiveDict(headers)

        resp = self.__do_object('DELETE', key,
                                params={'uploadId': upload_id}, headers=headers)
        logger.debug("Abort multipart done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def list_multipart_uploads(self,
                               prefix='',
                               delimiter='',
                               key_marker='',
                               upload_id_marker='',
                               max_uploads=1000, 
                               headers=None):
        """罗列正在进行中的分片上传。支持分页。

        :param str prefix: 只罗列匹配该前缀的文件的分片上传
        :param str delimiter: 目录分割符
        :param str key_marker: 文件名分页符。第一次调用可以不传，后续设为返回值中的 `next_key_marker`
        :param str upload_id_marker: 分片ID分页符。第一次调用可以不传，后续设为返回值中的 `next_upload_id_marker`
        :param int max_uploads: 一次罗列最多能够返回的条目数

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`ListMultipartUploadsResult <oss2.models.ListMultipartUploadsResult>`
        """
        logger.debug("Start to list multipart uploads, bucket: {0}, prefix: {1}, delimiter: {2}, key_marker: {3}, "
                     "upload_id_marker: {4}, max_uploads: {5}".format(self.bucket_name, to_string(prefix), delimiter,
                                                                      to_string(key_marker), upload_id_marker,
                                                                      max_uploads))

        headers = http.CaseInsensitiveDict(headers)

        resp = self.__do_bucket('GET',
                                params={'uploads': '',
                                        'prefix': prefix,
                                        'delimiter': delimiter,
                                        'key-marker': key_marker,
                                        'upload-id-marker': upload_id_marker,
                                        'max-uploads': str(max_uploads),
                                        'encoding-type': 'url'},
                                        headers=headers)
        logger.debug("List multipart uploads done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_list_multipart_uploads, ListMultipartUploadsResult)

    def upload_part_copy(self, source_bucket_name, source_key, byte_range,
                         target_key, target_upload_id, target_part_number,
                         headers=None, params=None):
        """分片拷贝。把一个已有文件的一部分或整体拷贝成目标文件的一个分片。
        :source_bucket_name: 源文件所在bucket的名称
        :source_key:源文件名称
        :param byte_range: 指定待拷贝内容在源文件里的范围。参见 :ref:`byte_range`
        :target_key: 目的文件的名称
        :target_upload_id: 目的文件的uploadid
        :target_part_number: 目的文件的分片号
        :param params: 请求参数

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`PutObjectResult <oss2.models.PutObjectResult>`
        """
        headers = http.CaseInsensitiveDict(headers)

        if params and Bucket.VERSIONID in params:
            headers[OSS_COPY_OBJECT_SOURCE] = '/' + source_bucket_name + \
                '/' + urlquote(source_key, '') + '?versionId=' + params[Bucket.VERSIONID]
        else:
            headers[OSS_COPY_OBJECT_SOURCE] = '/' + source_bucket_name + '/' + urlquote(source_key, '')


        range_string = _make_range_string(byte_range)
        if range_string:
            headers[OSS_COPY_OBJECT_SOURCE_RANGE] = range_string

        logger.debug("Start to upload part copy, source bucket: {0}, source key: {1}, bucket: {2}, key: {3}, range"
                     ": {4}, upload id: {5}, part_number: {6}, headers: {7}".format(source_bucket_name,
                    to_string(source_key),self.bucket_name,to_string(target_key),
                    byte_range, target_upload_id,target_part_number, headers))

        if params is None:
            params = dict()

        params['uploadId'] = target_upload_id
        params['partNumber'] = str(target_part_number)

        resp = self.__do_object('PUT', target_key,
                                params=params,headers=headers)
        logger.debug("Upload part copy done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return PutObjectResult(resp)

    def list_parts(self, key, upload_id,
                   marker='', max_parts=1000, headers=None):
        """列举已经上传的分片。支持分页。

        :param headers: HTTP头部
        :param str key: 文件名
        :param str upload_id: 分片上传ID
        :param str marker: 分页符
        :param int max_parts: 一次最多罗列多少分片

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`ListPartsResult <oss2.models.ListPartsResult>`
        """
        logger.debug("Start to list parts, bucket: {0}, key: {1}, upload_id: {2}, marker: {3}, max_parts: {4}".format(
            self.bucket_name, to_string(key), upload_id, marker, max_parts))

        headers = http.CaseInsensitiveDict(headers)

        resp = self.__do_object('GET', key,
                                params={'uploadId': upload_id,
                                        'part-number-marker': marker,
                                        'max-parts': str(max_parts)}, 
                                        headers=headers)
        logger.debug("List parts done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_list_parts, ListPartsResult)

    def put_symlink(self, target_key, symlink_key, headers=None):
        """创建Symlink。

        :param str target_key: 目标文件，目标文件不能为符号连接
        :param str symlink_key: 符号连接类文件，其实质是一个特殊的文件，数据指向目标文件

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        headers = http.CaseInsensitiveDict(headers)
        headers[OSS_SYMLINK_TARGET] = urlquote(target_key, '')

        logger.debug("Start to put symlink, bucket: {0}, target_key: {1}, symlink_key: {2}, headers: {3}".format(
            self.bucket_name, to_string(target_key), to_string(symlink_key), headers))
        resp = self.__do_object('PUT', symlink_key, headers=headers, params={Bucket.SYMLINK: ''})
        logger.debug("Put symlink done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_symlink(self, symlink_key, params=None, headers=None):
        """获取符号连接文件的目标文件。

        :param str symlink_key: 符号连接类文件
        :param dict params: 请求参数

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`GetSymlinkResult <oss2.models.GetSymlinkResult>`

        :raises: 如果文件的符号链接不存在，则抛出 :class:`NoSuchKey <oss2.exceptions.NoSuchKey>` ；还可能抛出其他异常
        """
        logger.debug(
            "Start to get symlink, bucket: {0}, symlink_key: {1}".format(self.bucket_name, to_string(symlink_key)))

        headers = http.CaseInsensitiveDict(headers)

        if params is None:
            params = dict()

        if Bucket.SYMLINK not in params:
            params[Bucket.SYMLINK] = ''

        resp = self.__do_object('GET', symlink_key, params=params, headers=headers)
        logger.debug("Get symlink done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return GetSymlinkResult(resp)

    def create_bucket(self, permission=None, input=None, headers=None):
        """创建新的Bucket。

        :param str permission: 指定Bucket的ACL。可以是oss2.BUCKET_ACL_PRIVATE（推荐、缺省）、oss2.BUCKET_ACL_PUBLIC_READ或是
            oss2.BUCKET_ACL_PUBLIC_READ_WRITE。

        :param input: :class:`BucketCreateConfig <oss2.models.BucketCreateConfig>` object
        """
        headers = http.CaseInsensitiveDict(headers)
        if permission:
            headers[OSS_CANNED_ACL] = permission

        data = self.__convert_data(BucketCreateConfig, xml_utils.to_put_bucket_config, input)
        logger.debug("Start to create bucket, bucket: {0}, permission: {1}, config: {2}".format(self.bucket_name,
                                                                                                permission, data))
        resp = self.__do_bucket('PUT', headers=headers, data=data)
        logger.debug("Create bucket done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def delete_bucket(self):
        """删除一个Bucket。只有没有任何文件，也没有任何未完成的分片上传的Bucket才能被删除。

        :return: :class:`RequestResult <oss2.models.RequestResult>`

        ":raises: 如果试图删除一个非空Bucket，则抛出 :class:`BucketNotEmpty <oss2.exceptions.BucketNotEmpty>`
        """
        logger.info("Start to delete bucket, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('DELETE')
        logger.debug("Delete bucket done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def put_bucket_acl(self, permission):
        """设置Bucket的ACL。

        :param str permission: 新的ACL，可以是oss2.BUCKET_ACL_PRIVATE、oss2.BUCKET_ACL_PUBLIC_READ或
            oss2.BUCKET_ACL_PUBLIC_READ_WRITE
        """
        logger.debug("Start to put bucket acl, bucket: {0}, acl: {1}".format(self.bucket_name, permission))
        resp = self.__do_bucket('PUT', headers={OSS_CANNED_ACL: permission}, params={Bucket.ACL: ''})
        logger.debug("Put bucket acl done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_bucket_acl(self):
        """获取Bucket的ACL。

        :return: :class:`GetBucketAclResult <oss2.models.GetBucketAclResult>`
        """
        logger.debug("Start to get bucket acl, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.ACL: ''})
        logger.debug("Get bucket acl done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_get_bucket_acl, GetBucketAclResult)

    def put_bucket_cors(self, input):
        """设置Bucket的CORS。

        :param input: :class:`BucketCors <oss2.models.BucketCors>` 对象或其他
        """
        data = self.__convert_data(BucketCors, xml_utils.to_put_bucket_cors, input)
        logger.debug("Start to put bucket cors, bucket: {0}, cors: {1}".format(self.bucket_name, data))
        resp = self.__do_bucket('PUT', data=data, params={Bucket.CORS: ''})
        logger.debug("Put bucket cors done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_bucket_cors(self):
        """获取Bucket的CORS配置。

        :return: :class:`GetBucketCorsResult <oss2.models.GetBucketCorsResult>`
        """
        logger.debug("Start to get bucket CORS, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.CORS: ''})
        logger.debug("Get bucket CORS done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_get_bucket_cors, GetBucketCorsResult)

    def delete_bucket_cors(self):
        """删除Bucket的CORS配置。"""
        logger.debug("Start to delete bucket CORS, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('DELETE', params={Bucket.CORS: ''})
        logger.debug("Delete bucket CORS done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def put_bucket_lifecycle(self, input, headers=None):
        """设置生命周期管理的配置。

        :param input: :class:`BucketLifecycle <oss2.models.BucketLifecycle>` 对象或其他
        """
        headers = http.CaseInsensitiveDict(headers)
        data = self.__convert_data(BucketLifecycle, xml_utils.to_put_bucket_lifecycle, input)
        logger.debug("Start to put bucket lifecycle, bucket: {0}, lifecycle: {1}".format(self.bucket_name, data))
        resp = self.__do_bucket('PUT', data=data, params={Bucket.LIFECYCLE: ''}, headers=headers)
        logger.debug("Put bucket lifecycle done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_bucket_lifecycle(self):
        """获取生命周期管理配置。

        :return: :class:`GetBucketLifecycleResult <oss2.models.GetBucketLifecycleResult>`

        :raises: 如果没有设置Lifecycle，则抛出 :class:`NoSuchLifecycle <oss2.exceptions.NoSuchLifecycle>`
        """
        logger.debug("Start to get bucket lifecycle, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.LIFECYCLE: ''})
        logger.debug("Get bucket lifecycle done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_get_bucket_lifecycle, GetBucketLifecycleResult)

    def delete_bucket_lifecycle(self):
        """删除生命周期管理配置。如果Lifecycle没有设置，也返回成功。"""
        logger.debug("Start to delete bucket lifecycle, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('DELETE', params={Bucket.LIFECYCLE: ''})
        logger.debug("Delete bucket lifecycle done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_bucket_location(self):
        """获取Bucket的数据中心。

        :return: :class:`GetBucketLocationResult <oss2.models.GetBucketLocationResult>`
        """
        logger.debug("Start to get bucket location, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.LOCATION: ''})
        logger.debug("Get bucket location done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_get_bucket_location, GetBucketLocationResult)

    def put_bucket_logging(self, input):
        """设置Bucket的访问日志功能。

        :param input: :class:`BucketLogging <oss2.models.BucketLogging>` 对象或其他
        """
        data = self.__convert_data(BucketLogging, xml_utils.to_put_bucket_logging, input)
        logger.debug("Start to put bucket logging, bucket: {0}, logging: {1}".format(self.bucket_name, data))
        resp = self.__do_bucket('PUT', data=data, params={Bucket.LOGGING: ''})
        logger.debug("Put bucket logging done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_bucket_logging(self):
        """获取Bucket的访问日志功能配置。

        :return: :class:`GetBucketLoggingResult <oss2.models.GetBucketLoggingResult>`
        """
        logger.debug("Start to get bucket logging, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.LOGGING: ''})
        logger.debug("Get bucket logging done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_get_bucket_logging, GetBucketLoggingResult)

    def delete_bucket_logging(self):
        """关闭Bucket的访问日志功能。"""
        logger.debug("Start to delete bucket loggging, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('DELETE', params={Bucket.LOGGING: ''})
        logger.debug("Put bucket lifecycle done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def put_bucket_referer(self, input):
        """为Bucket设置防盗链。

        :param input: :class:`BucketReferer <oss2.models.BucketReferer>` 对象或其他
        """
        data = self.__convert_data(BucketReferer, xml_utils.to_put_bucket_referer, input)
        logger.debug("Start to put bucket referer, bucket: {0}, referer: {1}".format(self.bucket_name, to_string(data)))
        resp = self.__do_bucket('PUT', data=data, params={Bucket.REFERER: ''})
        logger.debug("Put bucket referer done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_bucket_referer(self):
        """获取Bucket的防盗链配置。

        :return: :class:`GetBucketRefererResult <oss2.models.GetBucketRefererResult>`
        """
        logger.debug("Start to get bucket referer, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.REFERER: ''})
        logger.debug("Get bucket referer done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_get_bucket_referer, GetBucketRefererResult)

    def get_bucket_stat(self):
        """查看Bucket的状态，目前包括bucket大小，bucket的object数量，bucket正在上传的Multipart Upload事件个数等。

        :return: :class:`GetBucketStatResult <oss2.models.GetBucketStatResult>`
        """
        logger.debug("Start to get bucket stat, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.STAT: ''})
        logger.debug("Get bucket stat done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_get_bucket_stat, GetBucketStatResult)

    def get_bucket_info(self):
        """获取bucket相关信息，如创建时间，访问Endpoint，Owner与ACL等。

        :return: :class:`GetBucketInfoResult <oss2.models.GetBucketInfoResult>`
        """
        logger.debug("Start to get bucket info, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.BUCKET_INFO: ''})
        logger.debug("Get bucket info done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_get_bucket_info, GetBucketInfoResult)

    def put_bucket_website(self, input):
        """为Bucket配置静态网站托管功能。

        :param input: :class:`BucketWebsite <oss2.models.BucketWebsite>`
        """
        data = self.__convert_data(BucketWebsite, xml_utils.to_put_bucket_website, input)

        headers = http.CaseInsensitiveDict()
        headers['Content-MD5'] = utils.content_md5(data)

        logger.debug("Start to put bucket website, bucket: {0}, website: {1}".format(self.bucket_name, to_string(data)))
        resp = self.__do_bucket('PUT', data=data, params={Bucket.WEBSITE: ''}, headers=headers)
        logger.debug("Put bucket website done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_bucket_website(self):
        """获取Bucket的静态网站托管配置。

        :return: :class:`GetBucketWebsiteResult <oss2.models.GetBucketWebsiteResult>`

        :raises: 如果没有设置静态网站托管，那么就抛出 :class:`NoSuchWebsite <oss2.exceptions.NoSuchWebsite>`
        """

        logger.debug("Start to get bucket website, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.WEBSITE: ''})
        logger.debug("Get bucket website done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_get_bucket_website, GetBucketWebsiteResult)

    def delete_bucket_website(self):
        """关闭Bucket的静态网站托管功能。"""
        logger.debug("Start to delete bucket website, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('DELETE', params={Bucket.WEBSITE: ''})
        logger.debug("Delete bucket website done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def create_live_channel(self, channel_name, input):
        """创建推流直播频道

        :param str channel_name: 要创建的live channel的名称
        :param input: LiveChannelInfo类型，包含了live channel中的描述信息

        :return: :class:`CreateLiveChannelResult <oss2.models.CreateLiveChannelResult>`
        """
        data = self.__convert_data(LiveChannelInfo, xml_utils.to_create_live_channel, input)
        logger.debug("Start to create live-channel, bucket: {0}, channel_name: {1}, info: {2}".format(
            self.bucket_name, to_string(channel_name), to_string(data)))
        resp = self.__do_object('PUT', channel_name, data=data, params={Bucket.LIVE: ''})
        logger.debug("Create live-channel done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_create_live_channel, CreateLiveChannelResult)

    def delete_live_channel(self, channel_name):
        """删除推流直播频道

        :param str channel_name: 要删除的live channel的名称
        """
        logger.debug("Start to delete live-channel, bucket: {0}, live_channel: {1}".format(
            self.bucket_name, to_string(channel_name)))
        resp = self.__do_object('DELETE', channel_name, params={Bucket.LIVE: ''})
        logger.debug("Delete live-channel done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_live_channel(self, channel_name):
        """获取直播频道配置

        :param str channel_name: 要获取的live channel的名称

        :return: :class:`GetLiveChannelResult <oss2.models.GetLiveChannelResult>`
        """
        logger.debug("Start to get live-channel info: bucket: {0}, live_channel: {1}".format(
            self.bucket_name, to_string(channel_name)))
        resp = self.__do_object('GET', channel_name, params={Bucket.LIVE: ''})
        logger.debug("Get live-channel done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_get_live_channel, GetLiveChannelResult)

    def list_live_channel(self, prefix='', marker='', max_keys=100):
        """列举出Bucket下所有符合条件的live channel

        param: str prefix: list时channel_id的公共前缀
        param: str marker: list时指定的起始标记
        param: int max_keys: 本次list返回live channel的最大个数

        return: :class:`ListLiveChannelResult <oss2.models.ListLiveChannelResult>`
        """
        logger.debug("Start to list live-channels, bucket: {0}, prefix: {1}, marker: {2}, max_keys: {3}".format(
            self.bucket_name, to_string(prefix), to_string(marker), max_keys))
        resp = self.__do_bucket('GET', params={Bucket.LIVE: '',
                                               'prefix': prefix,
                                               'marker': marker,
                                               'max-keys': str(max_keys)})
        logger.debug("List live-channel done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_list_live_channel, ListLiveChannelResult)

    def get_live_channel_stat(self, channel_name):
        """获取live channel当前推流的状态

        param str channel_name: 要获取推流状态的live channel的名称

        return: :class:`GetLiveChannelStatResult <oss2.models.GetLiveChannelStatResult>`
        """
        logger.debug("Start to get live-channel stat, bucket: {0}, channel_name: {1}".format(
            self.bucket_name, to_string(channel_name)))
        resp = self.__do_object('GET', channel_name, params={Bucket.LIVE: '', Bucket.COMP: 'stat'})
        logger.debug("Get live-channel stat done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_live_channel_stat, GetLiveChannelStatResult)

    def put_live_channel_status(self, channel_name, status):
        """更改live channel的status，仅能在“enabled”和“disabled”两种状态中更改

        param str channel_name: 要更改status的live channel的名称
        param str status: live channel的目标status
        """
        logger.debug("Start to put live-channel status, bucket: {0}, channel_name: {1}, status: {2}".format(
            self.bucket_name, to_string(channel_name), status))
        resp = self.__do_object('PUT', channel_name, params={Bucket.LIVE: '', Bucket.STATUS: status})
        logger.debug("Put live-channel status done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_live_channel_history(self, channel_name):
        """获取live channel中最近的最多十次的推流记录，记录中包含推流的起止时间和远端的地址

        param str channel_name: 要获取最近推流记录的live channel的名称

        return: :class:`GetLiveChannelHistoryResult <oss2.models.GetLiveChannelHistoryResult>`
        """
        logger.debug("Start to get live-channel history, bucket: {0}, channel_name: {1}".format(
            self.bucket_name, to_string(channel_name)))
        resp = self.__do_object('GET', channel_name, params={Bucket.LIVE: '', Bucket.COMP: 'history'})
        logger.debug(
            "Get live-channel history done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_live_channel_history, GetLiveChannelHistoryResult)

    def post_vod_playlist(self, channel_name, playlist_name, start_time=0, end_time=0):
        """根据指定的playlist name以及startTime和endTime生成一个点播的播放列表

        param str channel_name: 要生成点播列表的live channel的名称
        param str playlist_name: 要生成点播列表m3u8文件的名称
        param int start_time: 点播的起始时间，Unix Time格式，可以使用int(time.time())获取
        param int end_time: 点播的结束时间，Unix Time格式，可以使用int(time.time())获取
        """
        logger.debug("Start to post vod playlist, bucket: {0}, channel_name: {1}, playlist_name: {2}, start_time: "
                     "{3}, end_time: {4}".format(self.bucket_name, to_string(channel_name), playlist_name, start_time,
                                                 end_time))
        key = channel_name + "/" + playlist_name
        resp = self.__do_object('POST', key, params={Bucket.VOD: '', 'startTime': str(start_time),
                                                     'endTime': str(end_time)})
        logger.debug("Post vod playlist done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_vod_playlist(self, channel_name, start_time, end_time):
        """查看指定时间段内的播放列表

        param str channel_name: 要获取点播列表的live channel的名称
        param int start_time: 点播的起始时间，Unix Time格式，可以使用int(time.time())获取
        param int end_time: 点播的结束时间，Unix Time格式，可以使用int(time.time())获取
        """
        logger.debug("Start to get vod playlist, bucket: {0}, channel_name: {1},  start_time: "
                     "{2}, end_time: {3}".format(self.bucket_name, to_string(channel_name),  start_time, end_time))
        resp = self.__do_object('GET', channel_name, params={Bucket.VOD: '', 'startTime': str(start_time),
                                                     'endTime': str(end_time)})
        logger.debug("get vod playlist done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        result = GetVodPlaylistResult(resp)
        return result

    def process_object(self, key, process, headers=None):
        """处理图片的接口，支持包括调整大小，旋转，裁剪，水印，格式转换等，支持多种方式组合处理。

        :param str key: 处理的图片的对象名称
        :param str process: 处理的字符串，例如"image/resize,w_100|sys/saveas,o_dGVzdC5qcGc,b_dGVzdA"

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict
        """

        headers = http.CaseInsensitiveDict(headers)

        logger.debug("Start to process object, bucket: {0}, key: {1}, process: {2}".format(
            self.bucket_name, to_string(key), process))
        process_data = "%s=%s" % (Bucket.PROCESS, process)
        resp = self.__do_object('POST', key, params={Bucket.PROCESS: ''}, headers=headers, data=process_data)
        logger.debug("Process object done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return ProcessObjectResult(resp)

    def put_object_tagging(self, key, tagging, headers=None, params=None):
        """

        :param str key: 上传tagging的对象名称，不能为空。

        :param tagging: tag 标签内容 
        :type tagging: :class:`Tagging <oss2.models.Tagging>` 对象

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :param dict params: HTTP请求参数

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to put object tagging, bucket: {0}, key: {1}, tagging: {2}".format(
            self.bucket_name, to_string(key), tagging))

        if headers is not None:
            headers = http.CaseInsensitiveDict(headers)

        if params is None:
            params = dict()

        params[Bucket.TAGGING] = ""

        data = self.__convert_data(Tagging, xml_utils.to_put_tagging, tagging) 
        resp = self.__do_object('PUT', key, data=data, params=params, headers=headers)

        return RequestResult(resp)

    def get_object_tagging(self, key, params=None, headers=None):

        """
        :param str key: 要获取tagging的对象名称
        :param dict params: 请求参数

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`GetTaggingResult <oss2.models.GetTaggingResult>` 
        """
        logger.debug("Start to get object tagging, bucket: {0}, key: {1} params: {2}".format(
                    self.bucket_name, to_string(key), str(params)))
        
        headers = http.CaseInsensitiveDict(headers)

        if params is None:
            params = dict()

        params[Bucket.TAGGING] = ""

        resp = self.__do_object('GET', key, params=params, headers=headers)

        return self._parse_result(resp, xml_utils.parse_get_tagging, GetTaggingResult)

    def delete_object_tagging(self, key, params=None, headers=None):
        """
        :param str key: 要删除tagging的对象名称
        :param dict params: 请求参数

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`RequestResult <oss2.models.RequestResult>` 
        """
        logger.debug("Start to delete object tagging, bucket: {0}, key: {1}".format(
                    self.bucket_name, to_string(key)))

        headers = http.CaseInsensitiveDict(headers)

        if params is None:
            params = dict()

        params[Bucket.TAGGING] = ""

        resp = self.__do_object('DELETE', key, params=params, headers=headers)

        logger.debug("Delete object tagging done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)
    
    def put_bucket_encryption(self, rule):
        """设置bucket加密配置。

        :param rule: :class:` ServerSideEncryptionRule<oss2.models.ServerSideEncryptionRule>` 对象
        """
        data = self.__convert_data(ServerSideEncryptionRule, xml_utils.to_put_bucket_encryption, rule)

        logger.debug("Start to put bucket encryption, bucket: {0}, rule: {1}".format(self.bucket_name, data))
        resp = self.__do_bucket('PUT', data=data, params={Bucket.ENCRYPTION: ""})
        logger.debug("Put bucket encryption done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_bucket_encryption(self):
        """获取bucket加密配置。

        :return: :class:`GetServerSideEncryptionResult <oss2.models.GetServerSideEncryptionResult>`

        :raises: 如果没有设置Bucket encryption，则抛出 :class:`NoSuchServerSideEncryptionRule <oss2.exceptions.NoSuchServerSideEncryptionRule>`
        """
        logger.debug("Start to get bucket encryption, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.ENCRYPTION: ''})
        logger.debug("Get bucket encryption done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_get_bucket_encryption, GetServerSideEncryptionResult)

    def delete_bucket_encryption(self):
        """删除Bucket加密配置。如果Bucket加密没有设置，也返回成功。"""
        logger.debug("Start to delete bucket encryption, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('DELETE', params={Bucket.ENCRYPTION: ''})
        logger.debug("Delete bucket encryption done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def put_bucket_tagging(self, tagging, headers=None):
        """

        :param str key: 上传tagging的对象名称，不能为空。

        :param tagging: tag 标签内容 
        :type tagging: :class:`Tagging <oss2.models.Tagging>` 对象

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to put object tagging, bucket: {0} tagging: {1}".format(
            self.bucket_name, tagging))

        headers = http.CaseInsensitiveDict(headers)

        data = self.__convert_data(Tagging, xml_utils.to_put_tagging, tagging) 
        resp = self.__do_bucket('PUT', data=data, params={Bucket.TAGGING: ''}, headers=headers)

        logger.debug("Put bucket tagging done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_bucket_tagging(self):

        """
        :param str key: 要获取tagging的对象名称
        :param dict params: 请求参数
        :return: :class:`GetTaggingResult<oss2.models.GetTaggingResult>` 
        """
        logger.debug("Start to get bucket tagging, bucket: {0}".format(
                    self.bucket_name))
        
        resp = self.__do_bucket('GET', params={Bucket.TAGGING: ''})

        logger.debug("Get bucket tagging done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_get_tagging, GetTaggingResult)

    def delete_bucket_tagging(self, params=None):
        """
        :return: :class:`RequestResult <oss2.models.RequestResult>` 
        """
        logger.debug("Start to delete bucket tagging, bucket: {0}".format(
                    self.bucket_name))

        if params is None:
            params = dict()

        if Bucket.TAGGING not in params:
            params[Bucket.TAGGING] = ''


        resp = self.__do_bucket('DELETE', params=params)

        logger.debug("Delete bucket tagging done, req_id: {0}, status_code: {1}".format(
                    resp.request_id, resp.status))
        return RequestResult(resp)

    def list_object_versions(self, prefix='', delimiter='', key_marker='',
            max_keys=100, versionid_marker='', headers=None):
        """根据前缀罗列Bucket里的文件的版本。

        :param str prefix: 只罗列文件名为该前缀的文件
        :param str delimiter: 分隔符。可以用来模拟目录
        :param str key_marker: 分页标志。首次调用传空串，后续使用返回值的next_marker
        :param int max_keys: 最多返回文件的个数，文件和目录的和不能超过该值
        :param str versionid_marker: 设定结果从key-marker对象的
            versionid-marker之后按新旧版本排序开始返回，该版本不会在返回的结果当中。 

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict

        :return: :class:`ListObjectVersionsResult <oss2.models.ListObjectVersionsResult>`
        """
        logger.debug(
            "Start to List object versions, bucket: {0}, prefix: {1}, delimiter: {2},"
            +"key_marker: {3}, versionid_marker: {4}, max-keys: {5}".format(
            self.bucket_name, to_string(prefix), delimiter, to_string(key_marker),
            to_string(versionid_marker), max_keys))

        headers = http.CaseInsensitiveDict(headers)

        resp = self.__do_bucket('GET',
                                params={'prefix': prefix,
                                        'delimiter': delimiter,
                                        'key-marker': key_marker,
                                        'version-id-marker': versionid_marker,
                                        'max-keys': str(max_keys),
                                        'encoding-type': 'url',
                                        Bucket.VERSIONS: ''},
                                        headers=headers)
        logger.debug("List object versions done, req_id: {0}, status_code: {1}"
                .format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_list_object_versions, ListObjectVersionsResult)

    def put_bucket_versioning(self, config, headers=None):
        """

        :param str operation: 设置bucket是否开启多版本特性，可取值为:[Enabled,Suspend] 

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to put object versioning, bucket: {0}".format(self.bucket_name))
        data = self.__convert_data(BucketVersioningConfig, xml_utils.to_put_bucket_versioning, config) 

        headers = http.CaseInsensitiveDict(headers)
        headers['Content-MD5'] = utils.content_md5(data)

        resp = self.__do_bucket('PUT', data=data, params={Bucket.VERSIONING: ''}, headers=headers)
        logger.debug("Put bucket versiong done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return RequestResult(resp)

    def get_bucket_versioning(self):
        """
        :return: :class:`GetBucketVersioningResult<oss2.models.GetBucketVersioningResult>` 
        """
        logger.debug("Start to get bucket versioning, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.VERSIONING: ''})
        logger.debug("Get bucket versiong done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_get_bucket_versioning, GetBucketVersioningResult)

    def put_bucket_policy(self, policy):
        """设置bucket授权策略, 具体policy书写规则请参考官方文档

        :param str policy: 授权策略
        """
        logger.debug("Start to put bucket policy, bucket: {0}, policy: {1}".format(self.bucket_name, policy))
        resp = self.__do_bucket('PUT', data=policy, params={Bucket.POLICY: ''}, headers={'Content-MD5': utils.content_md5(policy)})
        logger.debug("Put bucket policy done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return RequestResult(resp)

    def get_bucket_policy(self):
        """获取bucket授权策略

        :return: :class:`GetBucketPolicyResult <oss2.models.GetBucketPolicyResult>`
        """

        logger.debug("Start to get bucket policy, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.POLICY:''})
        logger.debug("Get bucket policy done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return GetBucketPolicyResult(resp)

    def delete_bucket_policy(self):
        """删除bucket授权策略
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to delete bucket policy, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('DELETE', params={Bucket.POLICY: ''})
        logger.debug("Delete bucket policy done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def put_bucket_request_payment(self, payer):
        """设置付费者。

        :param input: :class: str 
        """
        data = xml_utils.to_put_bucket_request_payment(payer)
        logger.debug("Start to put bucket request payment, bucket: {0}, payer: {1}".format(self.bucket_name, payer))
        resp = self.__do_bucket('PUT', data=data, params={Bucket.REQUESTPAYMENT: ''}, headers={'Content-MD5': utils.content_md5(data)})
        logger.debug("Put bucket request payment done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        
        return RequestResult(resp)
    
    def get_bucket_request_payment(self):
        """获取付费者设置。

        :return: :class:`GetBucketRequestPaymentResult <oss2.models.GetBucketRequestPaymentResult>`
        """
        logger.debug("Start to get bucket request payment, bucket: {0}.".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.REQUESTPAYMENT: ''})
        logger.debug("Get bucket request payment done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_get_bucket_request_payment, GetBucketRequestPaymentResult)

    def put_bucket_qos_info(self, bucket_qos_info):
        """配置bucket的QoSInfo

        :param bucket_qos_info :class:`BucketQosInfo <oss2.models.BucketQosInfo>`
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to put bucket qos info, bucket: {0}".format(self.bucket_name))
        data = self.__convert_data(BucketQosInfo, xml_utils.to_put_qos_info, bucket_qos_info) 

        headers = http.CaseInsensitiveDict()
        headers['Content-MD5'] = utils.content_md5(data)
        resp = self.__do_bucket('PUT', data=data, params={Bucket.QOS_INFO: ''}, headers=headers)
        logger.debug("Get bucket qos info done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return RequestResult(resp)

    def get_bucket_qos_info(self):
        """获取bucket的QoSInfo

        :return: :class:`GetBucketQosInfoResult <oss2.models.GetBucketQosInfoResult>`
        """
        logger.debug("Start to get bucket qos info, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.QOS_INFO: ''})
        logger.debug("Get bucket qos info, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_get_qos_info, GetBucketQosInfoResult)

    def delete_bucket_qos_info(self):
        """删除bucket的QoSInfo

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to delete bucket qos info, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('DELETE', params={Bucket.QOS_INFO: ''})
        logger.debug("Delete bucket qos info done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return RequestResult(resp)

    def set_bucket_storage_capacity(self, user_qos):
        """设置Bucket的容量，单位GB

        :param user_qos :class:`BucketUserQos <oss2.models.BucketUserQos>`
        """
        logger.debug("Start to set bucket storage capacity: {0}".format(self.bucket_name))
        data = xml_utils.to_put_bucket_user_qos(user_qos)
        resp = self.__do_bucket('PUT', data=data, params={Bucket.USER_QOS: ''})
        logger.debug("Set bucket storage capacity done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return RequestResult(resp)

    def get_bucket_storage_capacity(self):
        """获取bucket的容量信息。

        :return: :class:`GetBucketUserQosResult <oss2.models.GetBucketUserQosResult>`
        """
        logger.debug("Start to get bucket storage capacity, bucket:{0}".format(self.bucket_name))
        resp = self._Bucket__do_bucket('GET', params={Bucket.USER_QOS: ''})
        logger.debug("Get bucket storage capacity done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_get_bucket_user_qos, GetBucketUserQosResult)

    def put_async_fetch_task(self, task_config):
        """创建一个异步获取文件到bucket的任务。

        :param task_config: 任务配置
        :type task_config: class:`AsyncFetchTaskConfiguration <oss2.models.AsyncFetchTaskConfiguration>` 

        :return: :class:`PutAsyncFetchTaskResult <oss2.models.PutAsyncFetchTaskResult>`
        """
        logger.debug("Start to put async fetch task, bucket:{0}".format(self.bucket_name))
        data = xml_utils.to_put_async_fetch_task(task_config)
        headers = http.CaseInsensitiveDict()
        headers['Content-MD5'] = utils.content_md5(data)
        resp = self._Bucket__do_bucket('POST', data=data, params={Bucket.ASYNC_FETCH: ''}, headers=headers)
        logger.debug("Put async fetch task done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_put_async_fetch_task_result, PutAsyncFetchTaskResult)

    def get_async_fetch_task(self, task_id):
        """获取一个异步获取文件到bucket的任务信息。

        :param str task_id: 任务id
        :return: :class:`GetAsyncFetchTaskResult <oss2.models.GetAsyncFetchTaskResult>`
        """
        logger.debug("Start to get async fetch task, bucket:{0}, task_id:{1}".format(self.bucket_name, task_id))
        resp = self._Bucket__do_bucket('GET', headers={OSS_TASK_ID: task_id}, params={Bucket.ASYNC_FETCH: ''})
        logger.debug("Put async fetch task done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_get_async_fetch_task_result, GetAsyncFetchTaskResult)

    def put_bucket_inventory_configuration(self, inventory_configuration):
        """设置bucket清单配置

        :param inventory_configuration :class:`InventoryConfiguration <oss2.models.InventoryConfiguration>`
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to put bucket inventory configuration, bucket: {0}".format(self.bucket_name))
        data = self.__convert_data(InventoryConfiguration, xml_utils.to_put_inventory_configuration, inventory_configuration) 

        headers = http.CaseInsensitiveDict()
        headers['Content-MD5'] = utils.content_md5(data)
        resp = self.__do_bucket('PUT', data=data, params={Bucket.INVENTORY: '', Bucket.INVENTORY_CONFIG_ID:inventory_configuration.inventory_id}, headers=headers)
        logger.debug("Put bucket inventory configuration done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return RequestResult(resp)

    def get_bucket_inventory_configuration(self, inventory_id):
        """获取指定的清单配置。

        :param str inventory_id : 清单配置id
        :return: :class:`GetInventoryConfigurationResult <oss2.models.GetInventoryConfigurationResult>`
        """
        logger.debug("Start to get bucket inventory configuration, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.INVENTORY: '', Bucket.INVENTORY_CONFIG_ID:inventory_id})
        logger.debug("Get bucket inventory cinfguration done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_get_bucket_inventory_configuration, GetInventoryConfigurationResult)

    def list_bucket_inventory_configurations(self, continuation_token=None):
        """罗列清单配置，默认单次最大返回100条配置，如果存在超过100条配置，罗列结果将会分页，
        分页信息保存在 class:`ListInventoryConfigurationResult <oss2.models.ListInventoryConfigurationResult>`中。

        :param str continuation_token: 分页标识, 默认值为None, 如果上次罗列不完整，这里设置为上次罗列结果中的next_continuation_token值。
        :return: :class:`ListInventoryConfigurationResult <oss2.models.ListInventoryConfigurationResult>`
        """
        logger.debug("Start to list bucket inventory configuration, bucket: {0}".format(self.bucket_name))
        params = {Bucket.INVENTORY:''}
        if continuation_token is not None:
            params[Bucket.CONTINUATION_TOKEN] = continuation_token
        resp = self.__do_bucket('GET', params=params)
        logger.debug("List bucket inventory configuration done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_list_bucket_inventory_configurations, ListInventoryConfigurationsResult)

    def delete_bucket_inventory_configuration(self, inventory_id):
        """删除指定的清单配置

        :param str inventory_id : 清单配置id
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to delete bucket inventory configuration, bucket: {0}, configuration id: {1}.".format(self.bucket_name, inventory_id))
        resp = self.__do_bucket('DELETE', params={Bucket.INVENTORY:'', Bucket.INVENTORY_CONFIG_ID:inventory_id})
        logger.debug("Delete bucket inventory configuration, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return RequestResult(resp)


    def init_bucket_worm(self, retention_period_days=None):
        """创建一条合规保留策略

        :param int retention_period_days : 指定object的保留天数
        :return: :class:`InitBucketWormResult <oss2.models.InitBucketWormResult>`
        """
        logger.debug("Start to init bucket worm, bucket: {0}, retention_period_days: {1}."
                     .format(self.bucket_name, retention_period_days))
        data = xml_utils.to_put_init_bucket_worm(retention_period_days)
        headers = http.CaseInsensitiveDict()
        headers['Content-MD5'] = utils.content_md5(data)
        resp = self.__do_bucket('POST', data=data, params={Bucket.WORM: ''}, headers=headers)
        logger.debug("init bucket worm done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        result = InitBucketWormResult(resp)
        result.worm_id = resp.headers.get("x-oss-worm-id")
        return result

    def abort_bucket_worm(self):
        """删除一条合规保留策略
        只有未锁定保留策略的状态下才能删除，一旦锁定bucket数据将处于保护状态。

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to abort bucket worm, bucket: {0}.".format(self.bucket_name))
        resp = self.__do_bucket('DELETE', params={Bucket.WORM: ''})
        logger.debug("abort bucket worm done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return RequestResult(resp)

    def complete_bucket_worm(self, worm_id=None):
        """锁定一条合规保留策略

        :param str worm_id : 合规保留策略的id。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to complete bucket worm, bucket: {0}, worm_id: {1}.".format(self.bucket_name, worm_id))
        resp = self.__do_bucket('POST', params={Bucket.WORM_ID: worm_id})
        logger.debug("complete bucket worm done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return RequestResult(resp)

    def extend_bucket_worm(self, worm_id=None, retention_period_days=None):
        """延长已经锁定的合规保留策略的object保护天数。

        :param str worm_id : 合规保留策略的id。
        :param int retention_period_days : 指定object的保留天数
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        data = xml_utils.to_put_extend_bucket_worm(retention_period_days)
        headers = http.CaseInsensitiveDict()
        headers['Content-MD5'] = utils.content_md5(data)
        logger.debug("Start to extend bucket worm, bucket: {0}, worm_id: {1}, retention_period_days."
                     .format(self.bucket_name, worm_id, retention_period_days))
        resp = self.__do_bucket('POST', data=data, params={Bucket.WORM_ID: worm_id, Bucket.WORM_EXTEND: ''}, headers=headers)
        logger.debug("extend bucket worm done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return RequestResult(resp)

    def get_bucket_worm(self):
        """获取合规保留策略

        :return: :class:`GetBucketWormResult <oss2.models.GetBucketWormResult>`
        """
        logger.debug("Start to get bucket worm, bucket: {0}.".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.WORM: ''})
        logger.debug("get bucket worm done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_get_bucket_worm_result, GetBucketWormResult)

    def put_bucket_replication(self, rule):
        """设置bucket跨区域复制规则

        :param rule :class:`ReplicationRule <oss2.models.ReplicationRule>`
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to put bucket replication: {0}".format(self.bucket_name))
        data = xml_utils.to_put_bucket_replication(rule)
        headers = http.CaseInsensitiveDict()
        headers['Content-MD5'] = utils.content_md5(data)
        resp = self.__do_bucket('POST', data=data, params={Bucket.REPLICATION: '', 'comp': 'add'}, headers=headers)
        logger.debug("Put bucket replication done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return RequestResult(resp)

    def get_bucket_replication(self):
        """获取bucket跨区域复制规则

        :return: :class:`GetBucketReplicationResult <oss2.models.GetBucketReplicationResult>`
        """
        logger.debug("Start to get bucket replication: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.REPLICATION: ''})
        logger.debug("Get bucket replication done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_get_bucket_replication_result, GetBucketReplicationResult)

    def delete_bucket_replication(self, rule_id):
        """停止Bucket的跨区域复制并删除Bucket的复制配置
        :param str rule_id: Bucket跨区域复制规则的id。

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to delete bucket replication: {0}".format(self.bucket_name))
        data = xml_utils.to_delete_bucket_replication(rule_id)
        headers = http.CaseInsensitiveDict()
        headers['Content-MD5'] = utils.content_md5(data)
        resp = self.__do_bucket('POST', data=data, params={Bucket.REPLICATION: '', 'comp': 'delete'}, headers=headers)
        logger.debug("Delete bucket replication done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return RequestResult(resp)

    def get_bucket_replication_location(self):
        """获取可复制到的Bucket所在的地域

        :return: :class:`ReplicationLocation <oss2.models.GetBucketReplicationLocationResult>`
        """
        logger.debug("Start to get bucket replication location: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET',  params={Bucket.REPLICATION_LOCATION: ''})
        logger.debug("Get bucket replication location done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_get_bucket_replication_location_result, GetBucketReplicationLocationResult)

    def get_bucket_replication_progress(self, rule_id):
        """获取获取某个Bucket的跨区域复制进度

        :param str rule_id: Bucket跨区域复制规则的id。
        :return: :class:`GetBucketReplicationProgressResult <oss2.models.GetBucketReplicationProgressResult>`
        """
        logger.debug("Start to get bucket replication progress: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET',  params={Bucket.REPLICATION_PROGRESS: '', 'rule-id': rule_id})
        logger.debug("Get bucket replication progress done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_get_bucket_replication_progress_result, GetBucketReplicationProgressResult)

    def _get_bucket_config(self, config):
        """获得Bucket某项配置，具体哪种配置由 `config` 指定。该接口直接返回 `RequestResult` 对象。
        通过read()接口可以获得XML字符串。不建议使用。

        :param str config: 可以是 `Bucket.ACL` 、 `Bucket.LOGGING` 等。

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to get bucket config, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={config: ''})
        logger.debug("Get bucket config done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return resp

    def put_bucket_transfer_acceleration(self, enabled):
        """为存储空间（Bucket）配置传输加速

        :param str enabled : 是否开启传输加速。true：开启传输加速; false：关闭传输加速.
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to bucket transfer acceleration, bucket: {0}, enabled: {1}."
                     .format(self.bucket_name, enabled))
        data = xml_utils.to_put_bucket_transfer_acceleration(enabled)
        headers = http.CaseInsensitiveDict()
        headers['Content-MD5'] = utils.content_md5(data)
        resp = self.__do_bucket('PUT', data=data, params={Bucket.TRANSFER_ACCELERATION: ''}, headers=headers)
        logger.debug("bucket transfer acceleration done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return RequestResult(resp)

    def get_bucket_transfer_acceleration(self):
        """获取目标存储空间（Bucket）的传输加速配置

        :return: :class:`GetBucketTransferAccelerationResult <oss2.models.GetBucketTransferAccelerationResult>`
        """
        logger.debug("Start to get bucket transfer acceleration: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.TRANSFER_ACCELERATION: ''})
        logger.debug("Get bucket transfer acceleration done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_get_bucket_transfer_acceleration_result, GetBucketTransferAccelerationResult)

    def create_bucket_cname_token(self, domain):
        """创建域名所有权验证所需的CnameToken。

        :param str domain : 绑定的Cname名称。
        :return: :class:`CreateBucketCnameTokenResult <oss2.models.CreateBucketCnameTokenResult>`
        """
        logger.debug("Start to create bucket cname token, bucket: {0}.".format(self.bucket_name))
        data = xml_utils.to_bucket_cname_configuration(domain)
        resp = self.__do_bucket('POST', data=data, params={Bucket.CNAME: '', Bucket.COMP: 'token'})
        logger.debug("bucket cname token done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_create_bucket_cname_token, CreateBucketCnameTokenResult)

    def get_bucket_cname_token(self, domain):
        """获取已创建的CnameToken。

        :param str domain : 绑定的Cname名称。
        :return: :class:`GetBucketCnameTokenResult <oss2.models.GetBucketCnameTokenResult>`
        """
        logger.debug("Start to get bucket cname: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.CNAME: domain, Bucket.COMP: 'token'})
        logger.debug("Get bucket cname done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_get_bucket_cname_token, GetBucketCnameTokenResult)

    def put_bucket_cname(self, input):
        """为某个存储空间（Bucket）绑定自定义域名。

        :param input: PutBucketCnameRequest类型，包含了证书和自定义域名信息
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to add bucket cname, bucket: {0}.".format(self.bucket_name))
        data = xml_utils.to_bucket_cname_configuration(input.domain, input.cert)
        resp = self.__do_bucket('POST', data=data, params={Bucket.CNAME: '', Bucket.COMP: 'add'})
        logger.debug("bucket cname done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def list_bucket_cname(self):
        """查询某个存储空间（Bucket）下绑定的所有Cname列表。

        :return: :class:`ListBucketCnameResult <oss2.models.ListBucketCnameResult>`
        """
        logger.debug("Start to do query list bucket cname: {0}".format(self.bucket_name))

        resp = self.__do_bucket('GET', params={Bucket.CNAME: ''})
        logger.debug("query list bucket cname done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_list_bucket_cname, ListBucketCnameResult)

    def delete_bucket_cname(self, domain):
        """删除某个存储空间（Bucket）已绑定的Cname

        :param str domain : 绑定的Cname名称。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to delete bucket cname: {0}".format(self.bucket_name))
        data = xml_utils.to_bucket_cname_configuration(domain)
        resp = self.__do_bucket('POST', data=data, params={Bucket.CNAME: '', Bucket.COMP: 'delete'})
        logger.debug("delete bucket cname done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def open_bucket_meta_query(self):
        """为存储空间（Bucket）开启元数据管理功能

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to bucket meta query, bucket: {0}.".format(self.bucket_name))
        resp = self.__do_bucket('POST', params={Bucket.META_QUERY: '', 'comp': 'add'})
        logger.debug("bucket meta query done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_bucket_meta_query_status(self):
        """获取指定存储空间（Bucket）的元数据索引库信息。

        :return: :class:`GetBucketMetaQueryResult <oss2.models.GetBucketMetaQueryResult>`
        """
        logger.debug("Start to get bucket meta query: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.META_QUERY: ''})
        logger.debug("Get bucket meta query done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_get_bucket_meta_query_result, GetBucketMetaQueryResult)

    def do_bucket_meta_query(self, do_meta_query_request):
        """查询满足指定条件的文件（Object），并按照指定字段和排序方式列出文件信息。

        :param do_meta_query_request :class:`MetaQuery <oss2.models.MetaQuery>`
        :return: :class:`DoBucketMetaQueryResult <oss2.models.DoBucketMetaQueryResult>`
        """
        logger.debug("Start to do bucket meta query: {0}".format(self.bucket_name))

        data = self.__convert_data(MetaQuery, xml_utils.to_do_bucket_meta_query_request, do_meta_query_request)
        resp = self.__do_bucket('POST', data=data, params={Bucket.META_QUERY: '', Bucket.COMP: 'query'})
        logger.debug("do bucket meta query done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_do_bucket_meta_query_result, DoBucketMetaQueryResult)

    def close_bucket_meta_query(self):
        """关闭存储空间（Bucket）的元数据管理功能

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to close bucket meta query: {0}".format(self.bucket_name))
        resp = self.__do_bucket('POST', params={Bucket.META_QUERY: '', Bucket.COMP: 'delete'})
        logger.debug("bucket meta query done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def put_bucket_access_monitor(self, status):
        """更新 Bucket 访问跟踪状态。

        :param str status : bucket访问跟踪的开启状态
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to put bucket access monitor, bucket: {0}.".format(self.bucket_name))
        data = xml_utils.to_put_bucket_access_monitor(status)
        resp = self.__do_bucket('PUT', data=data, params={Bucket.ACCESS_MONITOR: ''})
        logger.debug("bucket access monitor done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_bucket_access_monitor(self):
        """获取当前Bucket的访问跟踪的状态。

        :return: :class:`GetBucketAccessMonitorResult <oss2.models.GetBucketAccessMonitorResult>`
        """
        logger.debug("Start to get bucket access monitor: {0}".format(self.bucket_name))

        resp = self.__do_bucket('GET', params={Bucket.ACCESS_MONITOR: ''})
        logger.debug("query list bucket cname done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_get_bucket_access_monitor_result, GetBucketAccessMonitorResult)

    def get_bucket_resource_group(self):
        """查询存储空间（Bucket）的资源组ID。

        :return: :class:`GetBucketResourceGroupResult <oss2.models.GetBucketResourceGroupResult>`
        """
        logger.debug("Start to get bucket resource group: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.RESOURCE_GROUP: ''})
        logger.debug("Get bucket resource group done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_get_bucket_resource_group_result, GetBucketResourceGroupResult)

    def put_bucket_resource_group(self, resourceGroupId):
        """为存储空间（Bucket）配置所属资源组。

        :param str resourceGroupId : Bucket所属的资源组ID。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to put bucket resource group, bucket: {0}.".format(self.bucket_name))
        data = xml_utils.to_put_bucket_resource_group(resourceGroupId)
        resp = self.__do_bucket('PUT', data=data, params={Bucket.RESOURCE_GROUP: ''})
        logger.debug("bucket resource group done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def put_bucket_style(self, styleName, content):
        """新增图片样式。

        :param str styleName : 样式名称。
        :param str content : 图片样式内容，图片样式可以包含一个或多个图片处理操作。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to put bucket style, bucket: {0}.".format(self.bucket_name))

        data = xml_utils.to_put_bucket_style(content)
        resp = self.__do_bucket('PUT', data=data, params={Bucket.STYLE: '', Bucket.STYLE_NAME: styleName})
        logger.debug("bucket style done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def get_bucket_style(self, styleName):
        """查询某个Bucket下指定的图片样式信息。

        :param str styleName : 样式名称。
        :return: :class:`GetBucketStyleResult <oss2.models.GetBucketStyleResult>`
        """
        logger.debug("Start to get bucket style: {0}".format(self.bucket_name))

        resp = self.__do_bucket('GET', params={Bucket.STYLE: '', Bucket.STYLE_NAME: styleName})
        logger.debug("Get bucket style done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return self._parse_result(resp, xml_utils.parse_get_bucket_style_result, GetBucketStyleResult)

    def list_bucket_style(self):
        """查询某个Bucket下已创建的所有图片样式。

        :return: :class:`ListBucketStyleResult <oss2.models.ListBucketStyleResult>`
        """
        logger.debug("Start to list bucket style: {0}".format(self.bucket_name))

        resp = self.__do_bucket('GET', params={Bucket.STYLE: ''})
        logger.debug("query list bucket style done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_list_bucket_style, ListBucketStyleResult)

    def delete_bucket_style(self, styleName):
        """删除某个Bucket下指定的图片样式。

        :param str styleName : 样式名称。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to delete bucket style: {0}".format(self.bucket_name))

        resp = self.__do_bucket('DELETE', params={Bucket.STYLE: '', Bucket.STYLE_NAME: styleName})
        logger.debug("delete bucket style done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def async_process_object(self, key, process, headers=None):
        """异步处理多媒体接口。

        :param str key: 处理的多媒体的对象名称
        :param str process: 处理的字符串，例如"video/convert,f_mp4,vcodec_h265,s_1920x1080,vb_2000000,fps_30,acodec_aac,ab_100000,sn_1|sys/saveas,o_dGVzdC5qcGc,b_dGVzdA"

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict
        """

        headers = http.CaseInsensitiveDict(headers)

        logger.debug("Start to async process object, bucket: {0}, key: {1}, process: {2}".format(
            self.bucket_name, to_string(key), process))
        process_data = "%s=%s" % (Bucket.ASYNC_PROCESS, process)
        resp = self.__do_object('POST', key, params={Bucket.ASYNC_PROCESS: ''}, headers=headers, data=process_data)
        logger.debug("Async process object done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_async_process_object, AsyncProcessObject)

    def put_bucket_callback_policy(self, callbackPolicy):
        """设置bucket回调策略

        :param str callbackPolicy: 回调策略
        """
        logger.debug("Start to put bucket callback policy, bucket: {0}, callback policy: {1}".format(self.bucket_name, callbackPolicy))
        data = xml_utils.to_do_bucket_callback_policy_request(callbackPolicy)
        resp = self.__do_bucket('PUT', data=data, params={Bucket.POLICY: '', Bucket.COMP: Bucket.CALLBACK})
        logger.debug("Put bucket callback policy done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))

        return RequestResult(resp)

    def get_bucket_callback_policy(self):
        """获取bucket回调策略
        :return: :class:`GetBucketPolicyResult <oss2.models.CallbackPolicyResult>`
        """

        logger.debug("Start to get bucket callback policy, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('GET', params={Bucket.POLICY: '', Bucket.COMP: Bucket.CALLBACK})
        logger.debug("Get bucket callback policy done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return self._parse_result(resp, xml_utils.parse_callback_policy_result, CallbackPolicyResult)

    def delete_bucket_callback_policy(self):
        """删除bucket回调策略
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        """
        logger.debug("Start to delete bucket callback policy, bucket: {0}".format(self.bucket_name))
        resp = self.__do_bucket('DELETE', params={Bucket.POLICY: '', Bucket.COMP: Bucket.CALLBACK})
        logger.debug("Delete bucket callback policy done, req_id: {0}, status_code: {1}".format(resp.request_id, resp.status))
        return RequestResult(resp)

    def __do_object(self, method, key, **kwargs):
        if not self.bucket_name:
            raise ClientError("Bucket name should not be null or empty.")
        if not key:
            raise ClientError("key should not be null or empty.")
        return self._do(method, self.bucket_name, key, **kwargs)

    def __do_bucket(self, method, **kwargs):
        return self._do(method, self.bucket_name, '', **kwargs)

    def __convert_data(self, klass, converter, data):
        if isinstance(data, klass):
            return converter(data)
        else:
            return data


def _normalize_endpoint(endpoint):
    url = endpoint

    if not endpoint.startswith('http://') and not endpoint.startswith('https://'):
        url = 'http://' + endpoint

    p = urlparse(url)

    if p.port is not None:
        return p.scheme + '://' + p.hostname + ':' + str(p.port)
    else:
        return p.scheme + '://' + p.hostname

_ENDPOINT_TYPE_ALIYUN = 0
_ENDPOINT_TYPE_CNAME = 1
_ENDPOINT_TYPE_IP = 2
_ENDPOINT_TYPE_PATH_STYLE = 3


def _make_range_string(range):
    if range is None:
        return ''

    start = range[0]
    last = range[1]

    if start is None and last is None:
        return ''

    return 'bytes=' + _range(start, last)


def _range(start, last):
    def to_str(pos):
        if pos is None:
            return ''
        else:
            return str(pos)

    return to_str(start) + '-' + to_str(last)


def _determine_endpoint_type(netloc, is_cname, bucket_name, is_path_style):
    if utils.is_ip_or_localhost(netloc):
        return _ENDPOINT_TYPE_IP

    if is_cname:
        return _ENDPOINT_TYPE_CNAME

    if is_path_style:
        return _ENDPOINT_TYPE_PATH_STYLE

    if utils.is_valid_bucket_name(bucket_name):
        return _ENDPOINT_TYPE_ALIYUN
    else:
        return _ENDPOINT_TYPE_IP


class _UrlMaker(object):
    def __init__(self, endpoint, is_cname, is_path_style):
        p = urlparse(endpoint)

        self.scheme = p.scheme
        self.netloc = p.netloc
        self.is_cname = is_cname
        self.is_path_style = is_path_style

    def __call__(self, bucket_name, key, slash_safe=False):
        self.type = _determine_endpoint_type(self.netloc, self.is_cname, bucket_name, self.is_path_style)

        safe = '/' if slash_safe is True else ''
        key = urlquote(key, safe=safe)

        if self.type == _ENDPOINT_TYPE_CNAME:
            return '{0}://{1}/{2}'.format(self.scheme, self.netloc, key)

        if self.type == _ENDPOINT_TYPE_IP or self.type == _ENDPOINT_TYPE_PATH_STYLE:
            if bucket_name:
                return '{0}://{1}/{2}/{3}'.format(self.scheme, self.netloc, bucket_name, key)
            else:
                return '{0}://{1}/{2}'.format(self.scheme, self.netloc, key)

        if not bucket_name:
            assert not key
            return '{0}://{1}'.format(self.scheme, self.netloc)

        return '{0}://{1}.{2}/{3}'.format(self.scheme, bucket_name, self.netloc, key)