
    "hjP                    N   d Z ddlZddlmZ ddlmZ ddlmZ ddlmZ ddlmZ dd	lmZ dd
lm	Z	 ddl ddl
mZmZmZmZ ddl ddl	 ddlZddlZ ej$                  e      Z G d de      Z G d de      Z G d de      Zd ZdZdZdZdZd Zd Zd Z  G d de      Z!y)u%.  
文件上传方法中的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: 行分隔符，默认是
,最多支持两个字符分隔符（比如:
)
    >>> 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。一般情况下不需要使用

    N   )	xml_utils)http)utils)
exceptions)defaults)models)select_params)*)urlquoteurlparse
to_unicode	to_stringc                   2    e Zd Z	 ddZd Zd Zed        Zy)_BaseNc                    || _         t        |j                               | _        t	        j
                  | j                        durt        dj                  |            |xs t        j                         | _
        t        j                  |t        j                        | _        || _        || _        || _        |	| _        d| _        |
| _        | j(                  d| _        t+        | j                  ||      | _        || _        t1        | j                   d      r&| j                   j3                         dk7  rd| _        y y y )NTz:The endpoint you has specified is not valid, endpoint: {0}osszoss-cloudboxauth_versionv1F)auth_normalize_endpointstripendpointr   is_valid_endpointClientErrorformatr   Sessionsessionr   getconnect_timeouttimeoutapp_name
enable_crcproxiesregionproductcloudbox_id	_UrlMaker	_make_urlis_verify_object_stricthasattrr   )selfr   r   is_cnamer   r    r"   r#   r$   r%   r'   is_path_styler*   s                F/root/.hermes/SkillClaw/.venv/lib/python3.12/site-packages/oss2/api.py__init__z_Base.__init__   s   	+HNN,<=""4==1=Zaabjkll0$,,.||OX5M5MN $&')DL"4==(MJ'>$499n-$))2H2H2Jd2R+0D( 3S-    c           	      t   t        |      }t        j                  || j                  ||      f| j                  | j
                  | j                  | j                  | j                  d|}| j                  j                  |||       | j                  j                  || j                        }|j                  dz  dk7  r;t        j                   |      }t"        j%                  dj'                  |             |t)        j*                  |j,                  dt.              }||dk(  r|j1                          |S )N)r"   r$   r%   r&   r'   r!   d      Exception: {0}content-lengthr   )r   r   Requestr)   r"   r$   r%   r&   r'   r   _sign_requestr   
do_requestr!   statusr   make_exceptionloggerinfor   r	   _hgetheadersintread)	r,   methodbucket_namekeykwargsreqrespecontent_lengths	            r/   _doz	_Base._do   s   nll64>>+s#C %$(MM#'<<"&++#'<<'+'7'7% $% 			[#6||&&sDLL&A;;#"))$/AKK(//23G
  dll4DcJ%.A*=IIKr1   c                    t        j                  ||f| j                  | j                  d|}| j                  j                  || j                        }|j                  dz  dk7  r;t        j                  |      }t        j                  dj                  |             |t        j                  |j                  dt               }||dk(  r|j#                          |S )N)r"   r$   r3   r4   r5   r6   r7   r   )r   r8   r"   r$   r   r:   r!   r;   r   r<   r=   r>   r   r	   r?   r@   rA   rB   )r,   rC   sign_urlrF   rG   rH   rI   rJ   s           r/   _do_urlz_Base._do_url   s    ll68ddmmT\\d]cd||&&sDLL&A;;#"))$/AKK(//23G
  dll4DcJ%.A*=IIKr1   c                 D     ||       } ||| j                                |S N)rB   )rH   
parse_funcklassresults       r/   _parse_resultz_Base._parse_result  s     t6499;'r1   ) TNNNFT)__name__
__module____qualname__r0   rK   rN   staticmethodrT    r1   r/   r   r      s,     KO1*4"  r1   r   c                        e Zd ZdZdZdZdZdZdZdZ	dZ
d	Zd
Z	 	 	 	 	 	 	 d fd	ZddZd ZddZddZd dZd!dZd"dZd Zd Zd dZd Zd dZd Zd Zd dZd Z xZS )#Serviceu  用于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标准。
    qosInforegionszx-oss-write-get-object-responsepublicAccessBlockrequesterQosInfoqosRequesterresourcePoolInforesourcePoolresourcePoolBucketsc
                     t         j                  dj                  ||||             t        t        |   ||d|||||||	
       y )NzRInit oss service, endpoint: {0}, connect_timeout: {1}, app_name: {2}, proxies: {3}F)r"   r$   r%   r'   r.   )r=   debugr   superr\   r0   )r,   r   r   r   r    r"   r$   r%   r'   r.   	__class__s             r/   r0   zService.__init__6  sT     	ippox: 	;gt%dHeWo/7-3\i 	& 	kr1   c                    t         j                  dj                  |||             i }||d<   ||d<   t        |      |d<   t	        j
                  |      }||j                  |       | j                  ddd||      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )	u  根据前缀罗列用户的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
        z>Start to list buckets, prefix: {0}, marker: {1}, max-keys: {2}prefixmarkermax-keysGETrU   paramsr@   z0List buckets done, req_id: {0}, status_code: {1})r=   rf   r   strr   CaseInsensitiveDictupdaterK   
request_idr;   rT   r   parse_list_bucketsListBucketsResult)r,   rj   rk   max_keysro   r@   	listParamrH   s           r/   list_bucketszService.list_bucketsD  s     	U\\]cekmuvw	$	($	( #H	***73V$xxr2ixIGNNt`d`k`klm!!$	(D(DFWXXr1   c                 2   t         j                  d       | j                  dddt        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )uo   获取User的QoSInfo
        :return: :class:`GetUserQosInfoResult <oss2.models.GetUserQosInfoResult>`
        zStart to get user qos info.rm   rU   ro   z*get use qos, req_id: {0}, status_code: {1})r=   rf   rK   r\   QOS_INFOr   rs   r;   rT   r   parse_get_qos_infoGetUserQosInfoResultr,   rH   s     r/   get_user_qos_infozService.get_user_qos_info`  ss     	23xxr2w/?/?.DxEAHHZ^ZeZefg!!$	(D(DFZ[[r1   c                 2   t         j                  d       | j                  dddt        j                  |i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u  查询所有支持地域或者指定地域对应的Endpoint信息，包括外网Endpoint、内网Endpoint和传输加速Endpoint。

        :param str regions : 地域。
        :return: :class:`DescribeRegionsResult <oss2.models.DescribeRegionsResult>`
        zStart to describe regionsrm   rU   rz   z4Describe regions done, req_id: {0}, status_code: {1})r=   rf   rK   r\   REGIONSr   rs   r;   rT   r   parse_describe_regionsDescribeRegionsResult)r,   r^   rH   s      r/   describe_regionszService.describe_regionsi  st     	01xxr2w.HxIKRRSWSbSbdhdodopq!!$	(H(HJ_``r1   c                 t   t         j                  dj                  |             t        j                  |      }|r||d<   |r||d<   |r||d<   | j                  dddt        j                  di||      }t         j                  dj                  |j                  |j                               t        |      S )	u  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>`
        z0Start to write get object response, headers: {0}zx-oss-request-routezx-oss-request-tokenzx-oss-fwd-statusPOSTrU   ro   r@   dataz=write get object response done, req_id: {0}, status_code: {1})r=   rf   r   r   rq   rK   r\   WRITE_GET_OBJECT_RESPONSErs   r;   RequestResult)r,   routetoken
fwd_statusr   r@   rH   s          r/   write_get_object_responsez!Service.write_get_object_responsev  s     	GNNwWX**73-2G)*-2G)**4G&'xxB0Q0QSU/V`gnrxsT[[\`\k\kmqmxmxyzT""r1   c                 l   t         j                  dj                  ||             | j                  dddt        j
                  dd|dt        |      i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u.  列举请求者所有的存储冗余转换任务。

        :param str continuation_token: 分页标志,首次调用传空串
        :param int max_keys: 最多返回数目

        :return: :class:`ListUserDataRedundancyTransitionResult <oss2.models.ListUserDataRedundancyTransitionResult>`
        zUStart to list user data redundancy transition, continuation token: {0}, max keys: {1}rm   rU   continuation-tokenrl   rz   zHList user data redundancy transition done, req_id: {0}, status_code: {1})r=   rf   r   rK   BucketREDUNDANCY_TRANSITIONrp   rs   r;   rT   r   *parse_list_user_data_redundancy_transition&ListUserDataRedundancyTransitionResultr,   continuation_tokenrv   rH   s       r/   $list_user_data_redundancy_transitionz,Service.list_user_data_redundancy_transition  s     	lss  uG  IQ  R  	Sxxr2v/K/KRQegy  |F  HK  LT  HU  /Vx  W_ffgkgvgvx|  yD  yD  E  	F!!$	(\(\  _E  F  	Fr1   c                 L   t         j                  d       | j                  dddt        j                  ddt        |      d|i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u  查询某个Bucket下所有接入点。
        param: int max_keys: 本次list返回access point的最大个数
        param: str continuation_token: list时指定的起始标记

        :return: :class:`ListBucketStyleResult <oss2.models.ListBucketStyleResult>`
        z!Start to list bucket access pointrm   rU   rl   r   rz   z;query list access point done, req_id: {0}, status_code: {1})r=   rf   rK   r   ACCESS_POINTrp   r   rs   r;   rT   r   parse_list_access_point_resultListAccessPointResultr,   rv   r   rH   s       r/   list_access_pointszService.list_access_points  s     	89xxr2v/B/BB
TWX`Tacw  zL  /Mx  NRYYZ^ZiZikokvkvwx!!$	(P(PRghhr1   c                 *   t         j                  d       t        j                  |      }| j	                  ddd|t
        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )u   为OSS全局开启阻止公共访问。

        :param bool block_public_access : 是否开启阻止公共访问。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z Start to put public access blockPUTrU   r   ro   z;Put public access block done, req_id: {0}, status_code: {1})r=   rf   r   "to_put_public_access_block_requestrK   r\   PUBLIC_ACCESS_BLOCKr   rs   r;   r   r,   block_public_accessr   rH   s       r/   put_public_access_blockzService.put_public_access_block  sy     	78;;<OPxxr2D':U:UWY9Zx[RYYZ^ZiZikokvkvwxT""r1   c                 2   t         j                  d       | j                  dddt        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取OSS全局阻止公共访问的配置信息。

        :return: :class:`GetPublicAccessBlockResult <oss2.models.GetPublicAccessBlockResult>`
        z Start to get public access blockrm   rU   rz   z;Get public access block done, req_id: {0}, status_code: {1})r=   rf   rK   r\   r   r   rs   r;   rT   r   $parse_get_public_access_block_resultGetPublicAccessBlockResultr~   s     r/   get_public_access_blockzService.get_public_access_block  sv    
 	78xxr2w/J/JB.OxPRYYZ^ZiZikokvkvwx!!$	(V(VXrssr1   c                     t         j                  d       | j                  dddt        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )u~   删除OSS全局阻止公共访问配置信息。

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z#Start to delete public access blockDELETErU   rz   z>Delete public access block done, req_id: {0}, status_code: {1})	r=   rf   rK   r\   r   r   rs   r;   r   r~   s     r/   delete_public_access_blockz"Service.delete_public_access_block  se    
 	:;xx"b'2M2Mr1RxSU\\]a]l]lnrnynyz{T""r1   c                 l   t         j                  dj                  ||             | j                  dddt        j
                  dd|dt        |      i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u  列举当前主账号在当前地域下的资源池。

        :param str continuation_token: 分页标志,首次调用传空串
        :param int max_keys: 最多返回数目

        :return: :class:`ListResourcePoolsResult <oss2.models.ListResourcePoolsResult>`
        zDStart to list resource pools, continuation_token: {0}, max_keys: {1}rm   rU   r   rl   rz   z7List resource pools done, req_id: {0}, status_code: {1})r=   rf   r   rK   r\   RESOURCE_POOLrp   rs   r;   rT   r   parse_list_resource_poolsListResourcePoolsResultr   s       r/   list_resource_poolszService.list_resource_pools  s     	[bbcuw  A  	Bxxr2w/D/DbJ^`rt~  AD  EM  AN  /Ox  PNUUVZVeVegkgrgrst!!$	(K(KMdeer1   c           	         t         j                  dj                  |             |st        d      | j	                  dddt
        j                  dt
        j                  |i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取特定资源池的基本信息。

        :param str resource_pool_name : 请求的资源池的名称。
        :return: :class:`ResourcePoolInfoResult <oss2.models.ResourcePoolInfoResult>`
        z*Start to get resource pool info, uid: {0}.&resource_pool_name should not be emptyrm   rU   rz   z:Get resource pool info done, req_id: {0}, status_code: {1})r=   rf   r   r   rK   r\   RESOURCE_POOL_INFOr   rs   r;   rT   r   parse_get_resource_pool_infoResourcePoolInfoResult)r,   resource_pool_namerH   s      r/   get_resource_pool_infozService.get_resource_pool_info  s     	AHHI[\]!FGGxxr2w/I/I2wOdOdfx.yxzQXXY]YhYhjnjujuvw!!$	(N(NPfggr1   c                    t         j                  dj                  |||             |st        d      | j	                  dddt
        j                  dt
        j                  |d|dt        |      i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )	uZ  获取特定资源池中的Bucket列表。

        :param str resource_pool_name : 请求的资源池的名称。
        :param str continuation_token: 分页标志,首次调用传空串
        :param int max_keys: 最多返回数目

        :return: :class:`ListResourcePoolBucketsResult <oss2.models.ListResourcePoolBucketsResult>`
        zbStart to list resource pool buckets, resource_pool_name:{0} continuation_token: {1}, max_keys: {2}r   rm   rU   r   rl   rz   z>List resource pool buckets done, req_id: {0}, status_code: {1})r=   rf   r   r   rK   r\   RESOURCE_POOL_BUCKETSr   rp   rs   r;   rT   r    parse_list_resource_pool_bucketsListResourcePoolBucketsResultr,   r   r   rv   rH   s        r/   list_resource_pool_bucketsz"Service.list_resource_pool_buckets  s     	y  A  A  BT  Vh  jr  s  	t!FGGxxr2w/L/LbRYRgRgi{  ~R  Tf  hr  tw  x@  tA  /Bx  CU\\]a]l]lnrnynyz{!!$	(R(RTqrrr1   c                    t         j                  dj                  |||             |st        d      |st        d      t	        j
                  |      }| j                  ddd|t        j                  dt        j                  |t        j                  |i      }t         j                  dj                  |j                  |j                               t        |      S )uF  修改子账号在资源池的请求者流控配置。

        :param str uid: 请求者UID
        :param str resource_pool_name: 请求的资源池的名称
        :param qos_configuration :class:`QoSConfiguration <oss2.models.QoSConfiguration>`
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        zhStart to put resource pool requester qos info, uid: {0}, resource_pool_name: {1}, qos_configuration: {2}uid should not be emptyr   r   rU   r   zHPut resource pool requester qos info done, req_id: {0}, status_code: {1})r=   rf   r   r   r   to_put_qos_inforK   r\   REQUESTER_QOS_INFOQOS_REQUESTERr   rs   r;   r   )r,   uidr   qos_configurationr   rH   s         r/   $put_resource_pool_requester_qos_infoz,Service.put_resource_pool_requester_qos_info  s     	  G  G  HK  M_  ar  s  	t788!FGG(():;xxr2D':T:TVXZaZoZoqtv}  wL  wL  N`  :ax  b_ffgkgvgvx|  yD  yD  E  	FT""r1   c                    t         j                  dj                  ||             |st        d      |st        d      | j	                  dddt
        j                  dt
        j                  |t
        j                  |i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取子账号在资源池的流控配置。

        :return: :class:`RequesterQoSInfoResult <oss2.models.RequesterQoSInfoResult>`
        zQStart to get resource pool requester qos info, uid: {0}, resource_pool_name: {1}.r   r   rm   rU   rz   zHGet resource pool requester qos info done, req_id: {0}, status_code: {1})r=   rf   r   r   rK   r\   r   r   r   rs   r;   rT   r   parse_get_requester_qos_infoRequesterQoSInfoResultr,   r   r   rH   s       r/   $get_resource_pool_requester_qos_infoz,Service.get_resource_pool_requester_qos_info  s    
 	hoops  vH  I  	J788!FGGxxr2w/I/I2wOdOdfikr  lA  lA  CU  /Vx  W_ffgkgvgvx|  yD  yD  E  	F!!$	(N(NPfggr1   c                    t         j                  dj                  |||             |st        d      | j	                  dddt
        j                  dt
        j                  |d|dt        |      i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )	uw  列举子账号账号在资源池的流控配置。

        :param str resource_pool_name : 请求的资源池的名称。
        :param str continuation_token: 分页标志,首次调用传空串
        :param int max_keys: 最多返回数目

        :return: :class:`ListResourcePoolRequesterQoSInfosResult <oss2.models.ListResourcePoolRequesterQoSInfosResult>`
        znStart to list resource pool requester qos infos, resource_pool_name:{0} continuation_token: {1}, max_keys: {2}r   rm   rU   r   rl   rz   zJList resource pool requester qos infos done, req_id: {0}, status_code: {1})r=   rf   r   r   rK   r\   r   r   rp   rs   r;   rT   r   ,parse_list_resource_pool_requester_qos_infos'ListResourcePoolRequesterQoSInfosResultr   s        r/   &list_resource_pool_requester_qos_infosz.Service.list_resource_pool_requester_qos_infos'  s    	  F  M  M  N`  bt  v~    	@!FGGxxr2w/I/I2wOdOdfx  {O  Qc  eo  qt  u}  q~  /x  @ahhimixixz~  {F  {F  G  	H!!$	(^(^  aH  I  	Ir1   c                    t         j                  dj                  ||             |st        d      |st        d      | j	                  dddt
        j                  dt
        j                  |t
        j                  |i      }t         j                  dj                  |j                  |j                               t        |      S )u   删除子账号在资源池的请求者流控配置。

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        zTStart to delete resource pool requester qos info, uid: {0}, resource_pool_name: {1}.r   r   r   rU   rz   zKDelete resource pool requester qos info done, req_id: {0}, status_code: {1})r=   rf   r   r   rK   r\   r   r   r   rs   r;   r   r   s       r/   'delete_resource_pool_requester_qos_infoz/Service.delete_resource_pool_requester_qos_info8  s    
 	krrsv  yK  L  	M788!FGGxx"b'2L2LbRYRgRgilnu  oD  oD  FX  2Yx  Zbiijnjyjy{  |G  |G  H  	IT""r1   )NNrU   NNNF)rU   rU   r4   NN)rU   rP   rU   r4   r4   rU   F)rV   rW   rX   __doc__r{   r   r   r   r   r   r   r   r   r0   rx   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   __classcell__rh   s   @r/   r\   r\     s    . HG A-+"M+"M1 !%!$kY8\a#<Fi#
t
#fhs$#&h I"#r1   r\   c                       e Zd ZdZdZdZdZdZdZdZ	dZ
d	Zd
ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!d Z"d!Z#d"Z$d#Z%d$Z&d%Z'd&Z(d'Z)d(Z*d)Z+d*Z,d+Z-d,Z.d-Z/d.Z0d/Z1d0Z2d1Z3d2Z4d3Z5d4Z6d5Z7d6Z8d7Z9d8Z:d7Z9d9Z;d:Z<d;Z=d<Z>	 	 	 	 	 	 	 	 	 	 dۈ fd=	Z?dd>Z@d? ZAdd@ZBddAZC	 	 ddBZD	 	 ddCZEddDZF	 	 ddEZG	 	 	 ddFZH	 	 	 	 	 ddGZI	 	 	 	 ddHZJ	 	 	 	 	 ddIZK	 	 	 ddJZL	 	 	 ddKZM	 	 	 ddLZNddMZOddNZPddOZQddPZRddQZSdR ZTddSZUddTZVddUZWddVZXddWZYddXZZddYZ[ddZZ\dd[Z]dd\Z^	 	 	 	 	 	 dd]Z_	 dd^Z`	 dd_Zadd`ZbddaZcddbZddc Zedd Zfde Zgdf Zhdg Zidh ZjddiZkdj Zldk Zmdl Zndm Zodn Zpdo Zqdp Zrdq Zsdr Ztds Zudt Zvdu Zwdv Zxdw Zydx Zzdy Z{ddzZ|d{ Z}d| Z~d} Zdd~Zd ZddZddZddZddZd Zd Zd ZddZd ZddZ	 	 ddZddZd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd ZddZd ZddZd ZddZddZd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd ZddZd Zd Zd ZddZd Zd Zd ZdÄ ZdĄ Zdń ZdƄ ZdǄ ZdȄ ZdɄ ZddʄZd˄ Zd̄ Zd̈́ Zdd΄Zdτ ZdЄ ZddфZd҄ Zdӄ ZdԄ ZdՄ ZddքZdׄ Zd؄ Zdل Zdڄ Z܈ xZS )r   u  用于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.ProviderAuth or oss2.ProviderAuthV4

    :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cors	lifecyclelocationloggingrefererwebsitelivecompr;   vodsymlinkstat
bucketInfox-oss-processtagging
encryptionversions
versioning	versionIdrestore
objectMetapolicyrequestPaymentr]   qos
asyncFetch
sequential	inventoryinventoryIdr   wormwormId
wormExtendreplicationreplicationLocationreplicationProgresstransferAccelerationcname	metaQueryaccessmonitorresourceGroupstyle	styleNamezx-oss-async-processcallbackbucketArchiveDirectReadhttpsConfigredundancyTransitionzx-oss-target-redundancy-typez"x-oss-redundancy-transition-taskidaccessPointaccessPointPolicyx-oss-access-point-namer_   r`   ra   rb   rc   c                    t         j                  dj                  |||||||	|
             t        t        |   ||||||||	|
