Python Auth.upload_token方法代码示例

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import upload_token [as 别名]
class Qiniu(object):
    def init_app(self, app):
        access_key = app.config.get('QINIU_ACCESS_KEY')
        secret_key = app.config.get('QINIU_SECRET_KEY')
        self.app = app
        self.bucket = app.config.get('QINIU_BUCKET')
        self.auth = Auth(access_key, secret_key)

    def upload_file(self, filename, filepath):
        """上传本地文件"""
        token = self.auth.upload_token(self.bucket, filename)
        ret, info = put_file(token, filename, filepath)

        if info.exception is not None:
            raise UploadError(info)

    def upload_data(self, filename, data):
        """上传二进制数据"""
        token = self.auth.upload_token(self.bucket, filename)
        ret, info = put_data(token, filename, data)

        if info.exception is not None:
            raise UploadError(info)

    def generate_token(self, filename=None, policy=None):
        """生成上传凭证"""
        return self.auth.upload_token(self.bucket, filename, policy=policy)

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import upload_token [as 别名]
class QiNiuProvider(object):
    def __init__(self, access_key, secret_key, bucket_name, imageServerUrl):
        self.access_key = access_key
        self.secret_key = secret_key
        self.bucket_name = bucket_name
        self.imageServerUrl = imageServerUrl
        self.credentials = Auth(self.access_key, self.secret_key)

    def token(self):
        return self.credentials.upload_token(self.bucket_name)

    def store(self, raw):
        key = hash(str(uuid.uuid1()))
        upload_token = self.credentials.upload_token(self.bucket_name, key)
        ret, err = put_data(upload_token, key, raw)
        if ret is not None:
            return "%s/%s" % (self.imageServerUrl, ret['key'])
        else:
            logging.error('upload error.')

    def store_file(self, file_path, file_name):
        upload_token = self.credentials.upload_token(self.bucket_name, file_name)
        ret, err = put_file(upload_token, file_name, file_path)
        if ret is not None:
            return "%s/%s" % (self.imageServerUrl, ret['key'])
        else:
            logging.error('upload: %s error.' % file_name)

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import upload_token [as 别名]
class QiNiu(object):

    def __init__(self):
        self.authed = Auth(AccessKey, SecretKey)

    def upload(self, data):
        """
        :param data:
                {
                    "filename":"",
                    "filepath":"",
                    "policy":{}
                }
        :return:
            ret
            info
        """

        filename = data["filename"]
        filepath = data["filepath"]
        policy   = data.get("policy", {})

        if policy:
            token = self.authed.upload_token(BucketName, filename, Expired, policy)
        else:
            token = self.authed.upload_token(BucketName, filename, Expired)

        ret, info = put_file(token, filename, filepath)

        return ret, info

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import upload_token [as 别名]
    def create(self):
        # TODO: 表单验证
        image = request.files['image']
        # TODO: 解包检查
        origin_name, suffix = image.raw_filename.split('.')

        data = image.file.read()
        data_hash = md5(data).hexdigest()
        key = data_hash

        model = ImageModel.query.get(data_hash)
        if model:
            return model.as_dict()

        auth = Auth(QINIU_ACCESS_KEY, QINIU_SECRET_KEY)
        token = auth.upload_token(
            QINIU_BUCKET_NAME, None, 7200,
            {
                'returnBody': json.dumps({
                    'key': '$(key)',
                    'hash': '$(etag)',
                    'format': '$(imageInfo.format)',
                    'width': '$(imageInfo.width)',
                    'height': '$(imageInfo.height)',
                }),
                'save_key': '$(etag)',
            }
        )
        ret, info = put_data(token, key, data)
        model = ImageModel(
            hashkey=data_hash, suffix=ret['format'],
            width=ret['width'], height=ret['height'])
        db.session.add(model)
        db.session.commit()
        return model.as_dict()

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import upload_token [as 别名]
class QiniuLPic(LPic):
    def __init__(self, conf=None, **option):
        super(QiniuLPic, self).__init__(conf, **option)
        self.cloud_name = '七牛云'

    def auth(self):
        self.client = Auth(self.cloud['AccessKey'], self.cloud['SecretKey'])

    @property
    def web_url(self):
        return 'https://portal.qiniu.com/bucket/{}/resource'.format(self.cloud['Bucket'])

    def upload(self, file, prefix=''):
        _token = self.client.upload_token(self.cloud['Bucket'], os.path.basename(file), 600)
        _, ret = put_file(_token, prefix + os.path.basename(file), file)
        return ret.ok()

    def list(self, prefix):
        bucket = BucketManager(self.client)
        ret, _, _ = bucket.list(self.cloud['Bucket'], prefix=prefix, limit=self.MAX_KEYS)
        return [i['key'] for i in sorted([i for i in ret['items']], key=lambda x: -x['putTime'])]

    def delete(self, key):
        bucket = BucketManager(self.client)
        _, ret = bucket.delete(self.cloud['Bucket'], key)
        return ret.ok()

    def close(self):
        cache = '.qiniu_pythonsdk_hostscache.json'
        if os.path.isfile(cache):
            os.remove(cache)

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import upload_token [as 别名]
def get_token(key):
    q = Auth(qiniu_access_key, qiniu_secret_key)

    # 上传策略仅指定空间名和上传后的文件名，其他参数仅为默认值
    token = q.upload_token(qiniu_bucket_name, key)

    return token

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import upload_token [as 别名]
def test_upload():
    q = Auth(access_key, secret_key)
    token = q.upload_token(bucket, mykey.encode('utf-8'))
    file = '/tmp/abc.txt'
    ret, info = put_file(token, mykey.encode('utf-8'), file, mime_type="text/plain", check_crc=True)
    print(info)
    print(ret)

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import upload_token [as 别名]
class Qiniu(BaseStorage):

    def __init__(self, bucket, access_key, secret_key, cdn_host, host=None, timeout=5):
        self.bucket = bucket
        self.access_key = access_key
        self.secret_key = secret_key
        self.host = host
        self.cdn_host = cdn_host
        self.timeout = timeout
        self.auth = Auth(self.access_key, self.secret_key)
        set_default(connection_timeout=self.timeout, connection_retries=0)

    @property
    def token(self):
        return self.auth.upload_token(self.bucket)

    def set(self, k, v, mimetype=None, **kwargs):
        ret, info = put_data(self.token, k, v, mime_type=mimetype)
        return bool(ret)

    def get(self, k):
        url = 'http://%s/%s' % (self.host, k)
        resp = requests.get(url, timeout=5)
        if resp.status_code == requests.codes.ok:
            return resp.content, resp.headers['content-type']
        return (None, None)

    def cdn_url(self, ident):
        return 'http://{}/{}'.format(self.cdn_host, ident)

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import upload_token [as 别名]
 def get(self, request):
     q = Auth(settings.QNACCESSKEY, settings.QNSECRETKEY)
     filename = str(uuid.uuid1()).replace("-", "") + ".jpg"
     print (filename)
     token = q.upload_token(settings.QNBUKET, filename)
     print (token)
     return Response({"key": filename, "token": token}, status=status.HTTP_202_ACCEPTED)

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import upload_token [as 别名]
def main():
	q = Auth('FCFQs6B-thjgt30-HEmCS9ZUCGQBxx2Zsg_WO1k5', 'Z8LCTm4gxo_dfX7HT0EhFnXmsFTGwZ8MyCFXmSXF')

	# 上传策略仅指定空间名和上传后的文件名，其他参数仅为默认值
	token = q.upload_token('qile')
	f = open('qiniu_auth_token.txt', 'w')
	f.write(str(token))

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import upload_token [as 别名]
def upload(origin_file_path):
    # 构建鉴权对象
    q = Auth(config.access_key, config.secret_key)

    # 要上传的空间
    bucket_name = 'md-doc'
    localfile = conwebp.convert(origin_file_path)

    # 上传到七牛后保存的文件名
    dest_prefix = time.strftime("%Y%m%d%H%M%S", time.localtime())
    dest_name = dest_prefix + "_" + os.path.basename(localfile)

    # 上传文件到七牛后， 七牛将文件名和文件大小回调给业务服务器。
    policy = {
        'callbackBody': 'filename=$(fname)&filesize=$(fsize)'
    }

    token = q.upload_token(bucket_name, dest_name, 3600, policy)

    ret, info = put_file(token, dest_name, localfile)
    if ret is not None:
        print("Upload Success,url=", config.domin + dest_name)
    else:
        print("info=", info)
        print("ret=", ret)
    assert ret['key'] == dest_name
    assert ret['hash'] == etag(localfile)

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import upload_token [as 别名]
def upload_to_qiniu(AK, SK, BUCKET_NAME,FILE_OBJ,FILE_NAME,):
    '''
    上传文件到七牛云，并返回 文件hash

    BUCKET_NAME 七牛资源空间名
    FILE_OBJ 文件二进制流
    FILE_NAME 文件保存到七牛云上的文件名
    '''
    q = Auth(AK, SK)
    token = q.upload_token(BUCKET_NAME, FILE_NAME, 3600)
    # ret
    # 一个dict变量，类似 {"hash": "<Hash string>", "key": "<Key string>"}
    # info
    """七牛HTTP请求返回信息类

    该类主要是用于获取和解析对七牛发起各种请求后的响应包的header和body。

    Attributes:
        status_code: 整数变量，响应状态码
        text_body:   字符串变量，响应的body
        req_id:      字符串变量，七牛HTTP扩展字段，参考 http://developer.qiniu.com/docs/v6/api/reference/extended-headers.html
        x_log:       字符串变量，七牛HTTP扩展字段，参考 http://developer.qiniu.com/docs/v6/api/reference/extended-headers.html
        error:       字符串变量，响应的错误内容
    """
    ret, info = put_data(token, FILE_NAME, FILE_OBJ)
    if info.status_code:
        if ret['hash'] == etag_stream(FILE_OBJ):
            return ret['hash']
        return None
    return None

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import upload_token [as 别名]
def storage(file_data):
    try:
        #构建鉴权对象
        q = Auth(access_key, secret_key)

        #要上传的空间
        bucket_name = 'ihome'

        #上传到七牛后保存的文件名
        # key = 'my-python-logo.png';


        #生成上传 Token，可以指定过期时间等

        token = q.upload_token(bucket_name)

        #要上传文件的本地路径
        # localfile = './sync/bbb.jpg'
        # ret, info = put_file(token, key, localfile)
        ret, info = put_data(token, None, file_data)
    except Exception as e:
        logging.error(e)
        raise e
    print(ret)
    print("*"*16)
    print(info)
    # assert ret['key'] == key
    # assert ret['hash'] == etag(localfile)
    print(type(info))
    print(info.status_code)
    if 200 == info.status_code:
        return ret["key"]
    else:
        raise Exception("上传失败")

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import upload_token [as 别名]
def loop_qiniu():
    while True:
        for f in os.listdir(UPLOAD_FOLDER):
            if 'tmp' not in f.split('_')[-1]:
                os.remove(os.path.join(UPLOAD_FOLDER, f))
                # print 'jump out and for one more time'
            elif 'tmp0' == f.split('_')[-1]:
                continue
            elif 'tmp' == f.split('_')[-1]:
                print 'start handle %s' % f
                f_path = os.path.join(UPLOAD_FOLDER, f)
                f_path_new = os.path.join(UPLOAD_FOLDER, f[:-4])
                key = f[:-4]
                q = Auth(access_key, secret_key)
                token = q.upload_token(Bucket, key, 3600)
                local_file = f_path
                ret, _ = put_file(token, key, local_file)
                try:
                    assert ret['key'] == key
                except TypeError:
                    print 'ret has error'
                    continue
                os.rename(f_path, f_path_new)
                print 'end handle %s' % key
                print time.strftime("%Y/%y/%d %H:%M:%S", time.localtime(time.time()))
            else:
                print '<----'
                print u'为考虑到的情况'
                print time.strftime("%Y/%y/%d %H:%M:%S", time.localtime(time.time()))
                print '---->'
    print 'pass this time while error', time.strftime("%Y/%y/%d %H:%M:%S", time.localtime(time.time()))

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import upload_token [as 别名]
def uploadsong(request):
    q = Auth('ToNLYIGLfHy5tpKSsRcBV2pw18b20LrYuBdvHaA_', 'rrD25c6RoHoMajmLR8lSz9wW4FcGEHvGMDL4l2zV')
    print q
    token = q.upload_token('outshineamazing', '')
    print token
    context = {'uptoken_url':token}
    return render(request,'comments/test.html',context)