七牛 SDK Python 绑定接口文档

• Index

• Module Index

• Search Page

class qiniu_bindings.etag.EtagV1

Bases: object

Etag V1 计算器 通过 EtagV1() 创建

finalize()

获取 Etag 计算结果，并且重置计算器

reset()

重置 Etag 计算器

write(data)

写入数据到 Etag 计算器

qiniu_bindings.etag.async_etag_of(reader)

异步读取 reader 中的数据并计算它的 Etag V1，生成结果

qiniu_bindings.etag.etag_of(reader)

读取 reader 中的数据并计算它的 Etag V1，生成结果

class qiniu_bindings.credential.ChainCredentialsProvider(creds)

Bases: CredentialProvider

认证信息串提供者

将多个认证信息提供者串联，遍历并找寻第一个可用认证信息

通过 ChainCredentialsProvider([credential1, credential2, credential3, ...]) 创建

class qiniu_bindings.credential.Credential(access_key, secret_key)

Bases: CredentialProvider

认证信息

通过 Credential(access_key, secret_key) 创建

access_key

获取认证信息的 AccessKey

authorization_v1_for_request(url, content_type, body)

使用七牛签名算法 V1 对 HTTP 请求（请求体为内存数据）进行签名，返回 Authorization 的值

authorization_v1_for_request_with_async_body_reader(url, content_type, body)

使用七牛签名算法 V1 对 HTTP 请求（请求体为异步输入流）进行签名，返回 Authorization 的值

authorization_v1_for_request_with_body_reader(url, content_type, body)

使用七牛签名算法 V1 对 HTTP 请求（请求体为输入流）进行签名，返回 Authorization 的值

authorization_v2_for_request(method, url, headers, body)

使用七牛签名算法 V2 对 HTTP 请求（请求体为内存数据）进行签名，返回 Authorization 的值

authorization_v2_for_request_with_async_body_reader(method, url, headers, body)

使用七牛签名算法 V2 对 HTTP 请求（请求体为异步输入流）进行签名，返回 Authorization 的值

authorization_v2_for_request_with_body_reader(method, url, headers, body)

使用七牛签名算法 V2 对 HTTP 请求（请求体为输入流）进行签名，返回 Authorization 的值

secret_key

获取认证信息的 SecretKey

sign(data)

使用七牛签名算法对数据进行签名

参考 https://developer.qiniu.com/kodo/manual/1201/access-token

sign_async_reader(io_base)

使用七牛签名算法对异步输入流数据进行签名

参考 https://developer.qiniu.com/kodo/manual/1201/access-token

sign_download_url(url, secs)

对对象的下载 URL 签名，可以生成私有存储空间的下载地址

sign_reader(io_base)

使用七牛签名算法对输入流数据进行签名

参考 https://developer.qiniu.com/kodo/manual/1201/access-token

class qiniu_bindings.credential.CredentialProvider

Bases: object

认证信息获取接口

抽象类

async_get(opts=None)

异步返回七牛认证信息

get(opts=None)

返回七牛认证信息

该方法的异步版本为 [Self::async_get]。

class qiniu_bindings.credential.EnvCredentialProvider

Bases: CredentialProvider

环境变量认证信息提供者，可以将认证信息配置在环境变量中。

通过 EnvCredentialProvider() 创建

static clear()

清空环境变量认证信息

static setup(credential)

配置环境变量认证信息提供者

class qiniu_bindings.credential.GetOptions

Bases: object

获取认证信息的选项

通过 GetOptions() 创建

class qiniu_bindings.credential.GlobalCredentialProvider

Bases: CredentialProvider

全局认证信息提供者，可以将认证信息配置在全局变量中。任何全局认证信息提供者实例都可以设置和访问全局认证信息。

通过 GlobalCredentialProvider() 创建

static clear()

清空全局认证信息

static setup(credential)

配置全局认证信息

class qiniu_bindings.upload_token.BucketUploadTokenProvider(bucket, lifetime_secs, credential, /, on_policy_generated=None)

Bases: UploadTokenProvider

基于存储空间的动态生成

根据存储空间的快速生成上传凭证实例

通过 BucketUploadTokenProvider(bucket, lifetime_secs, credential, on_policy_generated = None) 创建静态上传凭证提供者

class qiniu_bindings.upload_token.FromUploadPolicy(upload_policy, credential)

Bases: UploadTokenProvider

根据上传凭证生成上传策略

通过 FromUploadPolicy(upload_policy, credential) 创建静态上传凭证提供者

class qiniu_bindings.upload_token.GetAccessKeyOptions

Bases: object

获取 Access Key 的选项

通过 GetAccessKeyOptions() 创建获取 Access Key 的选项

class qiniu_bindings.upload_token.GetPolicyOptions

Bases: object

获取上传策略的选项

通过 GetPolicyOptions() 创建获取上传策略的选项

class qiniu_bindings.upload_token.ObjectUploadTokenProvider(bucket, object, lifetime_secs, credential, /, on_policy_generated=None)

Bases: UploadTokenProvider

基于对象的动态生成

根据对象的快速生成上传凭证实例

通过 ObjectUploadTokenProvider(bucket, object, lifetime_secs, credential, on_policy_generated = None) 创建静态上传凭证提供者

class qiniu_bindings.upload_token.StaticUploadTokenProvider(upload_token)

Bases: UploadTokenProvider

静态上传凭证提供者

根据已经被生成好的上传凭证字符串生成上传凭证获取接口的实例，可以将上传凭证解析为 Access Token 和上传策略

通过 StaticUploadTokenProvider(upload_token) 创建静态上传凭证提供者

class qiniu_bindings.upload_token.ToStringOptions

Bases: object

获取上传凭证的选项

通过 ToStringOptions() 创建获取上传凭证的选项

class qiniu_bindings.upload_token.UploadPolicy

Bases: object

上传策略

可以阅读 <https://developer.qiniu.com/kodo/manual/1206/put-policy> 了解七牛安全机制。

可以使用 UploadPolicy.new_for_bucket(bucket, lifetime, **fields) 或 UploadPolicy.new_for_object(bucket, object, lifetime, **fields) 或 UploadPolicy.new_for_objects_with_prefix(bucket, prefix, lifetime, **fields) 创建上传策略

as_json()

获取 JSON 格式的上传凭证

bucket

获取存储空间约束

callback_body

上传成功后，七牛云向业务服务器发送回调请求时的内容

支持魔法变量和自定义变量

callback_body_type

上传成功后，七牛云向业务服务器发送回调请求时的 Content-Type

默认为 application/x-www-form-urlencoded，也可设置为 application/json

callback_host

上传成功后，七牛云向业务服务器发送回调请求时的 Host

callback_urls

上传成功后，七牛云向业务服务器发送 POST 请求的 URL 列表

file_type

获取文件类型

static from_json(json)

解析 JSON 格式的上传凭证

get(key)

根据指定的上传策略字段获取相应的值

is_insert_only

是否仅允许新增对象，不允许覆盖对象

is_save_key_forced

是否忽略客户端指定的对象名称，强制使用自定义对象名称进行文件命名

key

获取对象名称约束或对象名称前缀约束

keys

获取上传策略的字段数组

maximum_file_size

限定上传文件尺寸的上限，单位为字节

mime_detection_enabled

是否启用 MIME 类型自动检测

mime_types

限定用户上传的文件类型

指定本字段值，七牛服务器会侦测文件内容以判断 MIME 类型，再用判断值跟指定值进行匹配， 匹配成功则允许上传，匹配失败则返回 403 状态码

minimum_file_size

限定上传文件尺寸的下限，单位为字节

static new_for_bucket(bucket, lifetime, **fields)

为指定的存储空间生成的上传策略

允许用户上传文件到指定的存储空间，不限制上传客户端指定对象名称。

上传策略根据给出的客户端配置指定上传凭证有效期

static new_for_object(bucket, object, lifetime, **fields)

为指定的存储空间和对象名称生成的上传策略

允许用户以指定的对象名称上传文件到指定的存储空间。 上传客户端不能指定与上传策略冲突的对象名称。

上传策略根据给出的客户端配置指定上传凭证有效期

static new_for_objects_with_prefix(bucket, prefix, lifetime, **fields)

为指定的存储空间和对象名称前缀生成的上传策略

允许用户以指定的对象名称前缀上传文件到指定的存储空间。 上传客户端指定包含该前缀的对象名称。

上传策略根据给出的客户端配置指定上传凭证有效期

object_lifetime

获取对象生命周期

单位为秒，但精确到天

return_body

上传成功后，自定义七牛云最终返回给上传端的数据

return_url

Web 端文件上传成功后，浏览器执行 303 跳转的 URL

save_key

自定义对象名称

支持魔法变量和自定义变量

to_upload_token_provider()

将上传策略转换为动态上传凭证提供者的实例

token_deadline

获取上传凭证过期时间戳

use_prefixal_object_key

是否是对象名称前缀约束

values

获取上传策略的字段值的数组

class qiniu_bindings.upload_token.UploadPolicyBuilder

Bases: object

上传策略构建器

用于生成上传策略，一旦生成完毕，上传策略将无法被修改

可以使用 UploadPolicyBuilder.new_for_bucket(bucket, lifetime, **fields) 或 UploadPolicyBuilder.new_for_object(bucket, object, lifetime, **fields) 或 UploadPolicyBuilder.new_for_objects_with_prefix(bucket, prefix, lifetime, **fields) 创建上传策略

build()

生成上传策略

callback(urls, host='', body='', body_type='')

上传成功后，自定义七牛云最终返回给上传端（在指定 return_url() 时是携带在跳转路径参数中）的数据