|||       |j                         | _        t        j                  | j                        durt        d      y )NzInit Bucket: {0}, endpoint: {1}, isCname: {2}, connect_timeout: {3}, app_name: {4}, enabled_crc: {5}, region: {6}, proxies: {6})r"   r#   r$   r%   r'   r.   r*   Tz,The bucket_name is invalid, please check it.)r=   rf   r   rg   r   r0   r   rD   r   is_valid_bucket_namer   )r,   r   r   rD   r-   r   r    r"   r#   r$   r%   r'   r.   r*   rh   s                 r/   r0   zBucket.__init__  s     	 &&,f[(Ho_gisu|  E  'F	Gfd$T8Xw.6:W^,2[h  CZ 	% 	[ ',,.%%d&6&67tCLMM Dr1   c                    |t        |j                               dk  rt        d      t        |      }| j                  r|j                  d      rt        d      t        j                  dj                  || j                  t        |      ||||             t        j                  || j                  | j                  ||      ||| j                  | j                  | j                        }d}	|*| j                   j#                  || j                  ||      }	|	S | j                   j#                  || j                  |||      }	|	S )	u  生成签名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

        :param additional_headers: 额外的需要签名的HTTP头

        :return: 签名URL。
        r   z$The key is invalid, please check it.?z/The key cannot start with `?`, please check it.zoStart to sign_url, method: {0}, bucket: {1}, key: {2}, expires: {3}, headers: {4}, params: {5}, slash_safe: {6})r@   ro   r%   r&   r'   rU   )in_additional_headers)lenr   r   r   r*   
startswithr=   rf   r   rD   r   r8   r)   r%   r&   r'   r   	_sign_url)
r,   rC   rE   expiresr@   ro   
slash_safeadditional_headersrG   rM   s
             r/   rM   zBucket.sign_url  s1   4 ;#ciik*a/DEEn''CNN3,?OPP}  E  E(()C.'7FT^`	a ll64>>$2B2BC#T#*"("&++#'<<'+'7'79 %yy**30@0@#wOH  yy**30@0@#wfx*yHr1   c                 V   t         j                  dj                  | j                  |||             | j	                  | j                  d      j                  dd      j                  dd      dz   |z   }i }|
|dk7  r||d<   | j                  j                  || j                  |||      S )	u  生成RTMP推流的签名URL。
        常见的用法是生成加签的URL以供授信用户向OSS推RTMP流。

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

        :return: 签名URL。
        zOSign RTMP url, bucket: {0}, channel_name: {1}, playlist_name: {2}, expires: {3}r   http://zrtmp://https:///rU   playlistName)r=   rf   r   rD   r)   replacer   _sign_rtmp_url)r,   channel_nameplaylist_namer  urlro   s         r/   sign_rtmp_urlzBucket.sign_rtmp_url  s     	fmmlM7D 	EnnT--v6>>y)T\\	#%()+78$")<%2F>"yy''T-=-=|WV\]]r1   c           
         t        j                  |      }t        j                  dj	                  | j
                  t        |      |t        |      |             | j                  d|||t        |      dd|      }t        j                  dj	                  |j                  |j                               | j                  |t        j                  t              S )u:  根据前缀罗列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>`
        z[Start to List objects, bucket: {0}, prefix: {1}, delimiter: {2}, marker: {3}, max-keys: {4}rm   r  )rj   	delimiterrk   rl   encoding-typern   z0List objects done, req_id: {0}, status_code: {1})r   rq   r=   rf   r   rD   r   _Bucket__do_bucketrp   rs   r;   rT   r   parse_list_objectsListObjectsResult)r,   rj   r   rk   rv   r@   rH   s          r/   list_objectszBucket.list_objects  s     **73ipp  )F"3Y	&@QS[]	^ 285>2847M9>	(@
 18   9 	GNNt`d`k`klm!!$	(D(DFWXXr1   c	                    t        j                  |      }t        j                  dj	                  | j
                  t        |      ||||||             | j                  dd||||t        |      j                         t        |      |d|      }	t        j                  dj	                  |	j                  |	j                               | j                  |	t        j                  t              S )u!  根据前缀罗列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>`
        zStart to List objects, bucket: {0}, prefix: {1}, delimiter: {2}, continuation_token: {3}, start-after: {4}, fetch-owner: {5}, encoding_type: {6}, max-keys: {7}rm   2)z	list-typerj   r   r   zstart-afterzfetch-ownerrl   r!  rn   z3List objects V2 done, req_id: {0}, status_code: {1})r   rq   r=   rf   r   rD   r   r"  rp   lowerrs   r;   rT   r   parse_list_objects_v2ListObjectsV2Result)
r,   rj   r   r   start_afterfetch_ownerencoding_typerv   r@   rH   s
             r/   list_objects_v2zBucket.list_objects_v2  s     **73TTZTZ  )F"3Y@RT_aln{  ~FUG	H 58285>>P7B7:;7G7M7M7O47M9F(H 18   	9 	JQQRVRaRacgcncnop!!$	(G(GI\]]r1   c                    t        j                  t        j                  |      |      }|rt        j                  ||      }| j
                  rt        j                  |      }t        j                  dj                  | j                  t        |      |             | j                  d|||      }t        j                  dj                  |j                  |j                               t        |      }| j
                  rB|j                   6t        j"                  d|j                   |j                   |j                         |S )u"  上传一个普通文件。

        用法 ::
            >>> 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>`
        z8Start to put object, bucket: {0}, key: {1}, headers: {2}r   r   r@   z.Put object done, req_id: {0}, status_code: {1}
put object)r   set_content_typer   rq   make_progress_adapterr#   make_crc_adapterr=   rf   r   rD   r   _Bucket__do_objectrs   r;   PutObjectResultcrc	check_crc)r,   rE   r   r@   progress_callbackrH   rS   s          r/   
put_objectzBucket.put_object:  s    , (()A)A')JCP..t5FGD??))$/DOVVW[WgWgirsviwW^` 	aswGELLT__^b^i^ijk &??vzz5OOL$((FJJ@Q@QRr1   c                 F   t        j                  t        j                  |      |      }t        j                  dj                  | j                  t        |      |             t        t        |      d      5 }| j                  ||||      cddd       S # 1 sw Y   yxY w)u%  上传一个本地文件到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>`
        z;Put object from file, bucket: {0}, key: {1}, file path: {2}rbr@   r9  N)r   r2  r   rq   r=   rf   r   rD   r   openr   r:  )r,   rE   filenamer@   r9  fs         r/   put_object_from_filezBucket.put_object_from_filec  s     (()A)A')JHURYYinh8 	9*X&- 	a??37N_?`	a 	a 	as   8BB c                 P   t        j                  |      }|rt        j                  ||      }| j                  rt        j
                  |      }t        j                  dj                  | j                  ||             | j                  d|||      }t        j                  dj                  |j                  |j                               t        |      }| j                  rB|j                  6t        j                  d|j                  |j                  |j                         |S )u   使用加签的url上传对象

        :param sign_url: 加签的url
        :param data: 待上传的数据
        :param headers: 用户指定的HTTP头部。可以指定Content-Type、Content-MD5、x-oss-meta-开头的头部等，必须和签名时保持一致
        :param progress_callback: 用户指定的进度回调函数。参考 :ref:`progress_callback`
        :return:
        zMStart to put object with signed url, bucket: {0}, sign_url: {1}, headers: {2}r   r0  z7Put object with url done, req_id: {0}, status_code: {1}r1  )r   rq   r   r3  r#   r4  r=   rf   r   rD   rN   rs   r;   r6  r7  r8  )r,   rM   r   r@   r9  rH   rS   s          r/   put_object_with_urlzBucket.put_object_with_urlx  s     **73..t5FGD??))$/Ddkkh1 	2 ||E8$|HNUUVZVeVegkgrgrst &??vzz5OOL$((FJJ@Q@QRr1   c                     t         j                  dj                  | j                  ||             t	        t        |      d      5 }| j                  ||||      cddd       S # 1 sw Y   yxY w)u   使用加签的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:
        zPPut object from file with signed url, bucket: {0}, sign_url: {1}, file path: {2}r<  r=  N)r=   rf   r   rD   r>  r   rC  )r,   rM   r?  r@   r9  r@  s         r/   put_object_with_url_from_filez$Bucket.put_object_with_url_from_file  sm     	gnnh2 	3*X&- 	o++Ha\m+n	o 	o 	os   A%%A.c           
         t        j                  t        j                  |      |      }|rt        j                  ||      }| j
                  r|t        j                  ||      }t        j                  dj                  | j                  t        |      ||             | j                  d|||dt        |      d      }t        j                  dj                  |j                  |j                               t!        |      }| j
                  rD|j"                  8|6t        j$                  d|j"                  |j"                  |j                         |S )u  追加上传一个文件。

        :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>` ；
                 还会抛出其他一些异常
        zJStart to append object, bucket: {0}, key: {1}, headers: {2}, position: {3}r   rU   )appendpositionr   r@   ro   z0Append object done, req_id: {0}, statu_code: {1}zappend object)r   r2  r   rq   r3  r#   r4  r=   rf   r   rD   r   r5  rp   rs   r;   AppendObjectResultr7  r8  )	r,   rE   rH  r   r@   r9  init_crcrH   rS   s	            r/   append_objectzBucket.append_object  s   0 (()A)A')JCP..t5FGD??x3))$9DahhingxA 	B%)(/24#h-'P   R 	GNNt`d`k`klm#D)??vzz5(:NOOOTXXvzz6CTCTUr1   c           	         t        j                  |      }t        |      }|r||d<   |i n|}|r!|j                  t        j
                  |i       t        j                  dj                  | j                  t        |      |||             | j                  d|||      }t        j                  dj                  |j                  |j                               t        ||| j                        S )u]  下载一个文件。

        用法 ::

            >>> 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>` ；还可能抛出其他异常
        rangeuS   Start to get object, bucket: {0}， key: {1}, range: {2}, headers: {3}, params: {4}rm   r@   ro   z.Get object done, req_id: {0}, status_code: {1})r   rq   _make_range_stringrr   r   PROCESSr=   rf   r   rD   r   r5  rs   r;   GetObjectResultr#   )	r,   rE   
byte_ranger@   r9  processro   range_stringrH   s	            r/   
get_objectzBucket.get_object  s    > **73)*5+GG~6MM6>>734jqqinlGVM 	NsGFKELLT__^b^i^ijkt%6HHr1   c                 >   d}t        j                  |      }t        |      }|r||d<   d}|dk(  rL|?t        j                  |vs-t        |t        j                           j                         dk7  rt        d      t        j                  ||      }	ddi}
|t        j                  |v rd|
d<   d	| _        | j                  d
||	||
      }d}|At        j                  |v r/t        |t        j                           j                         dk(  rd}t        |||      S )u  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>` ；还可能抛出其他异常
        FrN  Tfalsezm"AllowQuotedRecordDelimiter" must be specified in select_params as False when "Range" is specified in header.r   z
csv/selectzjson/select  r   rI  true)r   rq   rP  SelectParametersAllowQuotedRecordDelimiterrp   r(  r   r   to_select_object	Json_Typer!   r5  EnablePayloadCrcSelectObjectResult)r,   rE   sqlr9  r
   rS  r@   range_selectrU  bodyro   rH   crc_enableds                r/   select_objectzBucket.select_object  s]   B **73)*5+GGLD &)DDMY]`ano  p[  p[  b\  ^]  ^c  ^c  ^e  ip  ^p)  +Z  [  [))#}=!L1$)9)C)C})T&3F?#$PVW$)9)J)Jm)[=!1!B!BCDJJLPVV"!$(9;GGr1   c           	      @   t         j                  dj                  | j                  t	        |      |             t        t        |      d      5 }| j                  ||||||      }	|	j                  t        j                  |	|       n-t        j                  |	||	j                  |	j                         | j                  rF|D|d|vs|d   dk7  r6t        j                  d|	j                   |	j"                  |	j                         |	cddd       S # 1 sw Y   yxY w)	u  下载一个文件到本地文件。

        :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>` ；还可能抛出其他异常
        zBStart to get object to file, bucket: {0}, key: {1}, file path: {2}wb)rS  r@   r9  rT  ro   Nrs   zAccept-Encodinggzipr   )r=   rf   r   rD   r   r>  r   rV  rJ   shutilcopyfileobjr   copyfileobj_and_verifyrs   r#   r8  
client_crc
server_crc)
r,   rE   r?  rS  r@   r9  rT  ro   r@  rS   s
             r/   get_object_to_filezBucket.get_object_to_file>  s   0 	Y``inh8 	9*X&- 	__SZdu-4V % EF $$,""61-,,VQ8M8MZ`ZkZkl:#5O):')IwWhOimsOsOOE6+<+<f>O>OQWQbQbc	 	 	s   B;DDc                    t        j                  |      }t        |      }|r||d<   t        j	                  dj                  | j                  |||             | j                  d||      }t        ||| j                        S )u1  使用加签的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>` ；还可能抛出其他异常
        rN  zRStart to get object with url, bucket: {0}, sign_url: {1}, range: {2}, headers: {3}rm   r@   )
