def upload_qiniu_by_path(access_key, secret_key, bucket_name, key_prefix,
                         pool_number, path, delete=False):
    q = Auth(access_key, secret_key)
    mime_type = "text/plain"
    params = {'x:a': 'a'}

    pool = Pool(pool_number)

    for dirpath, dirnames, filenames in os.walk(path):
        print(dirpath)
        if len(filenames) > 0:
            for filename in filenames:
                if filename.startswith('.'):
                    continue
                localfile = os.path.join(dirpath, filename)
                key = os.path.join(key_prefix, localfile.replace(path, '')[1:])
                token = q.upload_token(bucket_name, key)

                pool.spawn(
                    down,
                    token=token,
                    key=key,
                    localfile=localfile,
                    mime_type=mime_type,
                    delete=delete
                )

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)

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)

	def get(self):

		access_key = 'YOUR_ACCESS_KEY'
		secret_key = 'YOUR_SECRET_KEY'

		q = Auth(access_key, secret_key)

		bucket_name = 'YOUR_BUCKET_NAME'
		
		# to set the uploaded file rename to YYYYMMDD_HHMMSS_filename
		# if the filename was "test.jpg", then the new filename will be "20160101_083054_test.jpg"
		# SEE MORE: http://developer.qiniu.com/article/kodo/kodo-developer/up/vars.html#magicvar
		policy = {"saveKey": "$(year)$(mon)$(day)_$(hour)$(min)$(sec)_$(fname)"}


		# in the source of qiniu/auth.py, the function upload_token takes 5 arguments:
		#	 bucket：your bucket_name
		#		key: the filename you want to set, None means set as ths "saveKey" above
		#	expires: expires time (second)
		#	 policy: the options to upload,see more: http://developer.qiniu.com/article/developer/security/put-policy.html
		#
		# def upload_token(self, bucket, key=None, expires=3600, policy=None, strict_policy=True):

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

		# return as json
		self.write(json.dumps({"uptoken":token}))

def generate_upload_token(prefix):
    '''
    prefix: 'head' or 'content'
    return: (token, key)
    '''

    # modify default upload zone
    qiniu.config.set_default(default_zone=qiniu.config.zone1)

    # access two keys
    access_key = current_app.config['QINIU_ACCESS_KEY']
    secret_key = current_app.config['QINIU_SECRET_KEY']
    # auth obj
    q = Auth(access_key, secret_key)
    # upload bucket name
    bucket_name = current_app.config['QINIU_BUCKET_NAME']

    # achieve file ext name
    try:
        match = re.finditer(r'.([0-9a-zA-Z]+)$', localfile)
        ext = match[-1].group(1)
    except:
        ext = 'jpg'

    # cloud filename
    # key = generate_upload_filename(ext, prefix=prefix)
    # generate token
    token = q.upload_token(bucket_name, None, 3600)

    return token

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

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()))

    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()

def upload():
    # Get the name of the uploaded file
    file = request.files['file']
    # Check if the file is one of the allowed types/extensions
    if file and allowed_file(file.filename):
        # Make the filename safe, remove unsupported chars
        filename = secure_filename(file.filename)
        # Move the file form the temporal folder to
        # the upload folder we setup
        file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
        # Redirect the user to the uploaded_file route, which
        # will basicaly show on the browser the uploaded file

        path = os.path.join(app.config['UPLOAD_FOLDER'], filename)

        access_key = ''
        secret_key = ''
        bucket_name = ''

        q = Auth(access_key, secret_key)
        token = q.upload_token(bucket_name, None, 3600)

        ret, info = qiniu.put_file(token, filename, path)

        return redirect(url_for('uploaded_file', filename=filename))

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)

def uploadToQiNiu(filePath,name):
     q = Auth(access_key, secret_key)
     localfile = filePath
     key = name
     mime_type = "image/jpeg"
     token = q.upload_token(bucket_name, key)
     ret, info = put_file(token, key, localfile, mime_type=mime_type, check_crc=True)

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)

    def post(self):
        for i in request.forms.keys():
            print i, request.forms[i], type(request.forms[i])

        for i in request.files.keys():
            print i, request.files[i], type(request.files[i])
            print request.files[i].__dict__

        image = request.files['image']
        name = image.raw_filename
        data = image.file.read()
        key = md5('data').hexdigest() + '.' + name.split('.')[-1]

        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)

def get_token(key):
    q = Auth(qiniu_access_key, qiniu_secret_key)

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

    return token

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("上传失败")

def upload_file(file_name=None, data=None):
    if not file_name:
        file_name = hashlib.md5(data).hexdigest()
    q = Auth(settings.QINIU_KEY, settings.QINIU_TOKEN)
    token = q.upload_token(settings.QINIU_BUCKET)
    ret, info = put_data(token, file_name, data)
    return ret['key'] == file_name, file_name

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

def token(request):
    # wiicome服务器设置七牛上传token
    q = Auth(ACCESS_KEY, SECRET_KEY)
    # 上传策略仅指定空间名和上传后的文件名，其他参数仅为默认值
    token = q.upload_token(BUCKET_KEY)
    data = {"uptoken": token}
    return JsonResponse(data)

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)

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))