支持[魔法变量](https://developer.qiniu.com/kodo/manual/1235/vars#magicvar)和[自定义变量](https://developer.qiniu.com/kodo/manual/1235/vars#xvar)。 return_body 要求是合法的 JSON 文本。 例如 {"key": $(key), "hash": $(etag), "w": $(imageInfo.width), "h": $(imageInfo.height)}

disable_mime_detection()

禁用 MIME 类型自动检测

enable_mime_detection()

启用 MIME 类型自动检测

file_size_limitation(min=None, max=None)

限定上传文件尺寸的范围

单位为字节

file_type

设置文件类型

insert_only()

仅允许创建新的对象，不允许覆盖和修改同名对象

mime_types

限定用户上传的文件类型

指定本字段值，七牛服务器会侦测文件内容以判断 MIME 类型，再用判断值跟指定值进行匹配， 匹配成功则允许上传，匹配失败则返回 403 状态码

static new_for_bucket(bucket, lifetime_secs, **fields)

为指定的存储空间生成的上传策略

允许用户上传文件到指定的存储空间，不限制上传客户端指定对象名称。

上传策略根据给出的客户端配置指定上传凭证有效期

static new_for_object(bucket, object, lifetime_secs, **fields)

为指定的存储空间和对象名称生成的上传策略

允许用户以指定的对象名称上传文件到指定的存储空间。 上传客户端不能指定与上传策略冲突的对象名称。

上传策略根据给出的客户端配置指定上传凭证有效期

static new_for_objects_with_prefix(bucket, prefix, lifetime_secs, **fields)

为指定的存储空间和对象名称前缀生成的上传策略

允许用户以指定的对象名称前缀上传文件到指定的存储空间。 上传客户端指定包含该前缀的对象名称。

上传策略根据给出的客户端配置指定上传凭证有效期

object_lifetime

设置对象生命周期

单位为秒，但精确到天

return_body

设置上传成功后，自定义七牛云最终返回给上传端的数据

return_url

Web 端文件上传成功后，浏览器执行 303 跳转的 URL

通常用于表单上传。 文件上传成功后会跳转到 <return_url>?upload_ret=<queryString>， <queryString> 包含 return_body 内容。 如不设置 return_url，则直接将 return_body 的内容返回给客户端

save_as(save_as, force=False)

自定义对象名称

支持[魔法变量](https://developer.qiniu.com/kodo/manual/1235/vars#magicvar)和[自定义变量](https://developer.qiniu.com/kodo/manual/1235/vars#xvar)。 force 为 false 时，save_as 字段仅当用户上传的时候没有主动指定对象名时起作用， force 为 true 时，将强制按 save_as 字段的内容命名

token_deadline

指定上传凭证过期时间

token_lifetime

指定上传凭证有效期

class qiniu_bindings.upload_token.UploadPolicyBuilderRef

Bases: object

上传策略构建器

该类型没有构造函数，仅限于在回调函数中使用，一旦移出回调函数，对其做任何操作都将引发无法预期的后果。

callback(urls, host='', body='', body_type='')

上传成功后，自定义七牛云最终返回给上传端（在指定 return_url() 时是携带在跳转路径参数中）的数据

支持[魔法变量](https://developer.qiniu.com/kodo/manual/1235/vars#magicvar)和[自定义变量](https://developer.qiniu.com/kodo/manual/1235/vars#xvar)。 return_body 要求是合法的 JSON 文本。 例如 {"key": $(key), "hash": $(etag), "w": $(imageInfo.width), "h": $(imageInfo.height)}

disable_mime_detection()

禁用 MIME 类型自动检测

enable_mime_detection()

启用 MIME 类型自动检测

file_size_limitation(min=None, max=None)

限定上传文件尺寸的范围

单位为字节

file_type

设置文件类型

insert_only()

仅允许创建新的对象，不允许覆盖和修改同名对象

mime_types

限定用户上传的文件类型

指定本字段值，七牛服务器会侦测文件内容以判断 MIME 类型，再用判断值跟指定值进行匹配， 匹配成功则允许上传，匹配失败则返回 403 状态码

object_lifetime

设置对象生命周期

单位为秒，但精确到天

return_body

设置上传成功后，自定义七牛云最终返回给上传端的数据

return_url

Web 端文件上传成功后，浏览器执行 303 跳转的 URL

通常用于表单上传。 文件上传成功后会跳转到 <return_url>?upload_ret=<queryString>， <queryString> 包含 return_body 内容。 如不设置 return_url，则直接将 return_body 的内容返回给客户端

save_as(save_as, force=False)

自定义对象名称

支持[魔法变量](https://developer.qiniu.com/kodo/manual/1235/vars#magicvar)和[自定义变量](https://developer.qiniu.com/kodo/manual/1235/vars#xvar)。 force 为 false 时，save_as 字段仅当用户上传的时候没有主动指定对象名时起作用， force 为 true 时，将强制按 save_as 字段的内容命名

token_deadline

指定上传凭证过期时间

token_lifetime

指定上传凭证有效期

class qiniu_bindings.upload_token.UploadTokenProvider

Bases: object

上传凭证获取接口

抽象类

可以阅读 <https://developer.qiniu.com/kodo/manual/1208/upload-token> 了解七牛安全机制。

access_key(opts=None)

从上传凭证内获取 AccessKey

async_access_key(opts=None)

异步从上传凭证内获取 AccessKey

async_bucket_name(opts=None)

异步获取上传凭证中的存储空间名称

async_policy(opts=None)

异步从上传凭证内获取上传策略

async_to_token_string(opts=None)

异步生成字符串

bucket_name(opts=None)

获取上传凭证中的存储空间名称

policy(opts=None)

从上传凭证内获取上传策略

to_token_string(opts=None)

生成字符串

class qiniu_bindings.http.AsyncHttpRequest(url=None, method=None, headers=None, body=None, body_len=None, appended_user_agent=None, resolved_ip_addrs=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, timeout_ms=None, connect_timeout_ms=None, /)

Bases: HttpRequestParts

异步 HTTP 请求

封装 HTTP 请求相关字段

通过 AsyncHttpRequest(url = None, method = None, headers = None, body = None, body_len = None, appended_user_agent = None, resolved_ip_addrs = None, uploading_progress = None, receive_response_status = None, receive_response_header = None, timeout_ms = None, connect_timeout_ms = None) 创建异步 HTTP 请求

body

设置请求体

class qiniu_bindings.http.AsyncHttpResponse(status_code=None, headers=None, version=None, server_ip=None, server_port=None, body=None, metrics=None, /)

Bases: HttpResponseParts

异步 HTTP 响应

封装 HTTP 响应相关字段

通过 AsyncHttpResponse(status_code = None, headers = None, version = None, server_ip = None, server_port = None, body = None, metrics = None) 创建异步 HTTP 响应

parse_json()

异步解析 JSON 响应体

read(size=- 1, /)

异步读取响应体数据

readall()

异步所有读取响应体数据

class qiniu_bindings.http.HttpCaller

Bases: object

HTTP 请求处理接口

抽象类

实现该接口，即可处理所有七牛 SDK 发送的 HTTP 请求

async_call(request)

异步发送 HTTP 请求

call(request)

阻塞发送 HTTP 请求

class qiniu_bindings.http.HttpRequestParts(url=None, method=None, headers=None, appended_user_agent=None, resolved_ip_addrs=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, timeout_ms=None, connect_timeout_ms=None, /)

Bases: object

HTTP 请求信息

不包含请求体信息

通过 HttpRequestParts(url = None, method = None, headers = None, appended_user_agent = None, resolved_ip_addrs = None, uploading_progress = None, receive_response_status = None, receive_response_header = None, timeout_ms = None, connect_timeout_ms = None) 创建 HTTP 请求信息

appended_user_agent

获取追加的用户代理

connect_timeout_ms

获取连接请求超时时长

headers

获取请求 HTTP Headers

method

获取请求 HTTP 方法

receive_response_header

设置接受到响应 Header 回调

receive_response_status

设置接受到响应状态回调

resolved_ip_addrs

获取预解析的服务器套接字地址

timeout_ms

获取请求超时时长

uploading_progress

设置上传进度回调

url

获取 HTTP 请求 URL

user_agent

获取用户代理

version

获取请求 HTTP 版本

class qiniu_bindings.http.HttpResponseParts

Bases: object

HTTP 响应基础信息

抽象类

不包含响应体信息

headers

获取 HTTP Headers

metrics

获取 HTTP 响应的指标信息

server_ip

获取 HTTP 服务器 IP 地址

server_port

获取 HTTP 服务器端口号

status_code

获取 HTTP 状态码

version

获取 HTTP 版本

class qiniu_bindings.http.HttpResponsePartsMut

Bases: object

HTTP 响应信息可变引用

不包含响应体信息

该类型没有构造函数，仅限于在回调函数中使用，仅限于在回调函数中使用，一旦移出回调函数，对其做任何操作都将引发无法预期的后果。

headers

获取 HTTP Headers

metrics

获取 HTTP 响应的指标信息

server_ip

获取 HTTP 服务器 IP 地址

server_port

获取 HTTP 服务器端口号

status_code

获取 HTTP 状态码

version

获取 HTTP 版本

class qiniu_bindings.http.HttpResponsePartsRef

Bases: object

HTTP 响应信息引用

不包含响应体信息

该类型没有构造函数，仅限于在回调函数中使用，仅限于在回调函数中使用，一旦移出回调函数，对其做任何操作都将引发无法预期的后果。

headers

获取 HTTP Headers

metrics

获取 HTTP 响应的指标信息

server_ip

获取 HTTP 服务器 IP 地址

server_port

获取 HTTP 服务器端口号

status_code

获取 HTTP 状态码

version

获取 HTTP 版本

class qiniu_bindings.http.IsahcHttpCaller

Bases: HttpCaller

七牛 Isahc HTTP 客户端实现

基于 Isahc 库提供 HTTP 客户端接口实现

通过 IsahcHttpCaller() 创建 Isahc HTTP 客户端

class qiniu_bindings.http.Metrics(total_duration_ns=None, name_lookup_duration_ns=None, connect_duration_ns=None, secure_connect_duration_ns=None, redirect_duration_ns=None, transfer_duration_ns=None, /)

Bases: object

HTTP 响应的指标信息

通过 Metrics(total_duration_ns = None, name_lookup_duration_ns = None, connect_duration_ns = None, secure_connect_duration_ns = None, redirect_duration_ns = None, transfer_duration_ns = None) 创建 HTTP 响应的指标信息

connect_duration

获取建立连接的耗时

name_lookup_duration

获取域名查询的耗时

redirect_duration

获取重定向的耗时

secure_connect_duration

获取建立安全连接的耗时

total_duration

获取总体请求耗时

transfer_duration

获取请求和响应数据传输的耗时

class qiniu_bindings.http.SyncHttpRequest(url=None, method=None, headers=None, body=None, body_len=None, appended_user_agent=None, resolved_ip_addrs=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, timeout_ms=None, connect_timeout_ms=None, /)

Bases: HttpRequestParts

阻塞 HTTP 请求

封装 HTTP 请求相关字段

通过 SyncHttpRequest(url = None, method = None, headers = None, body = None, body_len = None, appended_user_agent = None, resolved_ip_addrs = None, uploading_progress = None, receive_response_status = None, receive_response_header = None, timeout_ms = None, connect_timeout_ms = None) 创建阻塞 HTTP 请求

body

设置请求体

class qiniu_bindings.http.SyncHttpResponse(status_code=None, headers=None, version=None, server_ip=None, server_port=None, body=None, metrics=None, /)

Bases: HttpResponseParts

阻塞 HTTP 响应

封装 HTTP 响应相关字段

通过 SyncHttpResponse(status_code = None, headers = None, version = None, server_ip = None, server_port = None, body = None, metrics = None) 创建阻塞 HTTP 响应

parse_json()

解析 JSON 响应体

read(size=- 1, /)

读取响应体数据

readall()

读取所有响应体数据

class qiniu_bindings.http.Version

Bases: object

HTTP 版本

class qiniu_bindings.http_client.AllRegionsProvider(credential_provider, /, auto_persistent=True, use_https=True, uc_endpoints=None, cache_lifetime_secs=None, shrink_interval_secs=None)

Bases: RegionsProvider

七牛所有区域信息查询器

通过 AllRegionsProvider(credential_provider, auto_persistent = True, use_https = True, uc_endpoints = None, cache_lifetime_secs = None, shrink_interval_secs = None) 创建七牛所有区域信息查询器

static in_memory(credential_provider, /, use_https=True, uc_endpoints=None, cache_lifetime_secs=None, shrink_interval_secs=None)

构建七牛所有区域信息查询器

不启用文件系统持久化缓存

static load_or_create_from(credential_provider, path, /, auto_persistent=True, use_https=True, uc_endpoints=None, cache_lifetime_secs=None, shrink_interval_secs=None)

从文件系统加载或构建七牛所有区域信息查询器

可以选择是否启用自动持久化缓存功能

class qiniu_bindings.http_client.Authorization

Bases: object

七牛鉴权签名

可以使用 Authorization.upload_token(upload_token_provider) 或 Authorization.v1(credential_provider) 或 Authorization.v2(credential_provider) 或 Authorization.download(credential_provider) 创建七牛鉴权签名

async_sign(request)

使用指定的鉴权方式对异步 HTTP 请求进行签名

static download(credential_provider)

根据认证信息获取接口创建一个下载凭证签名算法的签名

sign(request)

使用指定的鉴权方式对 HTTP 请求进行签名

static upload_token(upload_token_provider)

根据上传凭证获取接口创建一个上传凭证签名算法的签名

static v1(credential_provider)

根据认证信息获取接口创建一个使用七牛鉴权 v1 签名算法的签名

static v2(credential_provider)

根据认证信息获取接口创建一个使用七牛鉴权 v2 签名算法的签名

class qiniu_bindings.http_client.Backoff

Bases: object

退避时长获取接口

抽象类

time_ns(error, /, decision=None, retried=None)

获取退避时长

class qiniu_bindings.http_client.BucketDomainsQueryer(auto_persistent=True, use_https=True, uc_endpoints=None, cache_lifetime_secs=None, shrink_interval_secs=None, /)

Bases: object

存储空间绑定域名查询器

查询该存储空间绑定的域名。

通过 BucketDomainsQueryer(auto_persistent = True, use_https = True, uc_endpoints = None, cache_lifetime_secs = None, shrink_interval_secs = None) 创建存储空间绑定域名查询器

static in_memory(auto_persistent=True, use_https=True, uc_endpoints=None, cache_lifetime_secs=None, shrink_interval_secs=None, /)

构建存储空间绑定域名查询器

不启用文件系统持久化缓存

static load_or_create_from(path, /, auto_persistent=True, use_https=True, uc_endpoints=None, cache_lifetime_secs=None, shrink_interval_secs=None)

从文件系统加载或构建存储空间绑定域名查询器

可以选择是否启用自动持久化缓存功能

query(access_key, bucket_name)

查询存储空间相关域名

class qiniu_bindings.http_client.BucketRegionsQueryer(auto_persistent=True, use_https=True, uc_endpoints=None, cache_lifetime_secs=None, shrink_interval_secs=None, /)

Bases: object

存储空间相关区域查询构建器

通过 BucketRegionsQueryer(auto_persistent = True, use_https = True, uc_endpoints = None, cache_lifetime_secs = None, shrink_interval_secs = None) 创建存储空间相关区域查询构建器

static in_memory(use_https=True, uc_endpoints=None, cache_lifetime_secs=None, shrink_interval_secs=None, /)

构建存储空间相关区域查询器

不启用文件系统持久化缓存

static load_or_create_from(path, /, auto_persistent=True, use_https=True, uc_endpoints=None, cache_lifetime_secs=None, shrink_interval_secs=None)

从文件系统加载或构建存储空间相关区域查询器

可以选择是否启用自动持久化缓存功能

query(access_key, bucket_name)

查询存储空间相关区域

class qiniu_bindings.http_client.CachedResolver(resolver, /, auto_persistent=None, cache_lifetime_secs=None, shrink_interval_secs=None)

Bases: Resolver

域名解析缓存器

为一个域名解析器实例提供内存和文件系统缓存功能

默认缓存 120 秒，清理间隔为 120 秒

通过 CachedResolver(resolver, auto_persistent = None, cache_lifetime_secs = None, shrink_interval_secs = None) 创建域名解析缓存器

static in_memory(resolver, /, cache_lifetime_secs=None, shrink_interval_secs=None)

构建域名解析缓存器

不启用文件系统持久化缓存

static load_or_create_from(resolver, path, /, auto_persistent=True, cache_lifetime_secs=None, shrink_interval_secs=None)

从文件系统加载或构建域名解析缓存器

可以选择是否启用自动持久化缓存功能

class qiniu_bindings.http_client.CallbackContextMut

Bases: object

回调函数上下文

基于简化回调函数上下文，并在此基础上增加获取扩展信息的引用和可变引用的方法。

该类型没有构造函数，仅限于在回调函数中使用，仅限于在回调函数中使用，一旦移出回调函数，对其做任何操作都将引发无法预期的后果。

appended_user_agent

获取追加的 UserAgent

connect_timeout_ms

获取连接请求超时时长

headers

获取请求 HTTP Headers

idempotent

获取七牛鉴权签名

method

获取请求 HTTP 方法

path

获取请求路径

query

获取请求查询参数

query_pairs

获取请求查询对

timeout_ms

获取请求超时时长

use_https

是否使用 HTTPS 协议

version

获取请求 HTTP 版本

class qiniu_bindings.http_client.ChainedResolver(resolvers)

Bases: Resolver

域名解析串

将多个域名解析器串联起来，遍历并找寻第一个可用的解析结果

通过 ChainedResolver(resolvers) 创建域名解析串

class qiniu_bindings.http_client.Chooser

Bases: object

选择 IP 地址接口

抽象类

还提供了对选择结果的反馈接口，用以修正自身选择逻辑，优化选择结果

async_choose(domain_with_port=None)

异步选择 IP 地址列表

async_feedback(domain=None, retried=None, metrics=None, error=None)

异步反馈选择的 IP 地址列表的结果

choose(domain_with_port=None)

选择 IP 地址列表

feedback(domain=None, retried=None, metrics=None, error=None)

反馈选择的 IP 地址列表的结果

class qiniu_bindings.http_client.DirectChooser

Bases: Chooser

直接选择器

不做任何筛选，也不接受任何反馈，直接将给出的 IP 地址列表返回

通过 DirectChooser() 创建直接选择器

class qiniu_bindings.http_client.DomainWithPort(domain, port=None)

Bases: object

域名和端口号

用来表示一个七牛服务器的地址，端口号是可选的，如果不提供，则根据传输协议判定默认的端口号。

通过 DomainWithPort(domain, port = None) 创建域名和端口号

domain

获取域名

port

获取端口

class qiniu_bindings.http_client.Endpoint(domain_or_ip_addr, port=None)

Bases: object

终端地址

用来表示一个域名和端口号，或 IP 地址和端口号。

通过 Endpoint(domain_or_ip_addr, port = None) 创建域名和端口号

domain

获取域名

ip_addr

获取 IP 地址

port

获取端口

class qiniu_bindings.http_client.Endpoints(preferred_endpoints, alternative_endpoints=None)

Bases: EndpointsProvider

终端地址列表

存储一个七牛服务的多个终端地址，包含主要地址列表和备选地址列表

通过 Endpoints(preferred_endpoints, alternative_endpoints = None) 创建终端地址列表

alternative

返回备选终端地址列表

preferred

返回主要终端地址列表

class qiniu_bindings.http_client.EndpointsProvider(regions_provider)

Bases: object

终端地址列表获取接口

同时提供阻塞获取接口和异步获取接口，异步获取接口则需要启用 async 功能

通过 EndpointsProvider(regions_provider) 创建终端地址列表获取接口

async_get(service_names=None)

异步获取终端地址列表

get(service_names=None)

获取终端地址列表

class qiniu_bindings.http_client.ErrorRetrier

Bases: RequestRetrier

根据七牛 API 返回的状态码作出重试决定

通过 ErrorRetrier() 创建七牛状态码重试器

class qiniu_bindings.http_client.ExponentialBackoff(base_number, base_delay)

Bases: Backoff

指数级增长的退避时长提供者

通过 ExponentialBackoff(base_number, base_delay_ns) 创建指数级增长的退避时长提供者

base_delay

获取底数

base_number

获取底数

class qiniu_bindings.http_client.ExtendedCallbackContextRef

Bases: object

扩展的回调函数上下文

基于回调函数上下文，并在此基础上增加返回部分请求信息的可变引用，以及 UserAgent 和经过解析的 IP 地址列表的获取和设置方法。

该类型没有构造函数，仅限于在回调函数中使用，仅限于在回调函数中使用，一旦移出回调函数，对其做任何操作都将引发无法预期的后果。

appended_user_agent

获取追加的 UserAgent

connect_timeout_ms

获取连接请求超时时长

headers

获取请求 HTTP Headers

idempotent

获取七牛鉴权签名

method

获取请求 HTTP 方法

path

获取请求路径

query

获取请求查询参数

query_pairs

获取请求查询对

resolved_ip_addrs

获取经过解析的 IP 地址列表

retried

获取重试统计信息

timeout_ms

获取请求超时时长

url

获取 HTTP 请求 URL

use_https

是否使用 HTTPS 协议

user_agent

获取 UserAgent

version

获取请求 HTTP 版本

class qiniu_bindings.http_client.FixedBackoff(delay)

Bases: Backoff

固定时长的退避时长提供者

通过 FixedBackoff(delay_ns) 创建固定时长的退避时长提供者

delay

获取固定时长

class qiniu_bindings.http_client.HttpClient(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: object

HTTP 客户端

用于发送 HTTP 请求的入口。

创建 HttpClient(http_caller = None, use_https = None, appended_user_agent = None, request_retrier = None, backoff = None, chooser = None, resolver = None, uploading_progress = None, receive_response_status = None, receive_response_header = None, to_resolve_domain = None, domain_resolved = None, to_choose_ips = None, ips_chosen = None, before_request_signed = None, after_request_signed = None, response_ok = None, response_error = None, before_backoff = None, after_backoff = None) 创建 HTTP 客户端

async_call(endpoints, /, service_names=None, use_https=None, version=None, path=None, headers=None, accept_json=None, accept_application_octet_stream=None, query=None, query_pairs=None, appended_user_agent=None, authorization=None, idempotent=None, bytes=None, body=None, body_len=None, content_type=None, json=None, form=None, multipart=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(endpoints, /, service_names=None, use_https=None, version=None, path=None, headers=None, accept_json=None, accept_application_octet_stream=None, query=None, query_pairs=None, appended_user_agent=None, authorization=None, idempotent=None, bytes=None, body=None, body_len=None, content_type=None, json=None, form=None, multipart=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

static default_backoff()

获得默认的 [Backoff] 实例

static default_chooser()

获得默认的 [Chooser] 实例

static default_http_caller()

获得默认的 [HttpCaller] 实例

static default_resolver()

获得默认的 [Resolver] 实例

static default_retrier()

获得默认的 [RequestRetrier] 实例

class qiniu_bindings.http_client.Idempotent

Bases: object

API 幂等性

class qiniu_bindings.http_client.IpAddrWithPort(ip, port=None)

Bases: object

IP 地址和端口号

用来表示一个七牛服务器的地址，端口号是可选的，如果不提供，则根据传输协议判定默认的端口号。

通过 IpAddrWithPort(ip, port = None) 创建域名和端口号

ip_addr

获取 IP 地址

port

获取端口

class qiniu_bindings.http_client.IpChooser(block_duration_secs=None, shrink_interval_secs=None, /)

Bases: Chooser

IP 地址选择器

包含 IP 地址黑名单，一旦被反馈 API 调用失败，则将所有相关 IP 地址冻结一段时间

通过 IpChooser(block_duration_secs = None, shrink_interval_secs = None) 创建 IP 地址选择器

class qiniu_bindings.http_client.JsonResponse

Bases: HttpResponseParts

JSON API 响应

封装 JSON API 响应相关字段

该类型没有构造函数，由七牛 API 客户端的 call() 方法返回

body

获得 JSON 响应体

class qiniu_bindings.http_client.LimitedBackoff(back_backoff, min_backoff_ns, max_backoff_ns)

Bases: Backoff

固定时长的退避时长提供者

通过 LimitedBackoff(back_backoff, min_backoff_ns, max_backoff_ns) 创建固定时长的退避时长提供者

max_backoff

获取最长的退避时长

min_backoff

获取最短的退避时长

class qiniu_bindings.http_client.LimitedRetrier(retrier, retries)

Bases: RequestRetrier

受限重试器

为一个重试器实例增加重试次数上限，即重试次数到达上限时，无论错误是什么，都切换服务器地址或不再予以重试。

通过 LimitedRetrier(retrier, retries) 创建受限重试器

static limit_current_endpoint(retrier, retries)

创建限制当前终端地址的重试次数的受限重试器

static limit_total(retrier, retries)

创建受限重试器

class qiniu_bindings.http_client.NeverEmptyHandedChooser(chooser, random_choose_fraction)

Bases: Chooser

永不空手的选择器

确保 [Chooser] 实例不会因为所有可选择的 IP 地址都被屏蔽而导致 HTTP 客户端直接返回错误， 在内置的 [Chooser] 没有返回结果时，将会随机返回一定比例的 IP 地址供 HTTP 客户端做一轮尝试。

通过 NeverEmptyHandedChooser(chooser, random_choose_fraction) 创建永不空手的选择器

class qiniu_bindings.http_client.NeverRetrier

Bases: RequestRetrier

永不重试器

总是返回不再重试的重试器

通过 NeverRetrier() 创建永不重试器

class qiniu_bindings.http_client.RandomizedBackoff(base_backoff, minification, magnification)

Bases: Backoff

均匀分布随机化退避时长提供者

基于一个退避时长提供者并为其增加随机化范围

通过 RandomizedBackoff(base_backoff, minification, magnification) 创建均匀分布随机化退避时长提供者

magnification

获取最大随机比率

minification

获取最小随机比率

class qiniu_bindings.http_client.Region

Bases: RegionsProvider

七牛存储区域

提供七牛不同服务的终端地址列表

通过 Region(region_id, s3_region_id = None, up_preferred_endpoints = None, up_alternative_endpoints = None, io_preferred_endpoints = None, io_alternative_endpoints = None, uc_preferred_endpoints = None, uc_preferred_endpoints = None, rs_preferred_endpoints = None, rs_alternative_endpoints = None, rsf_preferred_endpoints = None, rsf_alternative_endpoints = None, s3_preferred_endpoints = None, s3_alternative_endpoints = None, api_preferred_endpoints = None, api_alternative_endpoints = None) 创建七牛存储区域

api

获取 API 入口服务终端列表

api_alternative_endpoints

获取 API 入口服务备选终端列表

api_preferred_endpoints

获取 API 入口服务主要终端列表

io

获取下载服务终端列表

io_alternative_endpoints

获取下载服务备选终端列表

io_preferred_endpoints

获取下载服务主要终端列表

region_id

获取区域 ID

rs

获取元数据管理服务终端列表

rs_alternative_endpoints

获取元数据管理服务备选终端列表

rs_preferred_endpoints

获取元数据管理服务主要终端列表

rsf

获取元数据列举服务终端列表

rsf_alternative_endpoints

获取元数据列举服务备选终端列表

rsf_preferred_endpoints

获取元数据列举服务主要终端列表

s3

获取 S3 入口服务终端列表

s3_alternative_endpoints

获取 S3 入口服务备选终端列表

s3_preferred_endpoints

获取 S3 入口服务主要终端列表

s3_region_id

获取 S3 区域 ID

uc

获取存储空间管理服务终端列表

uc_alternative_endpoints

获取存储空间管理服务备选终端列表

uc_preferred_endpoints

获取存储空间管理服务主要终端列表

up

获取上传服务终端列表

up_alternative_endpoints

获取上传服务备选终端列表

up_preferred_endpoints

获取上传服务主要终端列表

class qiniu_bindings.http_client.RegionsProvider(regions)

Bases: object

区域信息获取接口

可以获取一个区域也可以获取多个区域

同时提供阻塞获取接口和异步获取接口，异步获取接口则需要启用 async 功能

通过 RegionsProvider(regions) 创建区域信息获取接口

async_get()

异步获取七牛区域信息

async_get_all()

异步获取多个七牛区域信息

get()

获取七牛区域信息

get_all()

获取多个七牛区域信息

class qiniu_bindings.http_client.RequestBuilderPartsRef

Bases: object

HTTP 请求构建器部分参数

包含 HTTP 请求构建器内除请求体和终端地址提供者以外的参数

该类型没有构造函数，仅限于在回调函数中使用，仅限于在回调函数中使用，一旦移出回调函数，对其做任何操作都将引发无法预期的后果。

accept_application_octet_stream()

设置 HTTP 响应预期为二进制流类型

accept_json()

设置 HTTP 响应预期为 JSON 类型

append_query_pair(query_pair_key, query_pair_value)

追加查询参数

appended_user_agent

追加 UserAgent

authorization

设置鉴权签名

connect_timeout_ms

设置连接请求超时时长

headers

设置 HTTP 请求头

idempotent

设置为幂等请求

on_after_backoff(callback)

设置退避后回调函数

on_after_request_signed(callback)

设置 HTTP 请求前回调函数

on_before_backoff(callback)

设置退避前回调函数

on_before_request_signed(callback)

设置 HTTP 请求签名前回调函数

on_domain_resolved(callback)

设置域名解析成功回调函数

on_ips_chosen(callback)

设置 IP 地址选择成功回调函数

on_receive_response_header(callback)

设置响应 HTTP 头回调函数

on_receive_response_status(callback)

设置响应状态码回调函数

on_response(callback)

设置响应成功回调函数

on_to_choose_ips(callback)

设置 IP 地址选择前回调函数

on_to_resolve_domain(callback)

设置域名解析前回调函数

on_uploading_progress(callback)

设置上传进度回调函数

path

设置 HTTP 请求路径

query

设置查询参数

query_pairs

设置查询参数

set_header(header_name, header_value)

添加 HTTP 请求头

timeout_ms

设置请求超时时长

use_https

设置是否使用 HTTPS

version

设置 HTTP 协议版本

class qiniu_bindings.http_client.RequestRetrier

Bases: object

请求重试器

抽象类

根据 HTTP 客户端返回的错误，决定是否重试请求，重试决定由 [RetryDecision] 定义。

retry(error, /, idempotent=None, retried=None)

作出重试决定

class qiniu_bindings.http_client.Resolver

Bases: object

域名解析的接口

抽象类

同时提供阻塞接口和异步接口，异步接口则需要启用 async 功能

async_resolve(domain, /, retried_stats_info=None)

异步解析域名

resolve(domain, /, retried_stats_info=None)

解析域名

class qiniu_bindings.http_client.RetriedStatsInfo

Bases: object

重试统计信息

通过 RetriedStatsInfo() 创建重试统计信息

abandoned_endpoints

获取放弃的终端地址的数量

abandoned_ips_of_current_endpoint

获取放弃的终端的 IP 地址的数量

increase_abandoned_endpoints()

提升放弃的终端地址的数量

increase_abandoned_ips_of_current_endpoint()

提升放弃的终端的 IP 地址的数量

increase_current_endpoint()

提升当前终端地址的重试次数

retried_on_current_endpoint

获取当前终端地址的重试次数

retried_on_current_ips

获取当前 IP 地址的重试次数

retried_total

获取总共重试的次数

switch_endpoint()

切换终端地址

switch_ips()

切换当前 IP 地址

switch_to_alternative_endpoints()

切换到备选终端地址

switched_to_alternative_endpoints

是否切换到了备选终端地址

class qiniu_bindings.http_client.RetryDecision

Bases: object

重试决定

class qiniu_bindings.http_client.ServiceName

Bases: object

七牛服务名称

class qiniu_bindings.http_client.ShuffledChooser(chooser)

Bases: Chooser

随机选择器

基于一个选择器实例，但将其返回的选择结果打乱

通过 ShuffledChooser(chooser) 创建随机选择器

class qiniu_bindings.http_client.ShuffledResolver(resolver)

Bases: Resolver

域名解析随机混淆器

基于一个域名解析器实例，但将其返回的解析结果打乱

通过 ShuffledResolver(resolver) 创建域名解析随机混淆器

class qiniu_bindings.http_client.SimpleResolver

Bases: Resolver

简单域名解析器

基于 libc 库的域名解析接口实现

通过 SimpleResolver() 创建简单域名解析器

class qiniu_bindings.http_client.SimplifiedCallbackContext

Bases: object

简化回调函数上下文

用于在回调函数中获取请求相关信息，如请求路径、请求方法、查询参数、请求头等。

该类型没有构造函数，仅限于在回调函数中使用，仅限于在回调函数中使用，一旦移出回调函数，对其做任何操作都将引发无法预期的后果。

appended_user_agent

获取追加的 UserAgent

headers

获取请求 HTTP Headers

idempotent

获取七牛鉴权签名

method

获取请求 HTTP 方法

path

获取请求路径

query

获取请求查询参数

query_pairs

获取请求查询对

use_https

是否使用 HTTPS 协议

version

获取请求 HTTP 版本

class qiniu_bindings.http_client.SubnetChooser(block_duration_secs=None, shrink_interval_secs=None, ipv4_netmask_prefix_length=None, ipv6_netmask_prefix_length=None, /)

Bases: Chooser

子网选择器

包含子网黑名单，一旦被反馈 API 调用失败，则将所有相关子网内 IP 地址冻结一段时间

通过 SubnetChooser(block_duration_secs = None, shrink_interval_secs = None, ipv4_netmask_prefix_length = None, ipv6_netmask_prefix_length = None) 创建子网选择器

class qiniu_bindings.http_client.TimeoutResolver(resolver, timeout)

Bases: Resolver

超时域名解析器

为一个域名解析器实例提供超时功能

通过 SimpleResolver(resolver) 创建超时域名解析器

class qiniu_bindings.http_client.TrustDnsResolver

Bases: Resolver

Trust-DNS 域名解析器

通过 TrustDnsResolver() 创建 Trust-DNS 域名解析器

class qiniu_bindings.apis.storage.async_fetch_object.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

从指定 URL 抓取资源，并将该资源存储到指定空间中。每次只抓取一个文件，抓取时可以指定保存空间名和最终资源名

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, json=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, json=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.batch_ops.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

批量操作意指在单一请求中执行多次（最大限制1000次） 查询元信息、修改元信息、移动、复制、删除、修改状态、修改存储类型、修改生命周期和解冻操作，极大提高对象管理效率。其中，解冻操作仅针对归档存储文件有效

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, form=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, form=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.copy_object.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

将源空间的指定对象复制到目标空间

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, src_entry=None, dest_entry=None, is_force=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, src_entry=None, dest_entry=None, is_force=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.create_bucket.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

创建一个新的存储空间

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, bucket=None, region=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, bucket=None, region=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.delete_bucket.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

删除指定的存储空间

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, bucket=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, bucket=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.delete_bucket_taggings.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

一键删除指定存储空间的所有标签

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.delete_object.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

删除指定对象

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, entry=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, entry=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.fetch_object.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

从指定 URL 抓取指定名称的对象并存储到该空间中

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, from_url=None, to_entry=None, host=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, from_url=None, to_entry=None, host=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.get_async_fetch_task.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

查询异步抓取任务

async_call(use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.get_bucket_taggings.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

查询指定的存储空间已设置的标签信息

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.get_buckets.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

获取拥有的所有存储空间列表

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.get_domains.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

获取存储空间的域名列表

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.get_objects.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

列举指定存储空间里的所有对象条目

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.get_objects_v2.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

列举指定存储空间里的所有对象条目

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.modify_object_life_cycle.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

修改已上传对象的生命周期

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, entry=None, to_ia_after_days=None, to_archive_after_days=None, to_deep_archive_after_days=None, delete_after_days=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, entry=None, to_ia_after_days=None, to_archive_after_days=None, to_deep_archive_after_days=None, delete_after_days=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.modify_object_metadata.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

修改文件元信息

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, entry=None, mime_type=None, condition=None, meta_data=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, entry=None, mime_type=None, condition=None, meta_data=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.modify_object_status.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

修改文件的存储状态，即禁用状态和启用状态间的的互相转换

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, entry=None, status=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, entry=None, status=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.move_object.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

将源空间的指定对象移动到目标空间，或在同一空间内对对象重命名

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, src_entry=None, dest_entry=None, is_force=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, src_entry=None, dest_entry=None, is_force=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.prefetch_object.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

对于设置了镜像存储的空间，从镜像源站抓取指定名称的对象并存储到该空间中，如果该空间中已存在该名称的对象，则会将镜像源站的对象覆盖空间中相同名称的对象

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, entry=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, entry=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.put_object.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

在一次 HTTP 会话中上传单一的一个文件

async_call(use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, multipart=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, multipart=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.restore_archived_object.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

解冻归档存储类型的文件，可设置解冻有效期1～7天，完成解冻任务通常需要1～5分钟

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, entry=None, freeze_after_days=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, entry=None, freeze_after_days=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.resumable_upload_v1_bput.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

上传指定块的一片数据，具体数据量可根据现场环境调整，同一块的每片数据必须串行上传

async_call(upload_token, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, ctx=None, chunk_offset=None, bytes=None, body=None, body_len=None, content_type=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(upload_token, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, ctx=None, chunk_offset=None, bytes=None, body=None, body_len=None, content_type=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.resumable_upload_v1_make_block.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

为后续分片上传创建一个新的块，同时上传第一片数据

async_call(upload_token, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, block_size=None, bytes=None, body=None, body_len=None, content_type=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(upload_token, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, block_size=None, bytes=None, body=None, body_len=None, content_type=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.resumable_upload_v1_make_file.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

将上传好的所有数据块按指定顺序合并成一个资源文件

async_call(upload_token, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, size=None, object_name=None, file_name=None, mime_type=None, custom_data=None, bytes=None, body=None, body_len=None, content_type=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(upload_token, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, size=None, object_name=None, file_name=None, mime_type=None, custom_data=None, bytes=None, body=None, body_len=None, content_type=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.resumable_upload_v2_abort_multipart_upload.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

根据 UploadId 终止 Multipart Upload

async_call(upload_token, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, bucket_name=None, object_name=None, upload_id=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(upload_token, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, bucket_name=None, object_name=None, upload_id=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.resumable_upload_v2_complete_multipart_upload.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

在将所有数据分片都上传完成后，必须调用 completeMultipartUpload API 来完成整个文件的 Multipart Upload。用户需要提供有效数据的分片列表（包括 PartNumber 和调用 uploadPart API 服务端返回的 Etag）。服务端收到用户提交的分片列表后，会逐一验证每个数据分片的有效性。当所有的数据分片验证通过后，会把这些数据分片组合成一个完整的对象

async_call(upload_token, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, bucket_name=None, object_name=None, upload_id=None, json=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(upload_token, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, bucket_name=None, object_name=None, upload_id=None, json=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.resumable_upload_v2_initiate_multipart_upload.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

使用 Multipart Upload 方式上传数据前，必须先调用 API 来获取一个全局唯一的 UploadId，后续的块数据通过 uploadPart API 上传，整个文件完成 completeMultipartUpload API，已经上传块的删除 abortMultipartUpload API 都依赖该 UploadId

async_call(upload_token, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, bucket_name=None, object_name=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(upload_token, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, bucket_name=None, object_name=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.resumable_upload_v2_list_parts.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

列举出指定 UploadId 所属任务所有已经上传成功的分片

async_call(upload_token, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, bucket_name=None, object_name=None, upload_id=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(upload_token, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, bucket_name=None, object_name=None, upload_id=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.resumable_upload_v2_upload_part.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

初始化一个 Multipart Upload 任务之后，可以根据指定的对象名称和 UploadId 来分片上传数据

async_call(upload_token, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, bucket_name=None, object_name=None, upload_id=None, part_number=None, bytes=None, body=None, body_len=None, content_type=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(upload_token, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, bucket_name=None, object_name=None, upload_id=None, part_number=None, bytes=None, body=None, body_len=None, content_type=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.set_bucket_private.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

设置存储空间的访问权限

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, form=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, form=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.set_bucket_taggings.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

设置存储空间的标签列表，包括新增和修改

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, json=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, json=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.set_buckets_mirror.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

设置存储空间的镜像源

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, bucket=None, src_site_url=None, host=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, bucket=None, src_site_url=None, host=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.set_object_file_type.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

修改文件的存储类型信息，可以实现标准存储、低频存储和归档存储之间的互相转换

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, entry=None, type=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, entry=None, type=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.apis.storage.stat_object.Client(http_caller=None, use_https=None, appended_user_agent=None, request_retrier=None, backoff=None, chooser=None, resolver=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None, /)

Bases: HttpClient

仅获取对象的元信息，不返回对象的内容

async_call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, entry=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出异步请求

call(credential, /, use_https=None, version=None, headers=None, query=None, query_pairs=None, appended_user_agent=None, entry=None, uploading_progress=None, receive_response_status=None, receive_response_header=None, to_resolve_domain=None, domain_resolved=None, to_choose_ips=None, ips_chosen=None, before_request_signed=None, after_request_signed=None, response_ok=None, response_error=None, before_backoff=None, after_backoff=None)

发出阻塞请求

class qiniu_bindings.objects.AsyncBatchOperationsIterator

Bases: object

异步批量操作结果迭代器

class qiniu_bindings.objects.AsyncObjectsIterator

Bases: object

异步列举操作迭代器

marker()

获取上一次列举返回的位置标记

class qiniu_bindings.objects.BatchOperations

Bases: object

批量操作

通过 bucket.batch_ops() 创建批量操作

class qiniu_bindings.objects.BatchOperationsIterator

Bases: object

批量操作结果迭代器

class qiniu_bindings.objects.BatchSizeProvider

Bases: object

最大批量操作数获取接口

抽象类

通过 BatchSizeProvider(size) 创建固定的最大批量操作数

batch_size

获取最大批量操作数

class qiniu_bindings.objects.Bucket

Bases: object

七牛存储空间管理器

由 objects_manager.bucket() 方法创建

batch_ops(operations, batch_size=None, before_request_callback=None, after_response_ok_callback=None, after_response_error_callback=None)

对空间内多个对象发起批量操作

copy_object_to(from_object, to_bucket, to_object, /, force=None, before_request_callback=None)

复制对象

delete_object(object, /, before_request_callback=None)

删除对象

list(limit=None, prefix=None, marker=None, version=None, need_parts=None, before_request_callback=None, after_response_ok_callback=None, after_response_error_callback=None)

列举对象

modify_object_life_cycle(object, mime_type, /, ia_after_days=None, archive_after_days=None, deep_archive_after_days=None, delete_after_days=None, before_request_callback=None)

设置对象生命周期

modify_object_metadata(object, mime_type, /, metadata=None, conditions=None, before_request_callback=None)

设置对象状态

modify_object_status(object, disabled, /, before_request_callback=None)

设置对象状态

move_object_to(from_object, to_bucket, to_object, /, force=None, before_request_callback=None)

移动对象

name

获取存储空间名称

restore_archived_object(object, freeze_after_days, /, before_request_callback=None)

解冻对象

set_object_type(object, object_type, /, before_request_callback=None)

设置对象类型

stat_object(object, /, before_request_callback=None)

获取对象元信息

class qiniu_bindings.objects.CopyObject

Bases: OperationProvider

对象复制操作构建器

可以通过 bucket.copy_object_to() 方法获取该构建器。

async_call()

异步发起对象复制请求

call()

阻塞发起对象复制请求

class qiniu_bindings.objects.DeleteObject

Bases: OperationProvider

对象删除操作构建器

可以通过 bucket.delete_object() 方法获取该构建器。

async_call()

异步发起对象删除请求

call()

阻塞发起对象删除请求

class qiniu_bindings.objects.FixedBatchSizeProvider(usize)

Bases: BatchSizeProvider

固定的最大批量操作数

通过 FixedBatchSizeProvider(size) 创建固定的最大批量操作数

class qiniu_bindings.objects.ListVersion

Bases: object

列举 API 版本

目前支持 V1 和 V2，默认为 V2

class qiniu_bindings.objects.ModifyObjectLifeCycle

Bases: OperationProvider

修改对象生命周期构建器

可以通过 bucket.modify_object_life_cycle() 方法获取该构建器。

async_call()

异步发起修改对象生命周期请求

call()

阻塞发起修改对象生命周期请求

class qiniu_bindings.objects.ModifyObjectMetadata

Bases: OperationProvider

修改对象元信息构建器

可以通过 bucket.modify_object_metadata() 方法获取该构建器。

async_call()

异步发起修改对象元信息请求

call()

阻塞发起修改对象元信息请求

class qiniu_bindings.objects.ModifyObjectStatus

Bases: OperationProvider

修改对象状态构建器

可以通过 bucket.modify_object_status() 方法获取该构建器。

async_call()

异步发起修改对象状态请求

call()

阻塞发起修改对象状态请求

class qiniu_bindings.objects.MoveObject

Bases: OperationProvider

对象移动操作构建器

可以通过 bucket.move_object_to() 方法获取该构建器。

async_call()

异步发起对象移动请求

call()

阻塞发起对象移动请求

class qiniu_bindings.objects.ObjectsIterator

Bases: object

列举操作迭代器

marker

获取上一次列举返回的位置标记

class qiniu_bindings.objects.ObjectsLister

Bases: object

列举操作迭代器

可以通过 bucket.list() 方法获取该迭代器。

class qiniu_bindings.objects.ObjectsManager(credential, /, use_https=None, http_client=None, uc_endpoints=None, queryer=None)

Bases: object

七牛对象管理器

通过 ObjectsManager(credential, use_https = None, http_client = None, uc_endpoints = None, queryer = None) 创建七牛对象管理器

bucket(name, /, regions=None)

获取七牛存储空间管理器

class qiniu_bindings.objects.OperationProvider

Bases: object

对象操作提供者接口

抽象类

class qiniu_bindings.objects.SetObjectType

Bases: OperationProvider

对象类型设置操作构建器

可以通过 bucket.set_object_type() 方法获取该构建器。

async_call()

异步发起对象类型设置请求

call()

阻塞发起对象类型设置请求

class qiniu_bindings.objects.StatObject

Bases: OperationProvider

对象元信息获取操作构建器

可以通过 bucket.stat_object() 方法获取该构建器。

async_call()

异步发起对象元信息获取请求

call()

阻塞发起对象元信息获取请求

class qiniu_bindings.objects.UnfreezeObject

Bases: OperationProvider

对象解冻操作构建器

可以通过 bucket.restore_archived_object() 方法获取该构建器。

async_call()

异步发起对象解冻请求

call()

阻塞发起对象解冻请求

class qiniu_bindings.upload.AlwaysMultiParts

Bases: ResumablePolicyProvider

总是选择分片上传

通过 AlwaysMultiParts() 创建分片上传策略

class qiniu_bindings.upload.AlwaysSinglePart

Bases: ResumablePolicyProvider

总是选择单请求上传

通过 AlwaysSinglePart() 创建单请求上传策略

class qiniu_bindings.upload.AppendOnlyAsyncResumableRecorderMedium

Bases: object

异步追加介质接口

抽象类

flush()

异步刷新数据

write(b, /)

异步写入所有数据

class qiniu_bindings.upload.AppendOnlyResumableRecorderMedium

Bases: object

追加介质接口

抽象类

flush()

刷新数据

write(b, /)

写入所有数据

class qiniu_bindings.upload.AsyncDataSource

Bases: object

异步数据源接口

抽象类

提供上传所用的数据源

slice(size)

异步数据源切片

source_key()

异步获取数据源 KEY

用于区分不同的数据源

total_size()

异步获取数据源大小

class qiniu_bindings.upload.AsyncDataSourceReader

Bases: object

异步只读介质接口

抽象类

read(size=- 1, /)

异步读取响应体数据

readall()

异步所有读取响应体数据

reset()

从头读取数据

class qiniu_bindings.upload.AsyncFileDataSource(path)

Bases: AsyncDataSource

异步文件数据源

基于一个文件实现了数据源接口

通过 AsyncFileDataSource(path) 创建异步文件数据源

class qiniu_bindings.upload.AsyncMultiPartsV1UploaderInitializedObject

Bases: object

被 分片上传器 V1 异步初始化的分片信息

通过 multi_parts_uploader_v1.async_initialize_parts() 创建

content_type

获取 MIME 类型

custom_vars

获取对象自定义变量

file_name

获取文件名称

metadata

获取对象元信息

object_name

获取对象名称

class qiniu_bindings.upload.AsyncMultiPartsV1UploaderUploadedPart

Bases: object

已经通过 分片上传器 V1 异步上传的分片信息

通过 multi_parts_uploader_v1.async_upload_part() 创建

offset

分片偏移量

response_body

获取响应体

resumed

是否来自于断点恢复

size

分片大小

class qiniu_bindings.upload.AsyncMultiPartsV2UploaderInitializedObject

Bases: object

被 分片上传器 V2 异步初始化的分片信息

通过 multi_parts_uploader_v2.async_initialize_parts() 创建

content_type

获取 MIME 类型

custom_vars

获取对象自定义变量

file_name

获取文件名称

metadata

获取对象元信息

object_name

获取对象名称

class qiniu_bindings.upload.AsyncMultiPartsV2UploaderUploadedPart

Bases: object

已经通过 分片上传器 V2 异步上传的分片信息

通过 multi_parts_uploader_v2.async_upload_part() 创建

offset

分片偏移量

response_body

获取响应体

resumed

是否来自于断点恢复

size

分片大小

class qiniu_bindings.upload.AsyncReader

Bases: object

异步数据阅读器

通过 resumable_policy_provider.get_policy_from_async_reader() 创建

read(size=- 1, /)

异步读取数据

readall()

异步所有读取数据

class qiniu_bindings.upload.AsyncUnseekableDataSource(source)

Bases: AsyncDataSource

不可寻址的异步数据源

基于一个不可寻址的异步阅读器实现了异步数据源接口

通过 AsyncUnseekableDataSource(source) 创建不可寻址的异步数据源

class qiniu_bindings.upload.AutoUploader

Bases: object

自动上传器

使用设置的各种提供者，将文件或是二进制流数据上传。

通过 upload_manager.auto_uploader() 创建自动上传器

class qiniu_bindings.upload.ConcurrencyProvider

Bases: object

并发数获取接口

抽象类

获取分片上传时的并发数

concurrency

获取并发数

feedback(object_size, elapsed_ns, /, error=None)

反馈并发数结果

class qiniu_bindings.upload.ConcurrentMultiPartsUploaderScheduler(uploader)

Bases: MultiPartsUploaderScheduler

并行分片上传调度器

在阻塞模式下创建线程池负责上传分片，在异步模式下使用 async-std 的线程池负责上传分片。

通过 ConcurrentMultiPartsUploaderScheduler(multi_parts_uploader) 创建串行分片上传调度器

class qiniu_bindings.upload.DataPartitionProvider

Bases: object

分片大小获取接口

抽象类

feedback(elapsed_ns, /, error=None)

反馈并发数结果

part_size

获取分片大小

class qiniu_bindings.upload.DataSource

Bases: object

数据源接口

抽象类

提供上传所用的数据源

slice(size)

数据源切片

source_key()

获取数据源 KEY

用于区分不同的数据源

total_size()

获取数据源大小

class qiniu_bindings.upload.DataSourceReader

Bases: object

追加介质接口

抽象类

read(size=- 1, /)

读取响应体数据

readall()

读取所有响应体数据

reset()

从头读取数据

class qiniu_bindings.upload.DummyResumableRecorder

Bases: ResumableRecorder

无断点恢复记录器

实现了断点恢复记录器接口，但总是返回找不到记录

通过 DummyResumableRecorder() 创建无断点恢复记录器

class qiniu_bindings.upload.FileDataSource(path)

Bases: DataSource

文件数据源

基于一个文件实现了数据源接口

通过 FileDataSource(path) 创建文件数据源

class qiniu_bindings.upload.FileSystemResumableRecorder(path=None, /)

Bases: ResumableRecorder

文件系统断点恢复记录器

基于文件系统提供断点恢复记录功能

通过 FileSystemResumableRecorder(path = None) 创建文件系统断点恢复记录器

class qiniu_bindings.upload.FixedConcurrencyProvider(concurrency)

Bases: ConcurrencyProvider

固定并发数提供者

通过 FixedConcurrencyProvider(concurrency) 创建固定并发数提供者

class qiniu_bindings.upload.FixedDataPartitionProvider(part_size)

Bases: DataPartitionProvider

固定分片大小提供者

通过 FixedDataPartitionProvider(part_size) 创建固定分片大小提供者

class qiniu_bindings.upload.FixedThresholdResumablePolicy(threshold)

Bases: ResumablePolicyProvider

固定阀值的可恢复策略

通过 FixedThresholdResumablePolicy(threshold) 创建固定阀值的可恢复策略

class qiniu_bindings.upload.FormUploader

Bases: object

表单上传器

通过七牛表单上传 API 一次上传整个数据流

通过 upload_manager.form_uploader() 创建表单上传器

class qiniu_bindings.upload.LimitedDataPartitionProvider(base, min, max)

Bases: DataPartitionProvider

受限的分片大小提供者

基于一个分片大小提供者实例，如果提供的分片大小在限制范围外，则调整到限制范围内。

通过 LimitedDataPartitionProvider(base, min, max) 创建受限的分片大小提供者

class qiniu_bindings.upload.MultiPartsUploaderPrefer

Bases: object

期望的对象分片上传器

class qiniu_bindings.upload.MultiPartsUploaderScheduler

Bases: object

分片上传调度器接口

抽象类

负责分片上传的调度，包括初始化分片信息、上传分片、完成分片上传。

async_upload(source, /, region_provider=None, object_name=None, file_name=None, content_type=None, metadata=None, custom_vars=None)

异步上传数据源

concurrency_provider

设置并发数提供者

data_partition_provider

设置分片大小提供者

upload(source, /, region_provider=None, object_name=None, file_name=None, content_type=None, metadata=None, custom_vars=None)

上传数据源

class qiniu_bindings.upload.MultiPartsUploaderSchedulerPrefer

Bases: object

期望的分片上传调度器

class qiniu_bindings.upload.MultiPartsV1Uploader

Bases: object

分片上传器 V1

不推荐直接使用这个上传器，而是可以借助 MultiPartsUploaderScheduler 来方便地实现分片上传。

通过 upload_manager.multi_parts_v1_uploader() 创建分片上传器 V1

async_complete_part(initialized, parts)

异步完成分片上传

在这步成功返回后，对象即可被读取。

async_initialize_parts(source, /, region_provider=None, object_name=None, file_name=None, content_type=None, metadata=None, custom_vars=None)

异步初始化分片信息

该步骤只负责初始化分片，但不实际上传数据，如果提供了有效的断点续传记录器，则可以尝试在这一步找到记录。

async_reinitialize_parts(initialized, /, keep_original_region=None, refresh_regions=None, regions_provider=None)

异步重新初始化分片信息

该步骤负责将先前已经初始化过的分片信息全部重置，清空断点续传记录器中的记录，之后从头上传整个文件

async_upload_part(initialized, data_partitioner_provider)

异步上传分片

实际上传的分片大小由提供的分片大小提供者获取。

如果返回 None 则表示已经没有更多分片可以上传。

complete_part(initialized, parts)

完成分片上传

在这步成功返回后，对象即可被读取。

initialize_parts(source, /, region_provider=None, object_name=None, file_name=None, content_type=None, metadata=None, custom_vars=None)

初始化分片信息

该步骤只负责初始化分片，但不实际上传数据，如果提供了有效的断点续传记录器，则可以尝试在这一步找到记录。

reinitialize_parts(initialized, /, keep_original_region=None, refresh_regions=None, regions_provider=None)

重新初始化分片信息

该步骤负责将先前已经初始化过的分片信息全部重置，清空断点续传记录器中的记录，之后从头上传整个文件

upload_part(initialized, data_partitioner_provider)

上传分片

实际上传的分片大小由提供的分片大小提供者获取。

如果返回 None 则表示已经没有更多分片可以上传。

class qiniu_bindings.upload.MultiPartsV1UploaderInitializedObject

Bases: object

被 分片上传器 V1 初始化的分片信息

通过 multi_parts_uploader_v1.initialize_parts() 创建

content_type

获取 MIME 类型

custom_vars

获取对象自定义变量

file_name

获取文件名称

metadata

获取对象元信息

object_name

获取对象名称

class qiniu_bindings.upload.MultiPartsV1UploaderUploadedPart

Bases: object

已经通过 分片上传器 V1 上传的分片信息

通过 multi_parts_uploader_v1.upload_part() 创建

offset

分片偏移量

response_body

获取响应体

resumed

是否来自于断点恢复

size

分片大小

class qiniu_bindings.upload.MultiPartsV2Uploader

Bases: object

分片上传器 V2

不推荐直接使用这个上传器，而是可以借助 MultiPartsUploaderScheduler 来方便地实现分片上传。

通过 upload_manager.multi_parts_v2_uploader() 创建分片上传器 V2

async_complete_part(initialized, parts)

异步完成分片上传

在这步成功返回后，对象即可被读取。

async_initialize_parts(source, /, region_provider=None, object_name=None, file_name=None, content_type=None, metadata=None, custom_vars=None)

异步初始化分片信息

该步骤只负责初始化分片，但不实际上传数据，如果提供了有效的断点续传记录器，则可以尝试在这一步找到记录。

async_reinitialize_parts(initialized, /, keep_original_region=None, refresh_regions=None, regions_provider=None)

异步重新初始化分片信息

该步骤负责将先前已经初始化过的分片信息全部重置，清空断点续传记录器中的记录，之后从头上传整个文件

async_upload_part(initialized, data_partitioner_provider)

异步上传分片

实际上传的分片大小由提供的分片大小提供者获取。

如果返回 None 则表示已经没有更多分片可以上传。

complete_part(initialized, parts)

完成分片上传

在这步成功返回后，对象即可被读取。

initialize_parts(source, /, region_provider=None, object_name=None, file_name=None, content_type=None, metadata=None, custom_vars=None)

初始化分片信息

该步骤只负责初始化分片，但不实际上传数据，如果提供了有效的断点续传记录器，则可以尝试在这一步找到记录。

reinitialize_parts(initialized, /, keep_original_region=None, refresh_regions=None, regions_provider=None)

重新初始化分片信息

该步骤负责将先前已经初始化过的分片信息全部重置，清空断点续传记录器中的记录，之后从头上传整个文件

upload_part(initialized, data_partitioner_provider)

上传分片

实际上传的分片大小由提供的分片大小提供者获取。

如果返回 None 则表示已经没有更多分片可以上传。

class qiniu_bindings.upload.MultiPartsV2UploaderInitializedObject

Bases: object

被 分片上传器 V2 初始化的分片信息

通过 multi_parts_uploader_v2.initialize_parts() 创建

content_type

获取 MIME 类型

custom_vars

获取对象自定义变量

file_name

获取文件名称

metadata

获取对象元信息

object_name

获取对象名称

class qiniu_bindings.upload.MultiPartsV2UploaderUploadedPart

Bases: object

已经通过 分片上传器 V2 上传的分片信息

通过 multi_parts_uploader_v2.upload_part() 创建

offset

分片偏移量

response_body

获取响应体

resumed

是否来自于断点恢复

size

分片大小

class qiniu_bindings.upload.MultiplePartitionsResumablePolicyProvider(base, multiply)

Bases: ResumablePolicyProvider

整数倍分片大小的可恢复策略

在数据源大小超过分片大小提供者返回的分片大小的整数倍时，将使用分片上传。

通过 MultiplePartitionsResumablePolicyProvider(base, multiply) 创建整数倍分片大小的可恢复策略

class qiniu_bindings.upload.MultiplyDataPartitionProvider(base, multiply)

Bases: DataPartitionProvider

整数倍分片大小提供者

基于一个分片大小提供者实例，如果提供的分片大小不是指定倍数的整数倍，则下调到它的整数倍

通过 MultiplyDataPartitionProvider(base, multiply) 创建整数倍分片大小提供者

class qiniu_bindings.upload.ReadOnlyAsyncResumableRecorderMedium

Bases: object

异步只读介质接口

抽象类

read(size=- 1, /)

异步读取响应体数据

readall()

异步所有读取响应体数据

class qiniu_bindings.upload.ReadOnlyResumableRecorderMedium

Bases: object

只读介质接口

抽象类

read(size=- 1, /)

读取响应体数据

readall()

读取所有响应体数据

class qiniu_bindings.upload.Reader

Bases: object

数据阅读器

通过 resumable_policy_provider.get_policy_from_reader() 创建

read(size=- 1, /)

读取数据

readall()

读取所有数据

class qiniu_bindings.upload.ResumablePolicy

Bases: object

可恢复策略

选择使用单请求上传或分片上传

class qiniu_bindings.upload.ResumablePolicyProvider

Bases: object

可恢复策略获取接口

抽象类

get_policy_from_async_reader()

通过异步输入流获取可恢复策略

返回选择的可恢复策略，以及经过更新的异步输入流

get_policy_from_reader()

通过输入流获取可恢复策略

返回选择的可恢复策略，以及经过更新的输入流

get_policy_from_size()

通过数据源大小获取可恢复策略

class qiniu_bindings.upload.ResumableRecorder

Bases: object

断点恢复记录器

抽象类

async_delete(source_key)

根据数据源 KEY 异步删除记录介质

delete(source_key)

根据数据源 KEY 删除记录介质

open_for_append(source_key)

根据数据源 KEY 打开追加记录介质

open_for_async_append(source_key)

根据数据源 KEY 打开异步追加记录介质

open_for_async_create_new(source_key)

根据数据源 KEY 创建异步追加记录介质

open_for_async_read(source_key)

根据数据源 KEY 打开异步只读记录介质

open_for_create_new(source_key)

根据数据源 KEY 创建追加记录介质

open_for_read(source_key)

根据数据源 KEY 打开只读记录介质

class qiniu_bindings.upload.SerialMultiPartsUploaderScheduler(uploader)

Bases: MultiPartsUploaderScheduler

串行分片上传调度器

不启动任何线程，仅在本地串行上传分片。

通过 SerialMultiPartsUploaderScheduler(multi_parts_uploader) 创建串行分片上传调度器

class qiniu_bindings.upload.SinglePartUploaderPrefer

Bases: object

期望的对象单请求上传器

class qiniu_bindings.upload.SourceKey

Bases: object

数据源 KEY

用于区分不同的数据源

通过 SourceKey(key) 创建数据源 KEY

class qiniu_bindings.upload.UnseekableDataSource(source)

Bases: DataSource

不可寻址的数据源

基于一个不可寻址的阅读器实现了数据源接口

通过 UnseekableDataSource(source) 创建不可寻址的数据源

class qiniu_bindings.upload.UploadManager(signer, /, http_client=None, use_https=None, queryer=None, uc_endpoints=None)

Bases: object

上传管理器

通过 UploadManager(signer, http_client = None, use_https = None, queryer = None, uc_endpoints = None) 创建上传管理器

auto_uploader(concurrency_provider=None, data_partition_provider=None, resumable_recorder=None, resumable_policy_provider=None, before_request=None, upload_progress=None, response_ok=None, response_error=None, part_uploaded=None)

创建自动上传器

form_uploader(before_request=None, upload_progress=None, response_ok=None, response_error=None)

创建表单上传器

multi_parts_v1_uploader(resumable_recorder, /, before_request=None, upload_progress=None, response_ok=None, response_error=None, part_uploaded=None)

创建分片上传器 V1

multi_parts_v2_uploader(resumable_recorder, /, before_request=None, upload_progress=None, response_ok=None, response_error=None, part_uploaded=None)

创建分片上传器 V2

class qiniu_bindings.upload.UploadTokenSigner

Bases: object

上传凭证签发器

通过 UploadTokenSigner.new_upload_token_provider(upload_token_provider) 或 UploadTokenSigner.new_credential_provider(credential, bucket_name, lifetime_secs, on_policy_generated = None) 创建上传凭证签发器

static new_credential_provider(credential, bucket_name, lifetime_secs, /, on_policy_generated=None)

根据认证信息提供者和存储空间名称创建上传凭证签发器

static new_upload_token_provider(upload_token_provider)

根据上传凭证提供者创建上传凭证签发器

class qiniu_bindings.upload.UploadedPartInfo

Bases: object

已经上传的分片信息

该类型没有构造函数，仅限于在回调函数中使用

class qiniu_bindings.upload.UploadingProgressInfo(transferred_bytes, /, total_bytes=None)

Bases: object

上传进度信息

通过 UploadingProgressInfo(transferred_bytes, total_bytes = None) 创建上传进度信息

total_bytes

获取总共需要传输的数据量

单位为字节

transferred_bytes

获取已经传输的数据量

单位为字节

class qiniu_bindings.download.AsyncDownloadingObjectReader

Bases: object

异步下载阅读器

通过 download_manager.async_reader() 创建下载阅读器

read(size=- 1, /)

异步读取下载的数据

readall()

异步所有读取下载的数据

class qiniu_bindings.download.DownloadManager(urls_generator, /, use_https=None, http_client=None)

Bases: object

下载管理器

通过 DownloadManager(urls_generator, use_https = None, http_client = None) 创建下载管理器

async_download_to_path(object_name, to_path, /, range_from=None, range_to=None, retrier=None, headers=None, before_request=None, download_progress=None, response_ok=None, response_error=None)

将下载的对象内容异步写入指定的文件系统路径

需要注意，如果文件已经存在，则会覆盖该文件，如果文件不存在，则会创建该文件。

async_reader(object_name, /, range_from=None, range_to=None, retrier=None, headers=None, before_request=None, download_progress=None, response_ok=None, response_error=None)

异步获取下载内容阅读器

download_to_async_writer(object_name, to_object, /, range_from=None, range_to=None, retrier=None, headers=None, before_request=None, download_progress=None, response_ok=None, response_error=None)

将下载的对象内容写入指定的输出流

download_to_path(object_name, to_path, /, range_from=None, range_to=None, retrier=None, headers=None, before_request=None, download_progress=None, response_ok=None, response_error=None)

将下载的对象内容写入指定的文件系统路径

需要注意，如果文件已经存在，则会覆盖该文件，如果文件不存在，则会创建该文件。

download_to_writer(object_name, to_object, /, range_from=None, range_to=None, retrier=None, headers=None, before_request=None, download_progress=None, response_ok=None, response_error=None)

将下载的对象内容写入指定的输出流

reader(object_name, /, range_from=None, range_to=None, retrier=None, headers=None, before_request=None, download_progress=None, response_ok=None, response_error=None)

获取下载内容阅读器

class qiniu_bindings.download.DownloadRetrier

Bases: object

下载重试器

抽象类

根据 HTTP 客户端返回的错误，决定是否重试请求，重试决定由 RetryDecision 定义。

class qiniu_bindings.download.DownloadUrlsGenerator

Bases: object

生成下载 URL 列表的接口

抽象类

同时提供阻塞接口和异步接口

async_generate(object_name, /, ttl_secs=None)

异步生成下载 URL 列表

generate(object_name, /, ttl_secs=None)

生成下载 URL 列表

class qiniu_bindings.download.DownloadingObjectReader

Bases: object

下载阅读器

通过 download_manager.read() 创建下载阅读器

read(size=- 1, /)

读取下载的数据

readall()

读取所有下载的数据

class qiniu_bindings.download.DownloadingProgressInfo(transferred_bytes, /, total_bytes=None)

Bases: object

下载传度信息

通过 DownloadingProgressInfo(transferred_bytes, total_bytes) 创建下载传度信息

total_bytes

获取总共需要传输的数据量

单位为字节

transferred_bytes

获取已经传输的数据量

单位为字节

class qiniu_bindings.download.EndpointsUrlGenerator(endpoints, /, use_https=None)

Bases: DownloadUrlsGenerator

终端地址下载 URL 列表生成器

通过 EndpointsUrlGenerator(endpoints, use_https=None) 创建终端地址下载 URL 列表生成器

class qiniu_bindings.download.ErrorRetrier

Bases: DownloadRetrier

根据七牛 API 返回的状态码作出重试决定

通过 ErrorRetrier() 创建错误重试器

class qiniu_bindings.download.NeverRetrier

Bases: DownloadRetrier

永不重试器

总是返回不再重试的重试器

通过 NeverRetrier() 创建永不重试器

class qiniu_bindings.download.RetriedStatsInfo

Bases: object

重试统计信息

通过 RetriedStatsInfo() 创建重试统计信息

abandoned_endpoints

获取放弃的终端地址的数量

increase()

提升当前终端地址的重试次数

retried_on_current_endpoint

获取当前终端地址的重试次数

retried_total

获取总共重试的次数

switch_endpoint()

切换终端地址

class qiniu_bindings.download.RetryDecision

Bases: object

重试决定

class qiniu_bindings.download.StaticDomainsUrlsGenerator(endpoints, /, use_https=None)

Bases: DownloadUrlsGenerator

静态公开空间域名下载 URL 列表生成器

通过 StaticDomainsUrlsGenerator(endpoints, use_https=None) 创建静态公开空间域名下载 URL 列表生成器

class qiniu_bindings.download.UrlsSigner(credential, generator)

Bases: DownloadUrlsGenerator

URL 列表签名器

通过 UrlsSigner(credential, generator) 创建 URL 列表签名器

exception qiniu_bindings.QiniuApiCallError

Bases: OSError

七牛 API 调用错误

class qiniu_bindings.QiniuApiCallErrorKind

Bases: object

七牛 API 响应错误类型

exception qiniu_bindings.QiniuAuthorizationError

Bases: OSError

七牛签名异常

exception qiniu_bindings.QiniuBase64Error

Bases: ValueError

七牛 Base64 解析错误

exception qiniu_bindings.QiniuBodySizeMissingError

Bases: TypeError

七牛缺少 body_len 参数错误

exception qiniu_bindings.QiniuCallbackError

Bases: RuntimeError

七牛回调异常

exception qiniu_bindings.QiniuDownloadError

Bases: OSError

七牛下载错误

exception qiniu_bindings.QiniuEmptyChainCredentialsProvider

Bases: ValueError

七牛空 ChainCredentialsProvider 错误

exception qiniu_bindings.QiniuEmptyChainedResolver

Bases: ValueError

七牛空 ChainedResolver 错误

exception qiniu_bindings.QiniuEmptyEndpoints

Bases: ValueError

七牛空 Endpoints 错误

exception qiniu_bindings.QiniuEmptyRegionsProvider

Bases: ValueError

七牛空 StaticRegionsProvider 错误

exception qiniu_bindings.QiniuHeaderValueEncodingError

Bases: ValueError

七牛 HTTP 头编码错误

exception qiniu_bindings.QiniuHttpCallError

Bases: OSError

七牛 HTTP 调用错误

class qiniu_bindings.QiniuHttpCallErrorKind

Bases: object

HTTP 响应错误类型

exception qiniu_bindings.QiniuInvalidConcurrency

Bases: ValueError

七牛并行数错误

exception qiniu_bindings.QiniuInvalidDomainWithPortError

Bases: ValueError

七牛非法域名错误

exception qiniu_bindings.QiniuInvalidEndpointError

Bases: ValueError

七牛非法终端地址错误

exception qiniu_bindings.QiniuInvalidHeaderNameError

Bases: ValueError

七牛非法 HTTP 头名称错误

exception qiniu_bindings.QiniuInvalidHeaderValueError

Bases: ValueError

七牛非法 HTTP 头值错误

exception qiniu_bindings.QiniuInvalidIpAddrError

Bases: ValueError

七牛非法 IP 地址错误

exception qiniu_bindings.QiniuInvalidIpAddrWithPortError

Bases: ValueError

七牛非法 IP 地址错误

exception qiniu_bindings.QiniuInvalidLimitation

Bases: ValueError

七牛分片限制错误

exception qiniu_bindings.QiniuInvalidMethodError

Bases: ValueError

七牛非法 HTTP 方法错误

exception qiniu_bindings.QiniuInvalidMultiply

Bases: ValueError

七牛分片大小错误

exception qiniu_bindings.QiniuInvalidObjectSize

Bases: ValueError

七牛对象大小错误

exception qiniu_bindings.QiniuInvalidPartSize

Bases: ValueError

七牛分片大小错误

exception qiniu_bindings.QiniuInvalidPortError

Bases: ValueError

七牛非法端口号错误

exception qiniu_bindings.QiniuInvalidPrefixLengthError

Bases: ValueError

七牛子网掩码前缀长度异常

exception qiniu_bindings.QiniuInvalidSourceKeyLengthError

Bases: ValueError

七牛数据源 KEY 长度错误

exception qiniu_bindings.QiniuInvalidStatusCodeError

Bases: ValueError

七牛非法 HTTP 状态码错误

exception qiniu_bindings.QiniuInvalidURLError

Bases: ValueError

七牛非法 URL 错误

exception qiniu_bindings.QiniuIoError

Bases: OSError

七牛本地 IO 错误

exception qiniu_bindings.QiniuIsahcError

Bases: RuntimeError

七牛 Isahc 异常

exception qiniu_bindings.QiniuJsonError

Bases: ValueError

七牛 JSON 错误

exception qiniu_bindings.QiniuMimeParseError

Bases: ValueError

七牛 MIME 解析错误

exception qiniu_bindings.QiniuTimeError

Bases: ValueError

七牛时间错误

exception qiniu_bindings.QiniuTrustDNSError

Bases: RuntimeError

七牛 Isahc 异常

exception qiniu_bindings.QiniuUnsupportedTypeError

Bases: ValueError

七牛不支持的类型错误

exception qiniu_bindings.QiniuUploadTokenFormatError

Bases: ValueError

七牛上传凭证格式错误

exception qiniu_bindings.QiniuUserAgentInitializeError

Bases: RuntimeError

七牛用户代理初始化异常