r   rq   rP  r=   rf   r   rD   rN   rR  r#   )r,   rM   rS  r@   r9  rU  rH   s          r/   get_object_with_urlzBucket.get_object_with_urlg  s}    $ **73)*5+GGipphg? 	@||E8W|=t%6HHr1   c           	         t         j                  dj                  | j                  ||||             t	        t        |      d      5 }| j                  ||||      }|j                  t        j                  ||       n-t        j                  |||j                  |j                         |cddd       S # 1 sw Y   yxY w)u  使用加签的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>` ；还可能抛出其他异常
        zbStart to get object with url, bucket: {0}, sign_url: {1}, file path: {2}, range: {3}, headers: {4}rg  )rS  r@   r9  Nrh  )r=   rf   r   rD   r>  r   rr  rJ   rj  rk  r   rl  rs   )r,   rM   r?  rS  r@   r9  r@  rS   s           r/   get_object_with_url_to_filez"Bucket.get_object_with_url_to_file  s    ( 	pVD$$h*gN	P *X&- 	--h:W^@Q . SF$$,""61-,,VQ8M8MZ`ZkZkl	 	 	s   A'B99Cc                     t        t        |      d      5 }| j                  |||||      }|D ]  }	|j                  |	        |cddd       S # 1 sw Y   yxY w)u&  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>`
        rg  )r9  r
   r@   N)r>  r   re  write)
r,   rE   r?  ra  r9  r
   r@   r@  rS   chunks
             r/   select_object_to_filezBucket.select_object_to_file  sm    $ *X&- 	''SDU6CW ( VF    	 	 	s   0AAc                 Z   t         j                  dj                  | j                  t	        |      |             | j                  d|||      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u  获取文件元信息。

        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>`
        z9Start to head object, bucket: {0}, key: {1}, headers: {2}HEADrO  z/Head object done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r5  rs   r;   rT   r   parse_dummy_resultHeadObjectResult)r,   rE   r@   ro   rH   s        r/   head_objectzBucket.head_object  s    , 	PWWing7 	8 WVLFMMdoo_c_j_jkl!!$	(D(DFVWWr1   c                     t        j                  |      }t        j                  |      }ddi}|	d|v rd|d<   d| _        | j                  d||||      }t        |      S )uK  获取或创建CSV,JSON LINES 文件元信息。如果元信息存在，返回之；不然则创建后返回之

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

            >>> select_meta_params = {  'FieldDelimiter': ',',
                                'RecordDelimiter': '
',
                                '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>`
        r   zcsv/metar^  z	json/metarY  r   rI  )r   rq   r   to_get_select_object_metar!   r5  GetSelectObjectMetaResult)r,   rE   select_meta_paramsr@   rc  ro   rH   s          r/   create_select_object_metaz Bucket.create_select_object_meta  su    : **73223EF!J/)k=O.O&1F?#$PVW(..r1   c                    t        j                  |      }t        j                  dj	                  | j
                  t        |                   |
t               }t        j                  |vrd|t        j                  <   | j                  d|||      }t        j                  dj	                  |j                  |j                               t        |      S )u  获取文件基本元信息，包括该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>` ；还可能抛出其他异常
        z3Start to get object metadata, bucket: {0}, key: {1}rU   rz  rn   z7Get object metadata done, req_id: {0}, status_code: {1})r   rq   r=   rf   r   rD   r   dictr   
OBJECTMETAr5  rs   r;   GetObjectMetaResultr,   rE   ro   r@   rH   s        r/   get_object_metazBucket.get_object_meta  s     **73JQQRVRbRbdmnqdrst>VFF*(*F6$$%FGLNUUVZVeVegkgrgrst"4((r1   c                    t         j                  dj                  | j                  t	        |                   	 | j                  ||       y# t        j                  $ r Y yt        j                  $ r  t        j                  $ r Y y  xY w)u{   如果文件存在就返回True，否则返回False。如果Bucket不存在，或是发生其他错误，则抛出异常。z6Start to check if object exists, bucket: {0}, key: {1}rq  FT)
r=   rf   r   rD   r   r  r   	NoSuchKeyNoSuchBucketNotFoundr,   rE   r@   s      r/   object_existszBucket.object_exists#  s    $ 	MTTUYUeUegpqtguvw		  g 6  ## 	&& 	"" 		s   A B#%B
Bc           
      ,   t        j                  |      }|rFt        j                  |v r4d|z   dz   t	        |d      z   dz   |t        j                     z   |t
        <   nd|z   dz   t	        |d      z   |t
        <   t        j                  dj                  |t        |      | j                  t        |      |             | j                  d||      }t        j                  dj                  |j                  |j                               t        |      S )u  拷贝一个文件到当前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>`
        r  rU   ?versionId=z^Start to copy object, source bucket: {0}, source key: {1}, bucket: {2}, key: {3}, headers: {4}r   rq  z/Copy object done, req_id: {0}, status_code: {1})r   rq   r   	VERSIONIDr   OSS_COPY_OBJECT_SOURCEr=   rf   r   r   rD   r5  rs   r;   r6  )r,   source_bucket_name
source_key
target_keyr@   ro   rH   s          r/   copy_objectzBucket.copy_objectC  s    **73f&&&0.14F.F/z2.//1>/?AGHXHXAY/ZG*+ /24F.F.LxXbdfOg.gG*+lss"Ij$94;K;KYWaMbdkm	n z7CFMMdoo_c_j_jklt$$r1   c                     |	d|t         <   t        j                  dj                  | j                  t        |                   | j                  | j                  |||      S )u  更改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>`
        REPLACEz6Start to update object metadata, bucket: {0}, key: {1}rq  )OSS_METADATA_DIRECTIVEr=   rf   r   rD   r   r  r  s      r/   update_object_metazBucket.update_object_metaa  s]     .7G*+MTTUYUeUegpqtguvw 0 0#sGLLr1   c                 N   t        j                  |      }t        j                  dj	                  | j
                  t        |                   | j                  d|||      }t        j                  dj	                  |j                  |j                               t        |      S )u  删除一个文件。

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

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

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z-Start to delete object, bucket: {0}, key: {1}r   rn   z1Delete object done, req_id: {0}, status_code: {1})r   rq   r=   r>   r   rD   r   r5  rf   rs   r;   r   r  s        r/   delete_objectzBucket.delete_objectt  s     **73CJJ4K[K[]fgj]klm#fgNHOOPTP_P_aealalmnT""r1   c                    t        j                  |      }t        j                  dj	                  | j
                  t        |                   |
t               }t        j                  |vrd|t        j                  <   | j                  t        t        j                  |      }| j                  d||||      }t        j                  dj	                  |j                  |j                                t#        |      S )ux  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>`
        z.Start to restore object, bucket: {0}, key: {1}rU   r   r   z2Restore object done, req_id: {0}, status_code: {1})r   rq   r=   rf   r   rD   r   r  r   RESTORE_Bucket__convert_dataRestoreConfigurationr   to_put_restore_configr5  rs   r;   r   )r,   rE   ro   r@   inputr   rH   s          r/   restore_objectzBucket.restore_object  s    < **73ELLTM]M]_hil_mno>VF>>'%'F6>>"""#79X9XZ_`FGRVWIPPQUQ`Q`bfbmbmnoT""r1   c                    t         j                  dj                  | j                  t	        |      |             t        j                  |      }||t        <   |
t               }t        j                  |vrd|t        j                  <   | j                  d|||      }t         j                  dj                  |j                  |j                               t        |      S )u  设置文件的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>`
        z8Start to put object acl, bucket: {0}, key: {1}, acl: {2}rU   r   rn   z2Put object acl done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r   rq   OSS_OBJECT_ACLr  r   ACLr5  rs   r;   r   )r,   rE   
permissionro   r@   rH   s         r/   put_object_aclzBucket.put_object_acl  s     	OVVinj: 	; **73",>VF::V#!#F6::s67KIPPQUQ`Q`bfbmbmnoT""r1   c                    t         j                  dj                  | j                  t	        |                   t        j                  |      }|
t               }t        j                  |vrd|t        j                  <   | j                  d|||      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t               S )u  获取文件的ACL。

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

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

        :return: :class:`GetObjectAclResult <oss2.models.GetObjectAclResult>`
        z.Start to get object acl, bucket: {0}, key: {1}rU   rm   rn   z2Get object acl done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r   rq   r  r   r  r5  rs   r;   rT   r   parse_get_object_aclGetObjectAclResultr  s        r/   get_object_aclzBucket.get_object_acl  s     	ELLTM]M]_hil_mno**73>VF::V#!#F6::s67KIPPQUQ`Q`bfbmbmno!!$	(F(FHZ[[r1   c                    |st        d      t        j                  dj                  | j                  |             t        j                  |d      }t        j                  |      }t        j                  |      |d<   | j                  d|ddd|	      }t        j                  d
j                  |j                  |j                               | j                  |t
        j                  t               S )u!  批量删除文件。待删除文件列表不能为空。

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

        :param headers: HTTP头部

        :return: :class:`BatchDeleteObjectsResult <oss2.models.BatchDeleteObjectsResult>`
        zkey_list should not be emptyz/Start to delete objects, bucket: {0}, keys: {1}FContent-MD5r   rU   r  deleter!  r   ro   r@   z2Delete objects done, req_id: {0}, status_code: {1})r   r=   rf   r   rD   r   to_batch_delete_objects_requestr   rq   r   content_md5r"  rs   r;   rT   parse_batch_delete_objectsBatchDeleteObjectsResult)r,   key_listr@   r   rH   s        r/   batch_delete_objectszBucket.batch_delete_objects  s     <==FMMdN^N^`hij885I**73!&!2!24!8%)24u'M(/   1 	IPPQUQ`Q`bfbmbmno!!$	(L(LNfggr1   c                    |st        d      t        j                  dj                  | j                               t        j                  |d      }t        j                  |      }t        j                  |      |d<   | j                  d|ddd|	      }t        j                  d
j                  |j                  |j                               | j                  |t
        j                  t               S )u{  批量删除带版本文件。待删除文件列表不能为空。

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

        :param headers: HTTP头部

        :return: :class:`BatchDeleteObjectsResult <oss2.models.BatchDeleteObjectsResult>`
        z$keylist_versions should not be emptyz,Start to delete object versions, bucket: {0}Fr  r   rU   r  r  r  z:Delete object versions done, req_id: {0}, status_code: {1})r   r=   rf   r   rD   r   'to_batch_delete_objects_version_requestr   rq   r   r  r"  rs   r;   rT   r  r  )r,   keylist_versionsr@   r   rH   s        r/   delete_object_versionszBucket.delete_object_versions  s      DEECJJ4K[K[\]@@AQSXY**73!&!2!24!8%)24u'M(/   1 	QXXY]YhYhjnjujuvw!!$	(L(LNfggr1   c                    t        j                  t        j                  |      |      }|t	               }n|j                         }d|d<   t        j                  dj                  | j                  t        |      ||             | j                  d|||      }t        j                  dj                  |j                  |j                               | j                  |t        j                   t"              S )u  初始化分片上传。

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

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

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

        :return: :class:`InitMultipartUploadResult <oss2.models.InitMultipartUploadResult>`
        rU   uploadszQStart to init multipart upload, bucket: {0}, keys: {1}, headers: {2}, params: {3}r   rn   z9Init multipart upload done, req_id: {0}, status_code: {1})r   r2  r   rq   r  copyr=   rf   r   rD   r   r5  rs   r;   rT   r   parse_init_multipart_uploadInitMultipartUploadResult)r,   rE   r@   ro   
tmp_paramsrH   s         r/   init_multipart_uploadzBucket.init_multipart_upload  s     (()A)A')JCP>JJ "
9hooingzC 	DJPPWWX\XgXgimitituv!!$	(M(MOhiir1   c           	         t        j                  |      }|rt        j                  ||      }| j                  rt        j
                  |      }t        j                  dj                  | j                  t        |      |||             | j                  d||t        |      d||      }t        j                  dj                  |j                  |j                               t        |      }| j                  rB|j                   6t        j"                  d|j                   |j                   |j                         |S )u  上传一个分片。

        :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>`
        z`Start to upload multipart, bucket: {0}, key: {1}, upload_id: {2}, part_number: {3}, headers: {4}r   )uploadId
partNumberr   z4Upload multipart done, req_id: {0}, status_code: {1}zupload part)r   rq   r   r3  r#   r4  r=   rf   r   rD   r   r5  rp   rs   r;   r6  r7  r8  )	r,   rE   	upload_idpart_numberr   r9  r@   rH   rS   s	            r/   upload_partzBucket.upload_part9  s
    **73..t5FGD??))$/Dnuu  )C.)['S	T s4=SQ\M]'^(/%)   + 	KRRSWSbSbdhdodopq &??vzz5OOM488VZZARARSr1   c                 H   t        j                  |      }d}|#t        |d       }t        j                  |      }t
        j                  dj                  | j                  t        |      ||             | j                  d|d|i||      }t
        j                  dj                  |j                  |j                               t        |      }| j                  rC|At        j                   |      }t        j"                  d	||j$                  |j                         |S )
ue  完成分片上传，创建文件。

        :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>`
        Nc                     | j                   S rP   )r  )ps    r/   <lambda>z2Bucket.complete_multipart_upload.<locals>.<lambda>p  s
     r1   )rE   zUStart to complete multipart upload, bucket: {0}, key: {1}, upload_id: {2}, parts: {3}r   r  )ro   r   r@   z=Complete multipart upload done, req_id: {0}, status_code: {1}zmultipart upload)r   rq   sortedr   to_complete_upload_requestr=   rf   r   rD   r   r5  rs   r;   r6  r#   r   calc_obj_crc_from_partsr8  r7  )	r,   rE   r  partsr@   r   rH   rS   
object_crcs	            r/   complete_multipart_uploadz Bucket.complete_multipart_upload^  s
    **735&=>E77>Dlssini? 	@ (2I'>%)(/   1 	KRRSWSbSbdhdodop	r !&??u066u=JOO.
FJJHYHYZr1   c                 T   t         j                  dj                  | j                  t	        |      |             t        j                  |      }| j                  d|d|i|      }t         j                  dj                  |j                  |j                               t        |      S )ux  取消分片上传。

        :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>`
        zFStart to abort multipart upload, bucket: {0}, key: {1}, upload_id: {2}r   r  rn   z3Abort multipart done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r   rq   r5  rs   r;   r   )r,   rE   r  r@   rH   s        r/   abort_multipart_uploadzBucket.abort_multipart_upload  s     	]ddini9 	: **73#(2I'>   QJQQRVRaRacgcncnopT""r1   c                    t         j                  dj                  | j                  t	        |      |t	        |      ||             t        j                  |      }| j                  dd||||t        |      dd|      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u  罗列正在进行中的分片上传。支持分页。

        :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>`
        zStart to list multipart uploads, bucket: {0}, prefix: {1}, delimiter: {2}, key_marker: {3}, upload_id_marker: {4}, max_uploads: {5}rm   rU   r  )r  rj   r   
key-markerzupload-id-markerzmax-uploadsr!  rn   z:List multipart uploads done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r   rq   r"  rp   rs   r;   rT   r   parse_list_multipart_uploadsListMultipartUploadsResult)r,   rj   r   
key_markerupload_id_markermax_uploadsr@   rH   s           r/   list_multipart_uploadszBucket.list_multipart_uploads  s    ( 	 ??EvdFVFVXabhXiktFOPZF[]mFQ@S	T
 **7335285>6@<L7:;7G9>(@ 18   9 	QXXY]YhYhjnjujuvw!!$	(N(NPjkkr1   c	                    t        j                  |      }|rFt        j                  |v r4d|z   dz   t	        |d      z   dz   |t        j                     z   |t
        <   nd|z   dz   t	        |d      z   |t
        <   t        |      }	|	r	|	|t        <   t        j                  dj                  |t        |      | j                  t        |      ||||             |
t               }||d<   t        |      |d<   | j                  d|||      }
t        j                  d	j                  |
j                   |
j"                               t%        |
      S )
u  分片拷贝。把一个已有文件的一部分或整体拷贝成目标文件的一个分片。
        :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>`
        r  rU   r  zStart to upload part copy, source bucket: {0}, source key: {1}, bucket: {2}, key: {3}, range: {4}, upload id: {5}, part_number: {6}, headers: {7}r  r  r   rn   z4Upload part copy done, req_id: {0}, status_code: {1})r   rq   r   r  r   r  rP  OSS_COPY_OBJECT_SOURCE_RANGEr=   rf   r   r   rD   r  rp   r5  rs   r;   r6  )r,   r  r  rS  r  target_upload_idtarget_part_numberr@   ro   rU  rH   s              r/   upload_part_copyzBucket.upload_part_copy  se   " **73f&&&0.14F.F/z2.//1>/?AGHXHXAY/ZG*+ /24F.F.LxXbdfOg.gG*+ **54@G01 MMSVTfj)$*:*:9Z;P 01CWNN	O
 >VF-z"#56|z'-g   ?KRRSWSbSbdhdodopqt$$r1   c           	         t         j                  dj                  | j                  t	        |      |||             t        j                  |      }| j                  d|||t        |      d|      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u  列举已经上传的分片。支持分页。

        :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>`
        zWStart to list parts, bucket: {0}, key: {1}, upload_id: {2}, marker: {3}, max_parts: {4}rm   )r  zpart-number-markerz	max-partsrn   z.List parts done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r   rq   r5  rp   rs   r;   rT   r   parse_list_partsListPartsResult)r,   rE   r  rk   	max_partsr@   rH   s          r/   
list_partszBucket.list_parts  s     	nuuiniL 	M **73s4=>D58^(E 18	   9
 	ELLT__^b^i^ijk!!$	(B(BOTTr1   c           	         t        j                  |      }t        |d      |t        <   t        j                  dj                  | j                  t        |      t        |      |             | j                  d||t        j                  di      }t        j                  dj                  |j                  |j                               t        |      S )u  创建Symlink。

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

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

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        rU   zRStart to put symlink, bucket: {0}, target_key: {1}, symlink_key: {2}, headers: {3}r   rO  z/Put symlink done, req_id: {0}, status_code: {1})r   rq   r   OSS_SYMLINK_TARGETr=   rf   r   rD   r   r5  r   SYMLINKrs   r;   r   )r,   r  symlink_keyr@   rH   s        r/   put_symlinkzBucket.put_symlink  s     **73&.z2&>"#ippi
3Y{5KWV 	W{GV^^]_L`aFMMdoo_c_j_jklT""r1   c                    t         j                  dj                  | j                  t	        |                   t        j                  |      }|
t               }t        j                  |vrd|t        j                  <   | j                  d|||      }t         j                  dj                  |j                  |j                               t        |      S )u  获取符号连接文件的目标文件。

        :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>` ；还可能抛出其他异常
        z3Start to get symlink, bucket: {0}, symlink_key: {1}rU   rm   rn   z/Get symlink done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r   rq   r  r   r  r5  rs   r;   GetSymlinkResult)r,   r  ro   r@   rH   s        r/   get_symlinkzBucket.get_symlink!  s     	AHHIYIY[dep[qr	t **73>VF>>'%'F6>>"{67SFMMdoo_c_j_jkl%%r1   c                    t        j                  |      }|r	||t        <   | j                  t        t
        j                  |      }t        j                  dj                  | j                  ||             | j                  d||      }t        j                  dj                  |j                  |j                               t        |      S )u9  创建新的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
        zAStart to create bucket, bucket: {0}, permission: {1}, config: {2}r   )r@   r   z1Create bucket done, req_id: {0}, status_code: {1})r   rq   OSS_CANNED_ACLr  BucketCreateConfigr   to_put_bucket_configr=   rf   r   rD   r"  rs   r;   r   )r,   r  r  r@   r   rH   s         r/   create_bucketzBucket.create_bucket=  s     **73&0GN#""#5y7U7UW\]X__`d`p`p`jlpr 	swTBHOOPTP_P_aealalmnT""r1   c                    t         j                  dj                  | j                               | j	                  d      }t         j                  dj                  |j                  |j                               t        |      S )u=  删除一个Bucket。只有没有任何文件，也没有任何未完成的分片上传的Bucket才能被删除。

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

        ":raises: 如果试图删除一个非空Bucket，则抛出 :class:`BucketNotEmpty <oss2.exceptions.BucketNotEmpty>`
        z#Start to delete bucket, bucket: {0}r   z1Delete bucket done, req_id: {0}, status_code: {1})	r=   r>   r   rD   r"  rf   rs   r;   r   r~   s     r/   delete_bucketzBucket.delete_bucketP  se     	9@@AQAQRS)HOOPTP_P_aealalmnT""r1   c                 <   t         j                  dj                  | j                  |             | j	                  dt
        |it        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )u   设置Bucket的ACL。

        :param str permission: 新的ACL，可以是oss2.BUCKET_ACL_PRIVATE、oss2.BUCKET_ACL_PUBLIC_READ或
            oss2.BUCKET_ACL_PUBLIC_READ_WRITE
        z.Start to put bucket acl, bucket: {0}, acl: {1}r   rU   rO  z2Put bucket acl done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r  r   r  rs   r;   r   )r,   r  rH   s      r/   put_bucket_aclzBucket.put_bucket_acl\  s     	ELLTM]M]_ijk
/KU[U_U_acTdeIPPQUQ`Q`bfbmbmnoT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )um   获取Bucket的ACL。

        :return: :class:`GetBucketAclResult <oss2.models.GetBucketAclResult>`
        z$Start to get bucket acl, bucket: {0}rm   rU   rz   z2Get bucket acl done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  rs   r;   rT   r   parse_get_bucket_aclGetBucketAclResultr~   s     r/   get_bucket_aclzBucket.get_bucket_aclg  s    
 	;BB4CSCSTUvzz2.>?IPPQUQ`Q`bfbmbmno!!$	(F(FHZ[[r1   c                 z   | j                  t        t        j                  |      }t        j                  dj                  | j                  |             | j                  d|t        j                  di      }t        j                  dj                  |j                  |j                               t        |      S )us   设置Bucket的CORS。

        :param input: :class:`BucketCors <oss2.models.BucketCors>` 对象或其他
        z0Start to put bucket cors, bucket: {0}, cors: {1}r   rU   r   z3Put bucket cors done, req_id: {0}, status_code: {1})r  
BucketCorsr   to_put_bucket_corsr=   rf   r   rD   r"  r   CORSrs   r;   r   r,   r  r   rH   s       r/   put_bucket_corszBucket.put_bucket_corsq  s    
 "":y/K/KUSGNNtO_O_aefgD&++r9JKJQQRVRaRacgcncnopT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )uv   获取Bucket的CORS配置。

        :return: :class:`GetBucketCorsResult <oss2.models.GetBucketCorsResult>`
        z%Start to get bucket CORS, bucket: {0}rm   rU   rz   z3Get bucket CORS done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  rs   r;   rT   r   parse_get_bucket_corsGetBucketCorsResultr~   s     r/   get_bucket_corszBucket.get_bucket_cors|      
 	<CCDDTDTUVv{{B.?@JQQRVRaRacgcncnop!!$	(G(GI\]]r1   c                 ,   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )u   删除Bucket的CORS配置。z(Start to delete bucket CORS, bucket: {0}r   rU   rz   z6Delete bucket CORS done, req_id: {0}, status_code: {1})
r=   rf   r   rD   r"  r   r  rs   r;   r   r~   s     r/   delete_bucket_corszBucket.delete_bucket_cors  sq    ?FFtGWGWXY&++r1BCMTTUYUdUdfjfqfqrsT""r1   c                    t        j                  |      }| j                  t        t        j
                  |      }t        j                  dj                  | j                  |             | j                  d|t        j                  di|      }t        j                  dj                  |j                  |j                               t        |      S )u   设置生命周期管理的配置。

        :param input: :class:`BucketLifecycle <oss2.models.BucketLifecycle>` 对象或其他
        z:Start to put bucket lifecycle, bucket: {0}, lifecycle: {1}r   rU   r  8Put bucket lifecycle done, req_id: {0}, status_code: {1})r   rq   r  BucketLifecycler   to_put_bucket_lifecycler=   rf   r   rD   r"  r   	LIFECYCLErs   r;   r   )r,   r  r@   r   rH   s        r/   put_bucket_lifecyclezBucket.put_bucket_lifecycle  s    
 **73""?I4U4UW\]QXXY]YiYikopqD&:J:JB9OY`aOVVW[WfWfhlhshstuT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取生命周期管理配置。

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

        :raises: 如果没有设置Lifecycle，则抛出 :class:`NoSuchLifecycle <oss2.exceptions.NoSuchLifecycle>`
        z*Start to get bucket lifecycle, bucket: {0}rm   rU   rz   z8Get bucket lifecycle done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  rs   r;   rT   r   parse_get_bucket_lifecycleGetBucketLifecycleResultr~   s     r/   get_bucket_lifecyclezBucket.get_bucket_lifecycle  s     	AHHIYIYZ[v/?/?.DEOVVW[WfWfhlhshstu!!$	(L(LNfggr1   c                 ,   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )uQ   删除生命周期管理配置。如果Lifecycle没有设置，也返回成功。z-Start to delete bucket lifecycle, bucket: {0}r   rU   rz   z;Delete bucket lifecycle done, req_id: {0}, status_code: {1})
r=   rf   r   rD   r"  r   r  rs   r;   r   r~   s     r/   delete_bucket_lifecyclezBucket.delete_bucket_lifecycle  ss    DKKDL\L\]^&2B2BB1GHRYYZ^ZiZikokvkvwxT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取Bucket的数据中心。

        :return: :class:`GetBucketLocationResult <oss2.models.GetBucketLocationResult>`
        z)Start to get bucket location, bucket: {0}rm   rU   rz   z7Get bucket location done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   LOCATIONrs   r;   rT   r   parse_get_bucket_locationGetBucketLocationResultr~   s     r/   get_bucket_locationzBucket.get_bucket_location  s    
 	@GGHXHXYZv.CDNUUVZVeVegkgrgrst!!$	(K(KMdeer1   c                 z   | j                  t        t        j                  |      }t        j                  dj                  | j                  |             | j                  d|t        j                  di      }t        j                  dj                  |j                  |j                               t        |      S )u   设置Bucket的访问日志功能。

        :param input: :class:`BucketLogging <oss2.models.BucketLogging>` 对象或其他
        z6Start to put bucket logging, bucket: {0}, logging: {1}r   rU   r   z6Put bucket logging done, req_id: {0}, status_code: {1})r  BucketLoggingr   to_put_bucket_loggingr=   rf   r   rD   r"  r   LOGGINGrs   r;   r   r   s       r/   put_bucket_loggingzBucket.put_bucket_logging  s    
 ""=)2Q2QSXYMTTUYUeUegklmD&.."9MNMTTUYUdUdfjfqfqrsT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取Bucket的访问日志功能配置。

        :return: :class:`GetBucketLoggingResult <oss2.models.GetBucketLoggingResult>`
        z(Start to get bucket logging, bucket: {0}rm   rU   rz   z6Get bucket logging done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  rs   r;   rT   r   parse_get_bucket_loggingGetBucketLoggingResultr~   s     r/   get_bucket_loggingzBucket.get_bucket_logging      
 	?FFtGWGWXYv~~r.BCMTTUYUdUdfjfqfqrs!!$	(J(JLbccr1   c                 ,   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )u$   关闭Bucket的访问日志功能。z,Start to delete bucket loggging, bucket: {0}r   rU   rz   r
  )
r=   rf   r   rD   r"  r   r  rs   r;   r   r~   s     r/   delete_bucket_loggingzBucket.delete_bucket_logging  sq    CJJ4K[K[\]&.."1EFOVVW[WfWfhlhshstuT""r1   c                    | j                  t        t        j                  |      }t        j                  dj                  | j                  t        |                   | j                  d|t        j                  di      }t        j                  dj                  |j                  |j                               t        |      S )u~   为Bucket设置防盗链。

        :param input: :class:`BucketReferer <oss2.models.BucketReferer>` 对象或其他
        z6Start to put bucket referer, bucket: {0}, referer: {1}r   rU   r   z6Put bucket referer done, req_id: {0}, status_code: {1})r  BucketRefererr   to_put_bucket_refererr=   rf   r   rD   r   r"  r   REFERERrs   r;   r   r   s       r/   put_bucket_refererzBucket.put_bucket_referer  s    
 ""=)2Q2QSXYMTTUYUeUegpqugvwxD&.."9MNMTTUYUdUdfjfqfqrsT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取Bucket的防盗链配置。

        :return: :class:`GetBucketRefererResult <oss2.models.GetBucketRefererResult>`
        z(Start to get bucket referer, bucket: {0}rm   rU   rz   z6Get bucket referer done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r)  rs   r;   rT   r   parse_get_bucket_refererGetBucketRefererResultr~   s     r/   get_bucket_refererzBucket.get_bucket_referer  r#  r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   查看Bucket的状态，目前包括bucket大小，bucket的object数量，bucket正在上传的Multipart Upload事件个数等。

        :return: :class:`GetBucketStatResult <oss2.models.GetBucketStatResult>`
        z%Start to get bucket stat, bucket: {0}rm   rU   rz   z3Get bucket stat done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   STATrs   r;   rT   r   parse_get_bucket_statGetBucketStatResultr~   s     r/   get_bucket_statzBucket.get_bucket_stat  r  r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取bucket相关信息，如创建时间，访问Endpoint，Owner与ACL等。

        :return: :class:`GetBucketInfoResult <oss2.models.GetBucketInfoResult>`
        z%Start to get bucket info, bucket: {0}rm   rU   rz   z3Get bucket info done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   BUCKET_INFOrs   r;   rT   r   parse_get_bucket_infoGetBucketInfoResultr~   s     r/   get_bucket_infozBucket.get_bucket_info  s    
 	<CCDDTDTUVv/A/A2.FGJQQRVRaRacgcncnop!!$	(G(GI\]]r1   c                    | j                  t        t        j                  |      }t	        j
                         }t        j                  |      |d<   t        j                  dj                  | j                  t        |                   | j                  d|t        j                  di|      }t        j                  dj                  |j                   |j"                               t%        |      S )u}   为Bucket配置静态网站托管功能。

        :param input: :class:`BucketWebsite <oss2.models.BucketWebsite>`
        r  z6Start to put bucket website, bucket: {0}, website: {1}r   rU   r  z6Put bucket website done, req_id: {0}, status_code: {1})r  BucketWebsiter   to_put_bucket_websiter   rq   r   r  r=   rf   r   rD   r   r"  r   WEBSITErs   r;   r   )r,   r  r   r@   rH   s        r/   put_bucket_websitezBucket.put_bucket_website  s    
 ""=)2Q2QSXY**,!&!2!24!8MTTUYUeUegpqugvwxD&.."9MW^_MTTUYUdUdfjfqfqrsT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u
  获取Bucket的静态网站托管配置。

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

        :raises: 如果没有设置静态网站托管，那么就抛出 :class:`NoSuchWebsite <oss2.exceptions.NoSuchWebsite>`
        z(Start to get bucket website, bucket: {0}rm   rU   rz   z6Get bucket website done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r<  rs   r;   rT   r   parse_get_bucket_websiteGetBucketWebsiteResultr~   s     r/   get_bucket_websitezBucket.get_bucket_website
  s     	?FFtGWGWXYv~~r.BCMTTUYUdUdfjfqfqrs!!$	(J(JLbccr1   c                 ,   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )u*   关闭Bucket的静态网站托管功能。z+Start to delete bucket website, bucket: {0}r   rU   rz   z9Delete bucket website done, req_id: {0}, status_code: {1})
r=   rf   r   rD   r"  r   r<  rs   r;   r   r~   s     r/   delete_bucket_websitezBucket.delete_bucket_website  sq    BII$JZJZ[\&.."1EFPWWX\XgXgimitituvT""r1   c           	         | j                  t        t        j                  |      }t        j                  dj                  | j                  t        |      t        |                   | j                  d||t        j                  di      }t        j                  dj                  |j                  |j                               | j                  |t        j                  t               S )u  创建推流直播频道

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

        :return: :class:`CreateLiveChannelResult <oss2.models.CreateLiveChannelResult>`
        zGStart to create live-channel, bucket: {0}, channel_name: {1}, info: {2}r   rU   r   z7Create live-channel done, req_id: {0}, status_code: {1})r  LiveChannelInfor   to_create_live_channelr=   rf   r   rD   r   r5  r   LIVErs   r;   rT   parse_create_live_channelCreateLiveChannelResult)r,   r  r  r   rH   s        r/   create_live_channelzBucket.create_live_channel  s     ""?I4T4TV[\^eei5yH 	I|$UWGXYNUUVZVeVegkgrgrst!!$	(K(KMdeer1   c                 B   t         j                  dj                  | j                  t	        |                   | j                  d|t        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )ue   删除推流直播频道

        :param str channel_name: 要删除的live channel的名称
        z<Start to delete live-channel, bucket: {0}, live_channel: {1}r   rU   rz   z7Delete live-channel done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r5  r   rG  rs   r;   r   r,   r  rH   s      r/   delete_live_channelzBucket.delete_live_channel.  s    
 	SZZi57 	8,R?PQNUUVZVeVegkgrgrstT""r1   c                 v   t         j                  dj                  | j                  t	        |                   | j                  d|t        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取直播频道配置

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

        :return: :class:`GetLiveChannelResult <oss2.models.GetLiveChannelResult>`
        z>Start to get live-channel info: bucket: {0}, live_channel: {1}rm   rU   rz   z4Get live-channel done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r5  r   rG  rs   r;   rT   r   parse_get_live_channelGetLiveChannelResultrL  s      r/   get_live_channelzBucket.get_live_channel9  s     	U\\i57 	8|V[["<MNKRRSWSbSbdhdodopq!!$	(H(HJ^__r1   c                    t         j                  dj                  | j                  t	        |      t	        |      |             | j                  dt        j                  dd|d|dt        |      i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )	uN  列举出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>`
        zQStart to list live-channels, bucket: {0}, prefix: {1}, marker: {2}, max_keys: {3}rm   rU   rj   rk   rl   rz   z5List live-channel done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r"  r   rG  rp   rs   r;   rT   r   parse_list_live_channelListLiveChannelResult)r,   rj   rk   rv   rH   s        r/   list_live_channelzBucket.list_live_channelF  s     	hooi/61BHN 	Ov{{B/7/7/93x=/J K 	LSSTXTcTceiepepqr!!$	(I(IK`aar1   c                    t         j                  dj                  | j                  t	        |                   | j                  d|t        j                  dt        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取live channel当前推流的状态

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

        return: :class:`GetLiveChannelStatResult <oss2.models.GetLiveChannelStatResult>`
        z>Start to get live-channel stat, bucket: {0}, channel_name: {1}rm   rU   r   rz   z9Get live-channel stat done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r5  r   rG  COMPrs   r;   rT   r   parse_live_channel_statGetLiveChannelStatResultrL  s      r/   get_live_channel_statzBucket.get_live_channel_statX  s     	U\\i57 	8|V[["fkk[a<bcPWWX\XgXgimitituv!!$	(I(IKcddr1   c                 d   t         j                  dj                  | j                  t	        |      |             | j                  d|t        j                  dt        j                  |i      }t         j                  dj                  |j                  |j                               t        |      S )u   更改live channel的status，仅能在“enabled”和“disabled”两种状态中更改

        param str channel_name: 要更改status的live channel的名称
        param str status: live channel的目标status
        zMStart to put live-channel status, bucket: {0}, channel_name: {1}, status: {2}r   rU   rz   z;Put live-channel status done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r5  r   rG  STATUSrs   r;   r   )r,   r  r;   rH   s       r/   put_live_channel_statuszBucket.put_live_channel_statusf  s     	dkki5v? 	@|V[["fmm]c<deRYYZ^ZiZikokvkvwxT""r1   c                    t         j                  dj                  | j                  t	        |                   | j                  d|t        j                  dt        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u0  获取live channel中最近的最多十次的推流记录，记录中包含推流的起止时间和远端的地址

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

        return: :class:`GetLiveChannelHistoryResult <oss2.models.GetLiveChannelHistoryResult>`
        zAStart to get live-channel history, bucket: {0}, channel_name: {1}rm   rU   historyrz   z<Get live-channel history done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r5  r   rG  rW  rs   r;   rT   r   parse_live_channel_historyGetLiveChannelHistoryResultrL  s      r/   get_live_channel_historyzBucket.get_live_channel_historyr  s     	X__i57 	8|V[["fkk[d<efJQQRVRaRacgcncno	q!!$	(L(LNijjr1   c                    t         j                  dj                  | j                  t	        |      |||             |dz   |z   }| j                  d|t        j                  ddt        |      dt        |      i      }t         j                  dj                  |j                  |j                               t        |      S )	u  根据指定的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())获取
        znStart to post vod playlist, bucket: {0}, channel_name: {1}, playlist_name: {2}, start_time: {3}, end_time: {4}r  r   rU   	startTimeendTimerz   z5Post vod playlist done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r5  r   VODrp   rs   r;   r   )r,   r  r  
start_timeend_timerE   rH   s          r/   post_vod_playlistzBucket.post_vod_playlist  s     	 **0&1A1A9\CZ\iku19+;	< S =0VZZ[RUV`Ra5>H5O PLSSTXTcTceiepepqrT""r1   c                 v   t         j                  dj                  | j                  t	        |      ||             | j                  d|t        j                  ddt        |      dt        |      i      }t         j                  dj                  |j                  |j                               t        |      }|S )uS  查看指定时间段内的播放列表

        param str channel_name: 要获取点播列表的live channel的名称
        param int start_time: 点播的起始时间，Unix Time格式，可以使用int(time.time())获取
        param int end_time: 点播的结束时间，Unix Time格式，可以使用int(time.time())获取
        zZStart to get vod playlist, bucket: {0}, channel_name: {1},  start_time: {2}, end_time: {3}rm   rU   rd  re  rz   z4get vod playlist done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r5  r   rf  rp   rs   r;   GetVodPlaylistResult)r,   r  rg  rh  rH   rS   s         r/   get_vod_playlistzBucket.get_vod_playlist  s     	 **0&1A1A9\CZ]giq*r	t|VZZ[Z]^hZi5>H=O PKRRSWSbSbdhdodopq%d+r1   c                    t        j                  |      }t        j                  dj	                  | j
                  t        |      |             t        j                  d|}| j                  d|t        j                  di||      }t        j                  dj	                  |j                  |j                               t        |      S )u  处理图片的接口，支持包括调整大小，旋转，裁剪，水印，格式转换等，支持多种方式组合处理。

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

        :param headers: HTTP头部
        :type headers: 可以是dict，建议是oss2.CaseInsensitiveDict
        z<Start to process object, bucket: {0}, key: {1}, process: {2}=r   rU   r   z2Process object done, req_id: {0}, status_code: {1})r   rq   r=   rf   r   rD   r   r   rQ  r5  rs   r;   ProcessObjectResultr,   rE   rT  r@   process_datarH   s         r/   process_objectzBucket.process_object  s     **73SZZing7 	8"(..':V^^R4HRY`lmIPPQUQ`Q`bfbmbmno"4((r1   c                 l   t         j                  dj                  | j                  t	        |      |             |t        j                  |      }|
t               }d|t        j                  <   | j                  t        t        j                  |      }| j                  d||||      }t        |      S )u  

        :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>`
        z@Start to put object tagging, bucket: {0}, key: {1}, tagging: {2}rU   r   r  )r=   rf   r   rD   r   r   rq   r  r   TAGGINGr  Taggingr   to_put_taggingr5  r   )r,   rE   r   r@   ro   r   rH   s          r/   put_object_taggingzBucket.put_object_tagging  s     	W^^ing7 	8 ..w7G>VF!#v~~""7I,D,DgNsfgVT""r1   c           	      b   t         j                  dj                  | j                  t	        |      t        |                   t        j                  |      }|
t               }d|t        j                  <   | j                  d|||      }| j                  |t        j                  t              S )u#  
        :param str key: 要获取tagging的对象名称
        :param dict params: 请求参数

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

        :return: :class:`GetTaggingResult <oss2.models.GetTaggingResult>` 
        z>Start to get object tagging, bucket: {0}, key: {1} params: {2}rU   rm   rn   )r=   rf   r   rD   r   rp   r   rq   r  r   rt  r5  rT   r   parse_get_taggingGetTaggingResultr  s        r/   get_object_taggingzBucket.get_object_tagging  s     	U\\$$inc&kC 	D **73>VF!#v~~s67K!!$	(C(CEUVVr1   c                    t         j                  dj                  | j                  t	        |                   t        j                  |      }|
t               }d|t        j                  <   | j                  d|||      }t         j                  dj                  |j                  |j                               t        |      S )u  
        :param str key: 要删除tagging的对象名称
        :param dict params: 请求参数

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

        :return: :class:`RequestResult <oss2.models.RequestResult>` 
        z5Start to delete object tagging, bucket: {0}, key: {1}rU   r   rn   z9Delete object tagging done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r   rq   r  r   rt  r5  rs   r;   r   r  s        r/   delete_object_taggingzBucket.delete_object_tagging  s     	LSS$$in6 	7 **73>VF!#v~~#fgNPWWX\XgXgimitituvT""r1   c                 z   | j                  t        t        j                  |      }t        j                  dj                  | j                  |             | j                  d|t        j                  di      }t        j                  dj                  |j                  |j                               t        |      S )u   设置bucket加密配置。

        :param rule: :class:` ServerSideEncryptionRule<oss2.models.ServerSideEncryptionRule>` 对象
        z6Start to put bucket encryption, bucket: {0}, rule: {1}r   rU   r   z9Put bucket encryption done, req_id: {0}, status_code: {1})r  ServerSideEncryptionRuler   to_put_bucket_encryptionr=   rf   r   rD   r"  r   
ENCRYPTIONrs   r;   r   )r,   ruler   rH   s       r/   put_bucket_encryptionzBucket.put_bucket_encryption	  s    
 ""#;Y=_=_aefMTTUYUeUegklmD&:K:KR9PQPWWX\XgXgimitituvT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u$  获取bucket加密配置。

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

        :raises: 如果没有设置Bucket encryption，则抛出 :class:`NoSuchServerSideEncryptionRule <oss2.exceptions.NoSuchServerSideEncryptionRule>`
        z+Start to get bucket encryption, bucket: {0}rm   rU   rz   z9Get bucket encryption done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  rs   r;   rT   r   parse_get_bucket_encryptionGetServerSideEncryptionResultr~   s     r/   get_bucket_encryptionzBucket.get_bucket_encryption	  s     	BII$JZJZ[\v/@/@".EFPWWX\XgXgimitituv!!$	(M(MOlmmr1   c                 ,   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )uN   删除Bucket加密配置。如果Bucket加密没有设置，也返回成功。z.Start to delete bucket encryption, bucket: {0}r   rU   rz   z<Delete bucket encryption done, req_id: {0}, status_code: {1})
r=   rf   r   rD   r"  r   r  rs   r;   r   r~   s     r/   delete_bucket_encryptionzBucket.delete_bucket_encryption	  ss    ELLTM]M]^_&2C2CR1HISZZ[_[j[jlplwlwxyT""r1   c                    t         j                  dj                  | j                  |             t	        j
                  |      }| j                  t        t        j                  |      }| j                  d|t        j                  di|      }t         j                  dj                  |j                  |j                               t        |      S )u  

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

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

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z5Start to put object tagging, bucket: {0} tagging: {1}r   rU   r  z6Put bucket tagging done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   rq   r  ru  r   rv  r"  r   rt  rs   r;   r   )r,   r   r@   r   rH   s        r/   put_bucket_taggingzBucket.put_bucket_tagging#	  s     	LSSg' 	( **73""7I,D,DgND&.."9MW^_MTTUYUdUdfjfqfqrsT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   
        :param str key: 要获取tagging的对象名称
        :param dict params: 请求参数
        :return: :class:`GetTaggingResult<oss2.models.GetTaggingResult>` 
        z(Start to get bucket tagging, bucket: {0}rm   rU   rz   z6Get bucket tagging done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   rt  rs   r;   rT   r   ry  rz  r~   s     r/   get_bucket_taggingzBucket.get_bucket_tagging8	  s     	?FF$$& 	' v~~r.BCMTTUYUdUdfjfqfqrs!!$	(C(CEUVVr1   c                 n   t         j                  dj                  | j                               |
t	               }t
        j                  |vrd|t
        j                  <   | j                  d|      }t         j                  dj                  |j                  |j                               t        |      S )zN
        :return: :class:`RequestResult <oss2.models.RequestResult>` 
        z+Start to delete bucket tagging, bucket: {0}rU   r   rz   z9Delete bucket tagging done, req_id: {0}, status_code: {1})r=   rf   r   rD   r  r   rt  r"  rs   r;   r   )r,   ro   rH   s      r/   delete_bucket_taggingzBucket.delete_bucket_taggingG	  s     	BII$$& 	' >VF>>'%'F6>>" 8PWWOOT[[2 	3T""r1   c                    t         j                  ddj                  | j                  t	        |      |t	        |      t	        |      |      z          t        j                  |      }| j                  dd|d|d|d|dt        |      d	d
t        j                  di|      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t               S )u  根据前缀罗列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>`
        zHStart to List object versions, bucket: {0}, prefix: {1}, delimiter: {2},z5key_marker: {3}, versionid_marker: {4}, max-keys: {5}rm   rj   r   r  zversion-id-markerrl   r!  r  rU   rn   z8List object versions done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r   rq   r"  rp   r   VERSIONSrs   r;   rT   r   parse_list_object_versionsListObjectVersionsResult)r,   rj   r   r  rv   versionid_markerr@   rH   s           r/   list_object_versionszBucket.list_object_versions[	  s      	VDKKi/Ij<Q&'33	4 **73(0&(3Y(4j(;=M(2CM(7(.(= 18   9 	O5	7 !!$	(L(LNfggr1   c                    t         j                  dj                  | j                               | j	                  t
        t        j                  |      }t        j                  |      }t        j                  |      |d<   | j                  d|t        j                  di|      }t         j                  dj                  |j                  |j                                t#        |      S )u   

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

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z+Start to put object versioning, bucket: {0}r  r   rU   r  z7Put bucket versiong done, req_id: {0}, status_code: {1})r=   rf   r   rD   r  BucketVersioningConfigr   to_put_bucket_versioningr   rq   r   r  r"  r   
VERSIONINGrs   r;   r   )r,   configr@   r   rH   s        r/   put_bucket_versioningzBucket.put_bucket_versioning	  s     	BII$JZJZ[\""#99;];]_ef**73!&!2!24!8D&:K:KR9PZabNUUVZVeVegkgrgrstT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )ze
        :return: :class:`GetBucketVersioningResult<oss2.models.GetBucketVersioningResult>` 
        z+Start to get bucket versioning, bucket: {0}rm   rU   rz   z7Get bucket versiong done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  rs   r;   rT   r   parse_get_bucket_versioningGetBucketVersioningResultr~   s     r/   get_bucket_versioningzBucket.get_bucket_versioning	  s     	BII$JZJZ[\v/@/@".EFNUUVZVeVegkgrgrst!!$	(M(MOhiir1   c           	      \   t         j                  dj                  | j                  |             | j	                  d|t
        j                  didt        j                  |      i      }t         j                  dj                  |j                  |j                               t        |      S )uy   设置bucket授权策略, 具体policy书写规则请参考官方文档

        :param str policy: 授权策略
        z4Start to put bucket policy, bucket: {0}, policy: {1}r   rU   r  r  z5Put bucket policy done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   POLICYr   r  rs   r;   r   )r,   r   rH   s      r/   put_bucket_policyzBucket.put_bucket_policy	  s    
 	KRRSWScSceklmFFMM2;NYfhmhyhy  {A  iB  YC  DLSSTXTcTceiepepqrT""r1   c                 ,   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )uv   获取bucket授权策略

        :return: :class:`GetBucketPolicyResult <oss2.models.GetBucketPolicyResult>`
        z'Start to get bucket policy, bucket: {0}rm   rU   rz   z5Get bucket policy done, req_id: {0}, status_code: {1})
r=   rf   r   rD   r"  r   r  rs   r;   GetBucketPolicyResultr~   s     r/   get_bucket_policyzBucket.get_bucket_policy	  ss     	>EEdFVFVWXv}}R.@ALSSTXTcTceiepepqr$T**r1   c                 ,   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )ue   删除bucket授权策略
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z*Start to delete bucket policy, bucket: {0}r   rU   rz   z8Delete bucket policy done, req_id: {0}, status_code: {1})
r=   rf   r   rD   r"  r   r  rs   r;   r   r~   s     r/   delete_bucket_policyzBucket.delete_bucket_policy	  ss     	AHHIYIYZ[&--1DEOVVW[WfWfhlhshstuT""r1   c           	         t        j                  |      }t        j                  dj	                  | j
                  |             | j                  d|t        j                  didt        j                  |      i      }t        j                  dj	                  |j                  |j                               t        |      S )u?   设置付费者。

        :param input: :class: str 
        z<Start to put bucket request payment, bucket: {0}, payer: {1}r   rU   r  r  z>Put bucket request payment done, req_id: {0}, status_code: {1})r   to_put_bucket_request_paymentr=   rf   r   rD   r"  r   REQUESTPAYMENTr   r  rs   r;   r   )r,   payerr   rH   s       r/   put_bucket_request_paymentz!Bucket.put_bucket_request_payment	  s    
 66u=SZZ[_[k[kmrstD&:O:OQS9T_lnsnn  AE  oF  _G  HU\\]a]l]lnrnynyz{T""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取付费者设置。

        :return: :class:`GetBucketRequestPaymentResult <oss2.models.GetBucketRequestPaymentResult>`
        z1Start to get bucket request payment, bucket: {0}.rm   rU   rz   z>Get bucket request payment done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  rs   r;   rT   r    parse_get_bucket_request_paymentGetBucketRequestPaymentResultr~   s     r/   get_bucket_request_paymentz!Bucket.get_bucket_request_payment	  s    
 	HOOPTP`P`abv/D/Db.IJU\\]a]l]lnrnynyz{!!$	(R(RTqrrr1   c                    t         j                  dj                  | j                               | j	                  t
        t        j                  |      }t        j                         }t        j                  |      |d<   | j                  d|t        j                  di|      }t         j                  dj                  |j                  |j                                t#        |      S )u   配置bucket的QoSInfo

        :param bucket_qos_info :class:`BucketQosInfo <oss2.models.BucketQosInfo>`
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z)Start to put bucket qos info, bucket: {0}r  r   rU   r  z7Get bucket qos info done, req_id: {0}, status_code: {1})r=   rf   r   rD   r  BucketQosInfor   r   r   rq   r   r  r"  r   r{   rs   r;   r   )r,   bucket_qos_infor   r@   rH   s        r/   put_bucket_qos_infozBucket.put_bucket_qos_info	  s     	@GGHXHXYZ""=)2K2K_]**,!&!2!24!8D&//29NX_`NUUVZVeVegkgrgrstT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )uv   获取bucket的QoSInfo

        :return: :class:`GetBucketQosInfoResult <oss2.models.GetBucketQosInfoResult>`
        z)Start to get bucket qos info, bucket: {0}rm   rU   rz   z2Get bucket qos info, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r{   rs   r;   rT   r   r|   GetBucketQosInfoResultr~   s     r/   get_bucket_qos_infozBucket.get_bucket_qos_info	  s    
 	@GGHXHXYZv.CDIPPQUQ`Q`bfbmbmno!!$	(D(DF\]]r1   c                 ,   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )ud   删除bucket的QoSInfo

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z,Start to delete bucket qos info, bucket: {0}r   rU   rz   z:Delete bucket qos info done, req_id: {0}, status_code: {1})
r=   rf   r   rD   r"  r   r{   rs   r;   r   r~   s     r/   delete_bucket_qos_infozBucket.delete_bucket_qos_info	  ss    
 	CJJ4K[K[\]&//21FGQXXY]YhYhjnjujuvwT""r1   c                 X   t         j                  dj                  | j                               t	        j
                  |      }| j                  d|t        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )uu   设置Bucket的容量，单位GB

        :param user_qos :class:`BucketUserQos <oss2.models.BucketUserQos>`
        z)Start to set bucket storage capacity: {0}r   rU   r   z?Set bucket storage capacity done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   to_put_bucket_user_qosr"  r   USER_QOSrs   r;   r   )r,   user_qosr   rH   s       r/   set_bucket_storage_capacityz"Bucket.set_bucket_storage_capacity	  s    
 	@GGHXHXYZ//9D&//29NOV]]^b^m^mosozoz{|T""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u~   获取bucket的容量信息。

        :return: :class:`GetBucketUserQosResult <oss2.models.GetBucketUserQosResult>`
        z0Start to get bucket storage capacity, bucket:{0}rm   rU   rz   z?Get bucket storage capacity done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  rs   r;   rT   r   parse_get_bucket_user_qosGetBucketUserQosResultr~   s     r/   get_bucket_storage_capacityz"Bucket.get_bucket_storage_capacity
  s    
 	GNNtO_O_`a&&ufoor5J&KV]]^b^m^mosozoz{|!!$	(K(KMcddr1   c                    t         j                  dj                  | j                               t	        j
                  |      }t        j                         }t        j                  |      |d<   | j                  d|t        j                  di|      }t         j                  dj                  |j                  |j                               | j                  |t        j                   t"              S )u)  创建一个异步获取文件到bucket的任务。

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

        :return: :class:`PutAsyncFetchTaskResult <oss2.models.PutAsyncFetchTaskResult>`
        z)Start to put async fetch task, bucket:{0}r  r   rU   r  8Put async fetch task done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   to_put_async_fetch_taskr   rq   r   r  r"  r   ASYNC_FETCHrs   r;   rT   !parse_put_async_fetch_task_resultPutAsyncFetchTaskResult)r,   task_configr   r@   rH   s        r/   put_async_fetch_taskzBucket.put_async_fetch_task
  s     	@GGHXHXYZ00=**,!&!2!24!8&&vD&BTBTVXAYcj&kOVVW[WfWfhlhshstu!!$	(S(SUlmmr1   c                 p   t         j                  dj                  | j                  |             | j	                  dt
        |it        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取一个异步获取文件到bucket的任务信息。

        :param str task_id: 任务id
        :return: :class:`GetAsyncFetchTaskResult <oss2.models.GetAsyncFetchTaskResult>`
        z6Start to get async fetch task, bucket:{0}, task_id:{1}rm   rU   rO  r  )r=   rf   r   rD   r"  OSS_TASK_IDr   r  rs   r;   rT   r   !parse_get_async_fetch_task_resultGetAsyncFetchTaskResult)r,   task_idrH   s      r/   get_async_fetch_taskzBucket.get_async_fetch_task!
  s     	MTTUYUeUegnop&&u{G6LV\VhVhjlUm&nOVVW[WfWfhlhshstu!!$	(S(SUlmmr1   c                    t         j                  dj                  | j                               | j	                  t
        t        j                  |      }t        j                         }t        j                  |      |d<   | j                  d|t        j                  dt        j                  |j                   i|      }t         j                  dj                  |j"                  |j$                               t'        |      S )u   设置bucket清单配置

        :param inventory_configuration :class:`InventoryConfiguration <oss2.models.InventoryConfiguration>`
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z8Start to put bucket inventory configuration, bucket: {0}r  r   rU   r  zFPut bucket inventory configuration done, req_id: {0}, status_code: {1})r=   rf   r   rD   r  InventoryConfigurationr   to_put_inventory_configurationr   rq   r   r  r"  r   	INVENTORYINVENTORY_CONFIG_IDinventory_idrs   r;   r   )r,   inventory_configurationr   r@   rH   s        r/   "put_bucket_inventory_configurationz)Bucket.put_bucket_inventory_configuration-
  s     	OVVW[WgWghi""#99;c;ce|}**,!&!2!24!8D&:J:JBPVPjPj  lC  lP  lP  :Q  [b  c]ddeietetvz  wB  wB  C  	DT""r1   c                    t         j                  dj                  | j                               | j	                  dt
        j                  dt
        j                  |i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取指定的清单配置。

        :param str inventory_id : 清单配置id
        :return: :class:`GetInventoryConfigurationResult <oss2.models.GetInventoryConfigurationResult>`
        z8Start to get bucket inventory configuration, bucket: {0}rm   rU   rz   zEGet bucket inventory cinfguration done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  r  rs   r;   rT   r   (parse_get_bucket_inventory_configurationGetInventoryConfigurationResultr,   r  rH   s      r/   "get_bucket_inventory_configurationz)Bucket.get_bucket_inventory_configuration=
  s     	OVVW[WgWghiv/?/?VE_E_`l.mn\ccdhdsdsuy  vA  vA  B  	C!!$	(Z(Z\{||r1   c                    t         j                  dj                  | j                               t        j
                  di}|||t        j                  <   | j                  d|      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u  罗列清单配置，默认单次最大返回100条配置，如果存在超过100条配置，罗列结果将会分页，
        分页信息保存在 class:`ListInventoryConfigurationResult <oss2.models.ListInventoryConfigurationResult>`中。

        :param str continuation_token: 分页标识, 默认值为None, 如果上次罗列不完整，这里设置为上次罗列结果中的next_continuation_token值。
        :return: :class:`ListInventoryConfigurationResult <oss2.models.ListInventoryConfigurationResult>`
        z9Start to list bucket inventory configuration, bucket: {0}rU   rm   rz   zGList bucket inventory configuration done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r  CONTINUATION_TOKENr"  rs   r;   rT   r   *parse_list_bucket_inventory_configurations!ListInventoryConfigurationsResult)r,   r   ro   rH   s       r/   $list_bucket_inventory_configurationsz+Bucket.list_bucket_inventory_configurationsI
  s     	PWWX\XhXhij""2&)0BF6,,-f5^eefjfufuw{  xC  xC  D  	E!!$	(\(\^  A  	Ar1   c                 N   t         j                  dj                  | j                  |             | j	                  dt
        j                  dt
        j                  |i      }t         j                  dj                  |j                  |j                               t        |      S )u   删除指定的清单配置

        :param str inventory_id : 清单配置id
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        zSStart to delete bucket inventory configuration, bucket: {0}, configuration id: {1}.r   rU   rz   zDDelete bucket inventory configuration, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  r  rs   r;   r   r  s      r/   %delete_bucket_inventory_configurationz,Bucket.delete_bucket_inventory_configurationY
  s     	jqqrv  sC  sC  EQ  R  	S&2B2B2vGaGabn1op[bbcgcrcrtxtt  A  	BT""r1   c                    t         j                  dj                  | j                  |             t	        j
                  |      }t        j                         }t        j                  |      |d<   | j                  d|t        j                  di|      }t         j                  dj                  |j                  |j                               t        |      }|j                   j#                  d      |_        |S )u   创建一条合规保留策略

        :param int retention_period_days : 指定object的保留天数
        :return: :class:`InitBucketWormResult <oss2.models.InitBucketWormResult>`
        zCStart to init bucket worm, bucket: {0}, retention_period_days: {1}.r  r   rU   r  z4init bucket worm done, req_id: {0}, status_code: {1}zx-oss-worm-id)r=   rf   r   rD   r   to_put_init_bucket_wormr   rq   r   r  r"  r   WORMrs   r;   InitBucketWormResultr@   r   worm_id)r,   retention_period_daysr   r@   rH   rS   s         r/   init_bucket_wormzBucket.init_bucket_wormf
  s     	ZfT--/DE	G001FG**,!&!2!24!8T6;;:KU\]KRRSWSbSbdhdodopq%d+))/:r1   c                 ,   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )u   删除一条合规保留策略
        只有未锁定保留策略的状态下才能删除，一旦锁定bucket数据将处于保护状态。

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z(Start to abort bucket worm, bucket: {0}.r   rU   rz   z5abort bucket worm done, req_id: {0}, status_code: {1})
r=   rf   r   rD   r"  r   r  rs   r;   r   r~   s     r/   abort_bucket_wormzBucket.abort_bucket_wormx
  ss     	?FFtGWGWXY&++r1BCLSSTXTcTceiepepqrT""r1   c                 .   t         j                  dj                  | j                  |             | j	                  dt
        j                  |i      }t         j                  dj                  |j                  |j                               t        |      S )u   锁定一条合规保留策略

        :param str worm_id : 合规保留策略的id。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z9Start to complete bucket worm, bucket: {0}, worm_id: {1}.r   rz   z8complete bucket worm done, req_id: {0}, status_code: {1})
r=   rf   r   rD   r"  r   WORM_IDrs   r;   r   )r,   r  rH   s      r/   complete_bucket_wormzBucket.complete_bucket_worm
  sw     	PWWX\XhXhjqrs/HIOVVW[WfWfhlhshstuT""r1   c                    t        j                  |      }t        j                         }t	        j
                  |      |d<   t        j                  dj                  | j                  ||             | j                  d|t        j                  |t        j                  di|      }t        j                  dj                  |j                  |j                               t!        |      S )u  延长已经锁定的合规保留策略的object保护天数。

        :param str worm_id : 合规保留策略的id。
        :param int retention_period_days : 指定object的保留天数
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        r  zNStart to extend bucket worm, bucket: {0}, worm_id: {1}, retention_period_days.r   rU   r  z6extend bucket worm done, req_id: {0}, status_code: {1})r   to_put_extend_bucket_wormr   rq   r   r  r=   rf   r   rD   r"  r   r  WORM_EXTENDrs   r;   r   )r,   r  r  r   r@   rH   s         r/   extend_bucket_wormzBucket.extend_bucket_worm
  s     223HI**,!&!2!24!8efT--w8MN	PT6>>7TZTfTfhj:ku|}MTTUYUdUdfjfqfqrsT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )ur   获取合规保留策略

        :return: :class:`GetBucketWormResult <oss2.models.GetBucketWormResult>`
        z&Start to get bucket worm, bucket: {0}.rm   rU   rz   z3get bucket worm done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  rs   r;   rT   r   parse_get_bucket_worm_resultGetBucketWormResultr~   s     r/   get_bucket_wormzBucket.get_bucket_worm
  s    
 	=DDTEUEUVWv{{B.?@JQQRVRaRacgcncnop!!$	(N(NPcddr1   c                    t         j                  dj                  | j                               t	        j
                  |      }t        j                         }t        j                  |      |d<   | j                  d|t        j                  dddi|      }t         j                  dj                  |j                  |j                               t        |      S )	u   设置bucket跨区域复制规则

        :param rule :class:`ReplicationRule <oss2.models.ReplicationRule>`
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z$Start to put bucket replication: {0}r  r   rU   r   addr  z:Put bucket replication done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   to_put_bucket_replicationr   rq   r   r  r"  r   REPLICATIONrs   r;   r   )r,   r  r   r@   rH   s        r/   put_bucket_replicationzBucket.put_bucket_replication
  s     	;BB4CSCSTU2248**,!&!2!24!8T6;M;MrSY[`:akrsQXXY]YhYhjnjujuvwT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取bucket跨区域复制规则

        :return: :class:`GetBucketReplicationResult <oss2.models.GetBucketReplicationResult>`
        z$Start to get bucket replication: {0}rm   rU   rz   z:Get bucket replication done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  rs   r;   rT   r   #parse_get_bucket_replication_resultGetBucketReplicationResultr~   s     r/   get_bucket_replicationzBucket.get_bucket_replication
  s    
 	;BB4CSCSTUv/A/A2.FGQXXY]YhYhjnjujuvw!!$	(U(UWqrrr1   c                    t         j                  dj                  | j                               t	        j
                  |      }t        j                         }t        j                  |      |d<   | j                  d|t        j                  dddi|      }t         j                  dj                  |j                  |j                               t        |      S )	u   停止Bucket的跨区域复制并删除Bucket的复制配置
        :param str rule_id: Bucket跨区域复制规则的id。

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z'Start to delete bucket replication: {0}r  r   rU   r   r  r  z=Delete bucket replication done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   to_delete_bucket_replicationr   rq   r   r  r"  r   r  rs   r;   r   )r,   rule_idr   r@   rH   s        r/   delete_bucket_replicationz Bucket.delete_bucket_replication
  s     	>EEdFVFVWX55g>**,!&!2!24!8T6;M;MrSY[c:dnuvT[[\`\k\kmqmxmxyzT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取可复制到的Bucket所在的地域

        :return: :class:`ReplicationLocation <oss2.models.GetBucketReplicationLocationResult>`
        z-Start to get bucket replication location: {0}rm   rU   rz   zCGet bucket replication location done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   REPLICATION_LOCATIONrs   r;   rT   r   ,parse_get_bucket_replication_location_result"GetBucketReplicationLocationResultr~   s     r/   get_bucket_replication_locationz&Bucket.get_bucket_replication_location
  s    
 	DKKDL\L\]^0K0KR/PQZaabfbqbqsws~s~  	A!!$	(^(^  aC  D  	Dr1   c                 d   t         j                  dj                  | j                               | j	                  dt
        j                  dd|i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取获取某个Bucket的跨区域复制进度

        :param str rule_id: Bucket跨区域复制规则的id。
        :return: :class:`GetBucketReplicationProgressResult <oss2.models.GetBucketReplicationProgressResult>`
        z-Start to get bucket replication progress: {0}rm   rU   zrule-idrz   zCGet bucket replication progress done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   REPLICATION_PROGRESSrs   r;   rT   r   ,parse_get_bucket_replication_progress_result"GetBucketReplicationProgressResult)r,   r  rH   s      r/   get_bucket_replication_progressz&Bucket.get_bucket_replication_progress
  s     	DKKDL\L\]^0K0KRQZ\c/deZaabfbqbqsws~s~  	A!!$	(^(^  aC  D  	Dr1   c                     t         j                  dj                  | j                               | j	                  d|di      }t         j                  dj                  |j
                  |j                               |S )uW  获得Bucket某项配置，具体哪种配置由 `config` 指定。该接口直接返回 `RequestResult` 对象。
        通过read()接口可以获得XML字符串。不建议使用。

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

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z'Start to get bucket config, bucket: {0}rm   rU   rz   z5Get bucket config done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  rs   r;   )r,   r  rH   s      r/   _get_bucket_configzBucket._get_bucket_config
  sh     	>EEdFVFVWXvrl;LSSTXTcTceiepepqrr1   c                    t         j                  dj                  | j                  |             t	        j
                  |      }t        j                         }t        j                  |      |d<   | j                  d|t        j                  di|      }t         j                  dj                  |j                  |j                               t        |      S )u   为存储空间（Bucket）配置传输加速

        :param str enabled : 是否开启传输加速。true：开启传输加速; false：关闭传输加速.
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        zAStart to bucket transfer acceleration, bucket: {0}, enabled: {1}.r  r   rU   r  z@bucket transfer acceleration done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   #to_put_bucket_transfer_accelerationr   rq   r   r  r"  r   TRANSFER_ACCELERATIONrs   r;   r   )r,   enabledr   r@   rH   s        r/    put_bucket_transfer_accelerationz'Bucket.put_bucket_transfer_acceleration
  s     	XfT--w7	9<<WE**,!&!2!24!8D&:V:VXZ9[elmW^^_c_n_nptp{p{|}T""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取目标存储空间（Bucket）的传输加速配置

        :return: :class:`GetBucketTransferAccelerationResult <oss2.models.GetBucketTransferAccelerationResult>`
        z.Start to get bucket transfer acceleration: {0}rm   rU   rz   zDGet bucket transfer acceleration done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  rs   r;   rT   r   -parse_get_bucket_transfer_acceleration_result#GetBucketTransferAccelerationResultr~   s     r/    get_bucket_transfer_accelerationz'Bucket.get_bucket_transfer_acceleration	  s    
 	ELLTM]M]^_v/K/KR.PQ[bbcgcrcrtxtt  A  	B!!$	(_(_  bE  F  	Fr1   c                    t         j                  dj                  | j                               t	        j
                  |      }| j                  d|t        j                  dt        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   创建域名所有权验证所需的CnameToken。

        :param str domain : 绑定的Cname名称。
        :return: :class:`CreateBucketCnameTokenResult <oss2.models.CreateBucketCnameTokenResult>`
        z0Start to create bucket cname token, bucket: {0}.r   rU   r   r   z6bucket cname token done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   to_bucket_cname_configurationr"  r   CNAMErW  rs   r;   rT   parse_create_bucket_cname_tokenCreateBucketCnameTokenResultr,   domainr   rH   s       r/   create_bucket_cname_tokenz Bucket.create_bucket_cname_token  s     	GNNtO_O_`a66v>T6<<V[[Za:bcMTTUYUdUdfjfqfqrs!!$	(Q(QSoppr1   c                    t         j                  dj                  | j                               | j	                  dt
        j                  |t
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取已创建的CnameToken。

        :param str domain : 绑定的Cname名称。
        :return: :class:`GetBucketCnameTokenResult <oss2.models.GetBucketCnameTokenResult>`
        zStart to get bucket cname: {0}rm   r   rz   z4Get bucket cname done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  rW  rs   r;   rT   r   parse_get_bucket_cname_tokenGetBucketCnameTokenResult)r,   r!  rH   s      r/   get_bucket_cname_tokenzBucket.get_bucket_cname_token   s     	5<<T=M=MNOv||VV[[RY.Z[KRRSWSbSbdhdodopq!!$	(N(NPijjr1   c                    t         j                  dj                  | j                               t	        j
                  |j                  |j                        }| j                  d|t        j                  dt        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )u   为某个存储空间（Bucket）绑定自定义域名。

        :param input: PutBucketCnameRequest类型，包含了证书和自定义域名信息
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z'Start to add bucket cname, bucket: {0}.r   rU   r  r   z0bucket cname done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r  r!  certr"  r   r  rW  rs   r;   r   r   s       r/   put_bucket_cnamezBucket.put_bucket_cname+  s     	>EEdFVFVWX66u||UZZPT6<<V[[Z_:`aGNNt`d`k`klmT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   查询某个存储空间（Bucket）下绑定的所有Cname列表。

        :return: :class:`ListBucketCnameResult <oss2.models.ListBucketCnameResult>`
        z(Start to do query list bucket cname: {0}rm   rU   rz   ;query list bucket cname done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  rs   r;   rT   r   parse_list_bucket_cnameListBucketCnameResultr~   s     r/   list_bucket_cnamezBucket.list_bucket_cname7  s    
 	?FFtGWGWXYv||R.@ARYYZ^ZiZikokvkvwx!!$	(I(IK`aar1   c                 x   t         j                  dj                  | j                               t	        j
                  |      }| j                  d|t        j                  dt        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )u   删除某个存储空间（Bucket）已绑定的Cname

        :param str domain : 绑定的Cname名称。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z!Start to delete bucket cname: {0}r   rU   r  r   z7delete bucket cname done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r  r"  r   r  rW  rs   r;   r   r   s       r/   delete_bucket_cnamezBucket.delete_bucket_cnameB  s     	8??@P@PQR66v>T6<<V[[Zb:cdNUUVZVeVegkgrgrstT""r1   c                 0   t         j                  dj                  | j                               | j	                  dt
        j                  dddi      }t         j                  dj                  |j                  |j                               t        |      S )u   为存储空间（Bucket）开启元数据管理功能

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z(Start to bucket meta query, bucket: {0}.r   rU   r   r  rz   5bucket meta query done, req_id: {0}, status_code: {1})
r=   rf   r   rD   r"  r   
META_QUERYrs   r;   r   r~   s     r/   open_bucket_meta_queryzBucket.open_bucket_meta_queryN  sy    
 	?FFtGWGWXY0A0A2vu/UVLSSTXTcTceiepepqrT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取指定存储空间（Bucket）的元数据索引库信息。

        :return: :class:`GetBucketMetaQueryResult <oss2.models.GetBucketMetaQueryResult>`
        z#Start to get bucket meta query: {0}rm   rU   rz   z9Get bucket meta query done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r3  rs   r;   rT   r   "parse_get_bucket_meta_query_resultGetBucketMetaQueryResultr~   s     r/   get_bucket_meta_query_statusz#Bucket.get_bucket_meta_query_statusX  s    
 	:AA$BRBRSTv/@/@".EFPWWX\XgXgimitituv!!$	(T(TVnoor1   c                    t         j                  dj                  | j                               | j	                  t
        t        j                  |      }| j                  d|t        j                  dt        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t               S )u  查询满足指定条件的文件（Object），并按照指定字段和排序方式列出文件信息。

        :param do_meta_query_request :class:`MetaQuery <oss2.models.MetaQuery>`
        :return: :class:`DoBucketMetaQueryResult <oss2.models.DoBucketMetaQueryResult>`
        z"Start to do bucket meta query: {0}r   rU   queryr   z8do bucket meta query done, req_id: {0}, status_code: {1})r=   rf   r   rD   r  	MetaQueryr   to_do_bucket_meta_query_requestr"  r   r3  rW  rs   r;   rT   !parse_do_bucket_meta_query_resultDoBucketMetaQueryResult)r,   do_meta_query_requestr   rH   s       r/   do_bucket_meta_queryzBucket.do_bucket_meta_queryb  s     	9@@AQAQRS""9i.W.WYnoT6;L;LbRXR]R]_f:ghOVVW[WfWfhlhshstu!!$	(S(SUlmmr1   c                 L   t         j                  dj                  | j                               | j	                  dt
        j                  dt
        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )u   关闭存储空间（Bucket）的元数据管理功能

        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z%Start to close bucket meta query: {0}r   rU   r  rz   r2  )r=   rf   r   rD   r"  r   r3  rW  rs   r;   r   r~   s     r/   close_bucket_meta_queryzBucket.close_bucket_meta_queryo  s~    
 	<CCDDTDTUV0A0A2v{{T\/]^LSSTXTcTceiepepqrT""r1   c                 X   t         j                  dj                  | j                               t	        j
                  |      }| j                  d|t        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )u   更新 Bucket 访问跟踪状态。

        :param str status : bucket访问跟踪的开启状态
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z0Start to put bucket access monitor, bucket: {0}.r   rU   r   z9bucket access monitor done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   to_put_bucket_access_monitorr"  r   ACCESS_MONITORrs   r;   r   )r,   r;   r   rH   s       r/   put_bucket_access_monitorz Bucket.put_bucket_access_monitory  s     	GNNtO_O_`a55f=D&:O:OQS9TUPWWX\XgXgimitituvT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取当前Bucket的访问跟踪的状态。

        :return: :class:`GetBucketAccessMonitorResult <oss2.models.GetBucketAccessMonitorResult>`
        z'Start to get bucket access monitor: {0}rm   rU   rz   r+  )r=   rf   r   rD   r"  r   rE  rs   r;   rT   r   &parse_get_bucket_access_monitor_resultGetBucketAccessMonitorResultr~   s     r/   get_bucket_access_monitorz Bucket.get_bucket_access_monitor  s    
 	>EEdFVFVWXv/D/Db.IJRYYZ^ZiZikokvkvwx!!$	(X(XZvwwr1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   查询存储空间（Bucket）的资源组ID。

        :return: :class:`GetBucketResourceGroupResult <oss2.models.GetBucketResourceGroupResult>`
        z'Start to get bucket resource group: {0}rm   rU   rz   z=Get bucket resource group done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   RESOURCE_GROUPrs   r;   rT   r   &parse_get_bucket_resource_group_resultGetBucketResourceGroupResultr~   s     r/   get_bucket_resource_groupz Bucket.get_bucket_resource_group  s    
 	>EEdFVFVWXv/D/Db.IJT[[\`\k\kmqmxmxyz!!$	(X(XZvwwr1   c                 X   t         j                  dj                  | j                               t	        j
                  |      }| j                  d|t        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )u   为存储空间（Bucket）配置所属资源组。

        :param str resourceGroupId : Bucket所属的资源组ID。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z0Start to put bucket resource group, bucket: {0}.r   rU   r   z9bucket resource group done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   to_put_bucket_resource_groupr"  r   rL  rs   r;   r   )r,   resourceGroupIdr   rH   s       r/   put_bucket_resource_groupz Bucket.put_bucket_resource_group  s     	GNNtO_O_`a55oFD&:O:OQS9TUPWWX\XgXgimitituvT""r1   c                 x   t         j                  dj                  | j                               t	        j
                  |      }| j                  d|t        j                  dt        j                  |i      }t         j                  dj                  |j                  |j                               t        |      S )u  新增图片样式。

        :param str styleName : 样式名称。
        :param str content : 图片样式内容，图片样式可以包含一个或多个图片处理操作。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z'Start to put bucket style, bucket: {0}.r   rU   r   z0bucket style done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   to_put_bucket_styler"  r   STYLE
STYLE_NAMErs   r;   r   )r,   r  contentr   rH   s        r/   put_bucket_stylezBucket.put_bucket_style  s     	>EEdFVFVWX,,W5D&,,FL]L]_h9ijGNNt`d`k`klmT""r1   c                    t         j                  dj                  | j                               | j	                  dt
        j                  dt
        j                  |i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   查询某个Bucket下指定的图片样式信息。

        :param str styleName : 样式名称。
        :return: :class:`GetBucketStyleResult <oss2.models.GetBucketStyleResult>`
        zStart to get bucket style: {0}rm   rU   rz   z4Get bucket style done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   rV  rW  rs   r;   rT   r   parse_get_bucket_style_resultGetBucketStyleResultr,   r  rH   s      r/   get_bucket_stylezBucket.get_bucket_style  s     	5<<T=M=MNOv||RARART].^_KRRSWSbSbdhdodopq!!$	(O(OQeffr1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   查询某个Bucket下已创建的所有图片样式。

        :return: :class:`ListBucketStyleResult <oss2.models.ListBucketStyleResult>`
        zStart to list bucket style: {0}rm   rU   rz   z;query list bucket style done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   rV  rs   r;   rT   r   parse_list_bucket_styleListBucketStyleResultr~   s     r/   list_bucket_stylezBucket.list_bucket_style  s    
 	6==d>N>NOPv||R.@ARYYZ^ZiZikokvkvwx!!$	(I(IK`aar1   c                 L   t         j                  dj                  | j                               | j	                  dt
        j                  dt
        j                  |i      }t         j                  dj                  |j                  |j                               t        |      S )u   删除某个Bucket下指定的图片样式。

        :param str styleName : 样式名称。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z!Start to delete bucket style: {0}r   rU   rz   z7delete bucket style done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   rV  rW  rs   r;   r   r]  s      r/   delete_bucket_stylezBucket.delete_bucket_style  s~     	8??@P@PQR&,,FDUDUW`1abNUUVZVeVegkgrgrstT""r1   c                    t        j                  |      }t        j                  dj	                  | j
                  t        |      |             t        j                  d|}| j                  d|t        j                  di||      }t        j                  dj	                  |j                  |j                               | j                  |t        j                  t              S )u  异步处理多媒体接口。

        :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
        zBStart to async process object, bucket: {0}, key: {1}, process: {2}rn  r   rU   r   z8Async process object done, req_id: {0}, status_code: {1})r   rq   r=   rf   r   rD   r   r   ASYNC_PROCESSr5  rs   r;   rT   r   parse_async_process_objectAsyncProcessObjectrp  s         r/   async_process_objectzBucket.async_process_object  s     **73Y``ing7 	8"("6"6@V5I5I24NX_frsOVVW[WfWfhlhshstu!!$	(L(LN`aar1   c                    t         j                  dj                  | j                  |             t	        j
                  |      }| j                  d|t        j                  dt        j                  t        j                  i      }t         j                  dj                  |j                  |j                               t        |      S )uR   设置bucket回调策略

        :param str callbackPolicy: 回调策略
        zFStart to put bucket callback policy, bucket: {0}, callback policy: {1}r   rU   r   z>Put bucket callback policy done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   $to_do_bucket_callback_policy_requestr"  r   r  rW  CALLBACKrs   r;   r   )r,   callbackPolicyr   rH   s       r/   put_bucket_callback_policyz!Bucket.put_bucket_callback_policy  s    
 	]ddeieueu  xF  G  	H==nMD&--V[[Z`ZiZi9jkU\\]a]l]lnrnynyz{T""r1   c                    t         j                  dj                  | j                               | j	                  dt
        j                  dt
        j                  t
        j                  i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )ut   获取bucket回调策略
        :return: :class:`GetBucketPolicyResult <oss2.models.CallbackPolicyResult>`
        z0Start to get bucket callback policy, bucket: {0}rm   rU   rz   z>Get bucket callback policy done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  rW  rl  rs   r;   rT   r   parse_callback_policy_resultCallbackPolicyResultr~   s     r/   get_bucket_callback_policyz!Bucket.get_bucket_callback_policy  s    
 	GNNtO_O_`av}}b&++v._`U\\]a]l]lnrnynyz{!!$	(N(NPdeer1   c                 h   t         j                  dj                  | j                               | j	                  dt
        j                  dt
        j                  t
        j                  i      }t         j                  dj                  |j                  |j                               t        |      S )ue   删除bucket回调策略
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z3Start to delete bucket callback policy, bucket: {0}r   rU   rz   zADelete bucket callback policy done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  rW  rl  rs   r;   r   r~   s     r/   delete_bucket_callback_policyz$Bucket.delete_bucket_callback_policy  s     	JQQRVRbRbcd&--V[[RXRaRa1bcX__`d`o`oquq|q|}~T""r1   c                 Z   t         j                  dj                  | j                  |             t	        j
                  |      }| j                  d|t        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )u[   设置归档直读

        :param boolean enabled: Bucket是否开启归档直读
        zBStart to put bucket archive direct read, bucket: {0}, enabled: {1}r   rU   r   z>bucket archive direct read done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   !to_put_bucket_archive_direct_readr"  r   ARCHIVE_DIRECT_READrs   r;   r   )r,   r  r   rH   s       r/   put_bucket_archive_direct_readz%Bucket.put_bucket_archive_direct_read  s    
 	Y``aeaqaqsz{|::7CD&:T:TVX9YZU\\]a]l]lnrnynyz{T""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取归档直读
        :return: :class:`GetBucketArchiveDirectReadResult <oss2.models.GetBucketArchiveDirectReadResult>`
        z4Start to get bucket archive direct read, bucket: {0}rm   rU   rz   zBGet bucket archive direct read done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   rw  rs   r;   rT   r   $parse_get_bucket_archive_direct_read GetBucketArchiveDirectReadResultr~   s     r/   get_bucket_archive_direct_readz%Bucket.get_bucket_archive_direct_read  s    
 	KRRSWScScdev/I/I2.NOY``aeapaprvr}r}~!!$	(V(VXxyyr1   c                 Z   t         j                  dj                  | j                  |             t	        j
                  |      }| j                  d|t        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )ub   Bucket开启或关闭TLS版本设置。
        :param httpsConfig: TLS版本信息设置
        z@Start to put bucket https config, bucket: {0}, https config: {1}r   rU   r   z;Put bucket https config done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   !to_do_bucket_https_config_requestr"  r   HTTPS_CONFIGrs   r;   r   )r,   r  r   rH   s       r/   put_bucket_https_configzBucket.put_bucket_https_config   s     	W^^_c_o_oq|}~::;GD&:M:Mr9RSRYYZ^ZiZikokvkvwxT""r1   c                    t         j                  dj                  | j                  |             | j	                  dt
        j                  dt
        j                  |i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )ul   为Bucket创建存储冗余转换任务。

        :param str targetType: 目标存储冗余类型
        zPStart to create bucket data redundancy transition, bucket: {0}, target type: {1}r   rU   rz   zLCreate bucket data redundancy transition done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r   TARGET_REDUNDANCY_TYPErs   r;   rT   r   .parse_create_data_redundancy_transition_result$CreateDataRedundancyTransitionResult)r,   
targetTyperH   s      r/   (create_bucket_data_redundancy_transitionz/Bucket.create_bucket_data_redundancy_transition+  s    
 	gnnosoo  BL  M  	N0L0LbRXRoRoq{/|}cjjkokzkz  }A  }H  }H  I  	J!!$	(`(`  cG  H  	Hr1   c                    t         j                  dj                  | j                               | j	                  dt
        j                  dt
        j                  |i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取存储冗余转换任务。
        :return: :class:`DataRedundancyTransitionInfoResult <oss2.models.DataRedundancyTransitionInfoResult>`
        z;Start to get bucket data redundancy transition, bucket: {0}rm   rU   rz   zIGet bucket data redundancy transition done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r   REDUNDANCY_TRANSITION_TASK_IDrs   r;   rT   r   +parse_get_bucket_data_redundancy_transition"DataRedundancyTransitionInfoResultr,   taskIdrH   s      r/   %get_bucket_data_redundancy_transitionz,Bucket.get_bucket_data_redundancy_transition7  s    
 	RYYZ^ZjZjklv/K/KRQWQuQuw}.~`gghlhwhwy}  zE  zE  F  	G!!$	(](]  `B  C  	Cr1   c                 L   t         j                  dj                  | j                               | j	                  dt
        j                  dt
        j                  |i      }t         j                  dj                  |j                  |j                               t        |      S )un   删除存储冗余转换任务。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z>Start to delete bucket data redundancy transition, bucket: {0}r   rU   rz   zLDelete bucket data redundancy transition done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r   r  rs   r;   r   r  s      r/   (delete_bucket_data_redundancy_transitionz/Bucket.delete_bucket_data_redundancy_transitionA  s     	U\\]a]m]mno&2N2NPRTZTxTx  {A  2B  Ccjjkokzkz  }A  }H  }H  I  	JT""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )uv   查看Bucket的TLS版本设置。
        :return: :class:`HttpsConfigResult <oss2.models.HttpsConfigResult>`
        z-Start to get bucket https config, bucket: {0}rm   rU   rz   z;Get bucket https config done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r  rs   r;   rT   r   parse_get_bucket_https_configHttpsConfigResultr~   s     r/   get_bucket_https_configzBucket.get_bucket_https_configJ  s     	DKKDL\L\]^v/B/BB.GHRYYZ^ZiZikokvkvwx!!$	(O(OQbccr1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   列举某个Bucket下所有的存储冗余转换任务。

        :return: :class:`ListBucketDataRedundancyTransitionResult <oss2.models.ListBucketDataRedundancyTransitionResult>`
        z=Start to do query list bucket data redundancy transition: {0}rm   rU   rz   zPquery list bucket data redundancy transition done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r   rs   r;   rT   r   ,parse_list_bucket_data_redundancy_transition(ListBucketDataRedundancyTransitionResultr~   s     r/   &list_bucket_data_redundancy_transitionz-Bucket.list_bucket_data_redundancy_transitionT  s    
 	T[[\`\l\lmnv/K/KR.PQgnnoso~o~  AE  AL  AL  M  	N!!$	(^(^  aI  J  	Jr1   c                    t         j                  dj                  | j                               t	        j
                  |      }| j                  d|t        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   创建接入点
        :param accessPoint :class:`CreateAccessPointRequest <oss2.models.CreateAccessPointRequest>`
        :return: :class:`CreateAccessPointResult <oss2.models.CreateAccessPointResult>`
        z)Start to create access point, bucket: {0}r   rU   r   z7Create access point done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   !to_do_create_access_point_requestr"  r   r   rs   r;   rT    parse_create_access_point_resultCreateAccessPointResult)r,   r  r   rH   s       r/   create_access_pointzBucket.create_access_point_  s    
 	@GGHXHXYZ::;GD&:M:Mr9RSNUUVZVeVegkgrgrst!!$	(R(RTkllr1   c                    t         j                  dj                  | j                               t	        j
                         }||d<   | j                  dt        j                  di|      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取接入点信息
        :param str accessPointName: 接入点名称
        :return: :class:`GetAccessPointResult <oss2.models.GetAccessPointResult>`
        z&Start to get access point, bucket: {0}r  rm   rU   rn   z4Get access point done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   rq   r"  r   r   rs   r;   rT   r   parse_get_access_point_resultGetAccessPointResultr,   accessPointNamer@   rH   s       r/   get_access_pointzBucket.get_access_pointj  s     	=DDTEUEUVW**,-<)*v/B/BB.GQXYKRRSWSbSbdhdodopq!!$	(O(OQeffr1   c                 `   t         j                  dj                  | j                               t	        j
                         }||d<   | j                  dt        j                  di|      }t         j                  dj                  |j                  |j                               t        |      S )u   删除接入点
         :param str accessPointName: 接入点名称
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z)Start to delete access point, bucket: {0}r  r   rU   rn   z7Delete access point done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   rq   r"  r   r   rs   r;   r   r  s       r/   delete_access_pointzBucket.delete_access_pointw  s    
 	@GGHXHXYZ**,-<)*&2E2Er1JT[\NUUVZVeVegkgrgrstT""r1   c           	      z   t         j                  dj                  | j                               | j	                  dt
        j                  ddt        |      d|i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u  查询某个Bucket下所有接入点。
        param: int max_keys: 本次list返回access point的最大个数
        param: str continuation_token: list时指定的起始标记
        :return: :class:`ListAccessPointResult <oss2.models.ListAccessPointResult>`
        z&Start to list bucket access point: {0}rm   rU   rl   r   rz   zBquery list bucket access point done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r   rp   rs   r;   rT   r   r   r   r   s       r/   list_bucket_access_pointsz Bucket.list_bucket_access_points  s     	=DDTEUEUVWv/B/BB
TWX`Tacw  zL  /M  NY``aeapaprvr}r}~!!$	(P(PRghhr1   c                 d   t         j                  dj                  | j                  |             t	        j
                         }||d<   | j                  d|t        j                  di|      }t         j                  dj                  |j                  |j                               t        |      S )u   设置接入点策略
        :param str accessPointName: 接入点名称
        :param str accessPointPolicy : 接入点策略
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        zEStart to put access point policy, bucket: {0}, accessPointPolicy: {1}r  r   rU   r  z>Create access point policy done, req_id: {0}, status_code: {1}r=   rf   r   rD   r   rq   r"  r   ACCESS_POINT_POLICYrs   r;   r   )r,   r  r  r@   rH   s        r/   put_access_point_policyzBucket.put_access_point_policy  s     	\ccdhdtdt  wH  I  	J**,-<)*,=vGaGaceFfpwxU\\]a]l]lnrnynyz{T""r1   c                 `   t         j                  dj                  | j                               t	        j
                         }||d<   | j                  dt        j                  di|      }t         j                  dj                  |j                  |j                               t        |      S )u   获取接入点策略
        :param str accessPointName: 接入点名称
        :return: :class:`GetAccessPointPolicyResult <oss2.models.GetAccessPointPolicyResult>`
        z-Start to get access point policy, bucket: {0}r  rm   rU   rn   z;Get access point policy done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   rq   r"  r   r  rs   r;   GetAccessPointPolicyResultr  s       r/   get_access_point_policyzBucket.get_access_point_policy  s     	DKKDL\L\]^**,-<)*v/I/I2.NX_`RYYZ^ZiZikokvkvwx)$//r1   c                 `   t         j                  dj                  | j                               t	        j
                         }||d<   | j                  dt        j                  di|      }t         j                  dj                  |j                  |j                               t        |      S )u   删除接入点策略
        :param str accessPointName: 接入点名称
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z0Start to delete access point policy, bucket: {0}r  r   rU   rn   z>Delete access point policy done, req_id: {0}, status_code: {1}r  r  s       r/   delete_access_point_policyz!Bucket.delete_access_point_policy  s    
 	GNNtO_O_`a**,-<)*&2L2Lb1Q[bcU\\]a]l]lnrnynyz{T""r1   c                 Z   t         j                  dj                  | j                  |             t	        j
                  |      }| j                  d|t        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )u   为Bucket开启阻止公共访问。

        :param bool block_public_access : 是否开启阻止公共访问。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        zCStart to bucket put public access block, bucket: {0}, enabled: {1}.r   rU   r   z>bucket public access block done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r   r"  r   r   rs   r;   r   r   s       r/   put_bucket_public_access_blockz%Bucket.put_bucket_public_access_block  s     	ZfT--/BC	E;;<OPD&:T:TVX9YZU\\]a]l]lnrnynyz{T""r1   c                 `   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取指定Bucket的阻止公共访问配置信息。

        :return: :class:`GetBucketPublicAccessBlockResult <oss2.models.GetBucketPublicAccessBlockResult>`
        z,Start to get bucket public access block: {0}rm   rU   rz   zBGet bucket public access block done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r   rs   r;   rT   r   r    GetBucketPublicAccessBlockResultr~   s     r/   get_bucket_public_access_blockz%Bucket.get_bucket_public_access_block  s    
 	CJJ4K[K[\]v/I/I2.NOY``aeapaprvr}r}~!!$	(V(VXxyyr1   c                 ,   t         j                  dj                  | j                               | j	                  dt
        j                  di      }t         j                  dj                  |j                  |j                               t        |      S )u   删除指定Bucket的阻止公共访问配置信息。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        z7Start to delete bucket public access block, bucket: {0}r   rU   rz   zEDelete bucket public access block done, req_id: {0}, status_code: {1})
r=   rf   r   rD   r"  r   r   rs   r;   r   r~   s     r/   !delete_bucket_public_access_blockz(Bucket.delete_bucket_public_access_block  s     	NUUVZVfVfgh&2L2Lb1QR\ccdhdsdsuy  vA  vA  B  	CT""r1   c                 |   t         j                  dj                  | j                  ||             t	        j
                  |      }| j                  d|t        j                  dt        j                  |i      }t         j                  dj                  |j                  |j                               t        |      S )u   为接入点开启阻止公共访问。

        :param bool block_public_access : 是否开启阻止公共访问。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        zmStart to put access point public access block, bucket: {0}, access point name: {1}, block public access: {2}.r   rU   r   zDaccess point public access block done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r   r"  r   r   OSS_ACCESS_POINT_NAMErs   r;   r   )r,   access_point_namer   r   rH   s        r/   $put_access_point_public_access_blockz+Bucket.put_access_point_public_access_block  s     	  EfT--/@BUV	X;;<OPD&:T:TVXZ`ZvZv  yJ  :K  L[bbcgcrcrtxtt  A  	BT""r1   c                    t         j                  dj                  | j                  |             | j	                  dt
        j                  dt
        j                  |i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取指定接入点的阻止公共访问配置信息。

        :return: :class:`GetBucketPublicAccessBlockResult <oss2.models.GetBucketPublicAccessBlockResult>`
        zKStart to get access point public access block: {0}, access point name: {1}.rm   rU   rz   zHGet access point public access block done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r   r  rs   r;   rT   r   r   r  r,   r  rH   s      r/   $get_access_point_public_access_blockz+Bucket.get_access_point_public_access_block  s    
 	biijnjzjz  }N  O  	Pv/I/I2vOkOkm~.  A_ffgkgvgvx|  yD  yD  E  	F!!$	(V(VXxyyr1   c                 N   t         j                  dj                  | j                  |             | j	                  dt
        j                  dt
        j                  |i      }t         j                  dj                  |j                  |j                               t        |      S )u   删除指定接入点的阻止公共访问配置信息。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        zVStart to delete access point public access block, bucket: {0}, access point name: {1}.r   rU   rz   zKDelete access point public access block done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r   r  rs   r;   r   r  s      r/   'delete_access_point_public_access_blockz.Bucket.delete_access_point_public_access_block  s     	mttuy  vF  vF  HY  Z  	[&2L2LbRXRnRn  qB  2C  Dbiijnjyjy{  |G  |G  H  	IT""r1   c                    t         j                  dj                  | j                  ||             |st	        d      t        j                  |      }| j                  d|t        j                  dt        j                  |i      }t         j                  dj                  |j                  |j                               t        |      S )u   修改请求者在Bucket上的流控配置。

        :param str uid: 请求者UID
        :param qos_configuration :class:`QoSConfiguration <oss2.models.QoSConfiguration>`
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        zVStart to put bucket requester qos info, bucket: {0}, uid: {1}, qos_configuration: {2}.r   r   rU   r   zAput bucket requester qos info done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r   r   r"  r   r   r   rs   r;   r   )r,   r   r   r   rH   s        r/   put_bucket_requester_qos_infoz$Bucket.put_bucket_requester_qos_info  s     	mfT--s4EF	H 788(():;D&:S:SUWY_YmYmor9stX__`d`o`oquq|q|}~T""r1   c                    t         j                  dj                  | j                  |             |st	        d      | j                  dt        j                  dt        j                  |i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u   获取请求者在Bucket上的流控配置。

        :return: :class:`RequesterQoSInfoResult <oss2.models.RequesterQoSInfoResult>`
        z6Start to get bucket requester qos info: {0}, uid: {1}.r   rm   rU   rz   z<Get bucket requester qos info, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r"  r   r   r   rs   r;   rT   r   r   r   r,   r   rH   s      r/   get_bucket_requester_qos_infoz$Bucket.get_bucket_requester_qos_info  s    
 	MTTUYUeUegjkl788v/H/H"fNbNbdg.hiSZZ[_[j[jlplwlwxy!!$	(N(NPfggr1   c                 z   t         j                  dj                  | j                               | j	                  dt
        j                  dd|dt        |      i      }t         j                  dj                  |j                  |j                               | j                  |t        j                  t              S )u#  列举所有对该Bucket的请求者流控配置。

        :param str continuation_token: 分页标志,首次调用传空串
        :param int max_keys: 最多返回数目
        :return: :class:`ListBucketRequesterQoSInfosResult <oss2.models.ListBucketRequesterQoSInfosResult>`
        z6Start to do query list bucket requester qos infos: {0}rm   rU   r   rl   rz   zIquery list bucket requester qos infos done, req_id: {0}, status_code: {1})r=   rf   r   rD   r"  r   r   rp   rs   r;   rT   r   %parse_list_bucket_requester_qos_infos!ListBucketRequesterQoSInfosResultr   s       r/   list_bucket_requester_qos_infosz&Bucket.list_bucket_requester_qos_infos   s     	MTTUYUeUefgv/H/H"Nbdv  yC  EH  IQ  ER  /S  T`gghlhwhwy}  zE  zE  F  	G!!$	(W(WYz{{r1   c                 h   t         j                  dj                  | j                  |             |st	        d      | j                  dt        j                  dt        j                  |i      }t         j                  dj                  |j                  |j                               t        |      S )uz   删除在Bucket上的请求者流控配置。
        :return: :class:`RequestResult <oss2.models.RequestResult>`
        zAStart to delete bucket requester qos info, bucket: {0}, uid: {1}.r   r   rU   rz   zDDelete bucket requester qos info done, req_id: {0}, status_code: {1})r=   rf   r   rD   r   r"  r   r   r   rs   r;   r   r  s      r/    delete_bucket_requester_qos_infoz'Bucket.delete_bucket_requester_qos_info.  s     	X__`d`p`pruvw788&2K2KRQWQeQegj1kl[bbcgcrcrtxtt  A  	BT""r1   c                     | j                   st        d      |st        d       | j                  || j                   |fi |S )Nz(Bucket name should not be null or empty.z key should not be null or empty.)rD   r   rK   )r,   rC   rE   rF   s       r/   __do_objectzBucket.__do_object;  sF    HII@AAtxx 0 0#@@@r1   c                 @     | j                   || j                  dfi |S NrU   )rK   rD   )r,   rC   rF   s      r/   __do_bucketzBucket.__do_bucketB  s"    txx 0 0"???r1   c                 .    t        ||      r ||      S |S rP   )
isinstance)r,   rR   	converterr   s       r/   __convert_datazBucket.__convert_dataE  s    dE"T?"Kr1   )
FNNrU   TNNNFT)NNFN)rU   rU   rU   r4   N)rU   rU   rU   rU   Fr  r4   N)NN)NNN)NNNNN)NNNNrP   )rU   rU   rU   rU     N)rU   r  N)rU   rU   r4   )r   r   )rU   rU   rU   r4   rU   Nr   r   r   )rV   rW   rX   r   r  r  r  r  r  r)  r<  rG  rW  r\  rf  r  r0  r5  rQ  rt  r  r  r  r  r  r  r  r  r{   r  r  
SEQUENTIALr  r  r  r  r  r  r  r  r  r  r  r3  rE  rL  rV  rW  rf  rl  rw  r  r   r  r  r   r  r  r   r   r   r   r   r0   rM   r  r%  r.  r:  rA  rC  rE  rL  rV  re  ro  rr  rt  rx  r}  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r"  r%  r*  r.  r3  r8  r=  rA  rC  rJ  rM  rQ  rU  rZ  r]  rb  ri  rl  rr  rw  r{  r}  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r
  r  r  r  r  r"  r&  r)  r.  r0  r4  r8  r@  rB  rF  rJ  rO  rS  rY  r^  rb  rd  ri  rn  rr  rt  rx  r|  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r5  r"  r  r   r   s   @r/   r   r   I  sp   8 CDIHGGGDDF
CGDKGGJHJIGJF&NHHKJI'-DGKK002EJ$N$NEJ)MH3 L2;$H! L-5-5+"M+"M  !% !$)-N*/b^(Y6^D  %)'T &*/3a*> /38<o" #(,#,^ #%).Ib &*!%"	8Hv '+#'-1#'"&'T (,$(.2I> 04,06:	 F &*!%6X<&/P)8@%<M&#&+#Z#:\0h6h6j4#J%N#. '))+*,02+/'+%lR /3-%` 7;U8#(&8#&
#	#\	#^#
#
h#f	#d#	#d^^#d#f	#`b$e
#k#")&#>W2#2
#
n##*W#( HJ7;$hL#$j	#	+#
#	s# 	^	#
#	en"
n# 
}A 
#$
#
##"	e#	s#	D
D# 	F
q	k
#	b
##pn#
#	x	x
##g	b
#b&
#f#	#z	#
HC#d	J	mg
#
i#0
##	z##	z##(h|
#A@r1   r   c                 $   | }| j                  d      s| j                  d      sd| z   }t        |      }|j                  5|j                  dz   |j                  z   dz   t        |j                        z   S |j                  dz   |j                  z   S )Nr  r  z://:)r  r   portschemehostnamerp   )r   r  r  s      r/   r   r   L  s    
Cy)(2E2Ej2Q("Avvxx%!**,s2S[@@xx%!**,,r1   r5      c                 D    | y| d   }| d   }||ydt        ||      z   S )NrU   r   r   zbytes=)_range)rN  startlasts      r/   rP  rP  _  s:    }!HE8D}fUD)))r1   c                 0    d } ||       dz    ||      z   S )Nc                     | yt        |       S r  )rp   )poss    r/   to_strz_range.<locals>.to_strm  s    ;s8Or1   -rZ   )r  r  r  s      r/   r  r  l  s!     %=3--r1   c                     t        j                  |       rt        S |rt        S |rt        S t        j
                  |      rt        S t        S rP   )r   is_ip_or_localhost_ENDPOINT_TYPE_IP_ENDPOINT_TYPE_CNAME_ENDPOINT_TYPE_PATH_STYLEr
  _ENDPOINT_TYPE_ALIYUN)netlocr-   rD   r.   s       r/   _determine_endpoint_typer  v  sB    '  ##((!!+.$$  r1   c                       e Zd Zd ZddZy)r(   c                 z    t        |      }|j                  | _        |j                  | _        || _        || _        y rP   )r   r  r  r-   r.   )r,   r   r-   r.   r  s        r/   r0   z_UrlMaker.__init__  s1    Xhhhh *r1   c                    t        | j                  | j                  || j                        | _        |du rdnd}t        ||      }| j                  t        k(  r'dj                  | j                  | j                  |      S | j                  t        k(  s| j                  t        k(  rQ|r(dj                  | j                  | j                  ||      S dj                  | j                  | j                  |      S |s*|rJ dj                  | j                  | j                        S dj                  | j                  || j                  |      S )	NTr  rU   )safez{0}://{1}/{2}z{0}://{1}/{2}/{3}z	{0}://{1}z{0}://{1}.{2}/{3})r  r  r-   r.   typer   r  r   r  r  r  )r,   rD   rE   r  r  s        r/   __call__z_UrlMaker.__call__  s   ,T[[$--VZVhVhi	 D(sbs&99,,"))$++t{{CHH99))TYY:S-S*11$++t{{KY\]]&--dkk4;;LLN7%%dkk4;;??"))$++{DKKQTUUr1   Nr   )rV   rW   rX   r0   r  rZ   r1   r/   r(   r(     s    +Vr1   r(   )"r   r   rU   r   r   r   r   r   r	   r
   compatr   r   r   r   r@   timerj  	getLoggerrV   r=   objectr   r\   r   r   r  r  r  r  rP  r  r  r(   rZ   r1   r/   <module>r     s   sh          = =    			8	$EF EPs#e s#j	@,U @,FX-     
*.! V Vr1   