Python Auth.private_download_url方法代码示例

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import private_download_url [as 别名]
def upload_photo():
    """上传照片到七牛，并返回私有链接地址"""
    from qiniu import Auth
    from qiniu import put_file

    global config
    progress_handler = lambda progress, total: progress

    photo_path = http_get("http://127.0.0.1:9876/photo/shot").content
    # Upload to qiniu
    mime_type = "image/jpeg"
    auth = Auth(str(config["qiniu"]["api_key"]), str(config["qiniu"]["secret"]))
    print auth
    filename = os.path.basename(photo_path)
    print "filename: ", filename, type(filename)
    token = auth.upload_token(str(config["qiniu"]["bucket"]))
    print token
    ret, info = put_file(token, filename, photo_path, {}, mime_type, progress_handler=progress_handler)
    print "uploaded: ", ret, info
    try:
        os.remove(photo_path)
    except Exception:
        pass

    # Return URL
    base_url = "{}/{}".format(str(config["qiniu"]["domain"]), filename)
    return auth.private_download_url(base_url, expires=3600)

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import private_download_url [as 别名]
class QiniuPro():
    def __init__(self):
        self.auth = Auth(ACCESS_KEY, SECRET_KEY)

    def download_private_url(self, key, expires=7200):
        base_url = '%s/%s' % (DOMAIN, key)
        private_url = self.auth.private_download_url(base_url, expires)
        return private_url

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import private_download_url [as 别名]
def get_download_file_url(file_name):
    """获取文件url"""

    cache_key = '_'.join((settings.CACHE_PREFIX, file_name))
    private_url = cache.get(cache_key)
    if private_url:
        return private_url

    q = Auth(settings.QINIU_KEY, settings.QINIU_TOKEN)
    base_url = 'http://%s/%s' % (settings.QINIU_HOST, file_name)
    private_url = q.private_download_url(base_url, expires=3600*24)

    cache.set(cache_key, private_url, 3600*24)

    return private_url

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import private_download_url [as 别名]
class qiniu():
    def __init__(self):
        self.access_key = "AK"
        self.secret_key = "SK"
        self.mdomain = "YourDomain"
        self.mauth = Auth(self.access_key, self.secret_key)
    def upload(self, upload_dir, upload_bucket):
        if os.path.isdir(upload_dir):
            if os.path.isdir(upload_dir):
                up_file_list = []
                for root, dirs, files in os.walk(upload_dir,topdown=True):
                    for v_file in files:
                        up_file_list.append(os.path.join(root, v_file))
                for file_name in up_file_list:
                    token = self.mauth.upload_token(upload_bucket, file_name)
                    ret, info = put_file(token, file_name, file_name)
                    # print(info)
                    assert ret['key'] == file_name
                    assert ret['hash'] == etag(file_name)
                    print ret
            elif os.path.isfile(upload_dir):
                token = self.mauth.upload_token(upload_bucket, file_name)
                ret, info = put_file(token, file_name, file_name)
                assert ret['key'] == file_name
                assert ret['hash'] == etag(file_name)
                print ret
        elif os.path.isfile(upload_dir):
            file_name = upload_dir
            token = self.mauth.upload_token(upload_bucket, file_name)
            ret, info = put_file(token, file_name, file_name)
            assert ret['key'] == file_name
            assert ret['hash'] == etag(file_name)
            print ret
    def list(self, bucket_name, prefix, limit=5):
        bucket = BucketManager(self.mauth)
        delimiter = None
        marker = None
        ret, eof, info = bucket.list(bucket_name, prefix, marker, limit, delimiter)
        for item in ret.get('items'):
            print "{Name: %s Size:%s Hash:%s}" % (item['key'], item['fsize'], item['hash'])
    def download(self, filename, output_dir):
        base_url = 'http://%s/%s' % (self.mdomain, filename)
        private_url = self.mauth.private_download_url(base_url)
        print private_url
        if os.path.exists(output_dir):
            os.chdir(output_dir)
        else:
            os.makedirs(output_dir)
            os.chdir(output_dir)
        res = requests.get(private_url, stream=True)
        assert res.status_code == 200
        print res.status_code
        with closing(res) as r:
            accepts = 0
            chunk_size = 512
            with open(os.path.basename(filename), "wb") as code:
                for chunk in r.iter_content(chunk_size=chunk_size):
                #downlaod big data optimization；old mathed is  code.write(r.content)
                    if chunk:  # filter out keep-alive new chunks
                        code.write(chunk)
                        accepts += len(chunk)
                        # print accepts, int(r.headers['Content-Length'])
                        progress = round(float(accepts) / int(r.headers['Content-Length']), 4) * 100
                        sys.stdout.write('\r' + 'Now downlaod ' + str(progress) + '%')
                        sys.stdout.flush()
                print '\n'

    def delete(self, bucket_name, del_list):
        mbucket = BucketManager(self.mauth)
        del_item = build_batch_delete(bucket_name, del_list)
        ret, info = mbucket.batch(del_item)
        print info

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import private_download_url [as 别名]
def GetQiniuDlToken(key):

    if key is '' or key is None:
        return False,'文件名为空'
    #开发者账号授权
    q = Auth(access_key, secret_key)
    private_url = ''
    #生成私有的基本URL
    base_url = 'http://%s/%s' % (bucket_url, key)
    try:
        #生成私密url
        private_url = q.private_download_url(base_url, 3600)
        return True,private_url
    except:
        print '第三方获取上传凭证函数异常'
        return False,private_url

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import private_download_url [as 别名]
def test_fetch():
    q = Auth(access_key, secret_key)
    bm = BucketManager(q)
    ret, info = bm.stat(bucket, mykey)
    print(info)
    print(ret)

    bucket_domain = '7xpb8s.com1.z0.glb.clouddn.com'
    base_url = 'http://%s/%s' % (bucket_domain, mykey)
    private_url = q.private_download_url(base_url, expires=3600)
    print(private_url)
    r = requests.get(private_url)
    assert r.status_code == 200

    ret, info = bm.fetch(private_url, bucket, mykey)
    print(info)
    print(ret)

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import private_download_url [as 别名]
def list_file(username, path): # ok
    user = User.objects.filter(username=username)
    if bool(user):
        user = user[0]
    else :
        return False
    q = Auth(settings.QINIU_ACCESS_KEY, settings.QINIU_SECRET_KEY)  # 授权
    files = FileInfo.objects.filter(owner=user,file_path=path)  #
    filelist = {}
    for f in files:
        if f.file_type == 'dir':  # 文件夹不需要下载 ，但可以设置另外的子目录获取的url，待定
            filelist[f.file_name] = ""
            continue
        if path == '/':
            path = ""
        base_url = ''.join([settings.QINIU_DOMAIN,username, path, '/', f.file_name])
        filelist[f.file_name] =  q.private_download_url(base_url, expires=3600)
    return json.dumps(filelist,ensure_ascii=False,encoding="utf-8",sort_keys=True)

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import private_download_url [as 别名]
def qiniu_private(base_url):
    """
    get private resource
    """
    cache_key = 'st:qiniu:' + base_url

    cache_value = cache.get(cache_key)
    if cache_value:
        return cache_value

    q = Auth(get_qiniu_config('QINIU_ACCESS_KEY'),
             get_qiniu_config('QINIU_SECRET_KEY'))
    expire = 3600 if not hasattr(settings,
                                 'QINIU_PREVIEW_EXPIRE') else settings.QINIU_PREVIEW_EXPIRE
    private_url = q.private_download_url(base_url, expires=expire)

    cache.set(cache_key, private_url, timeout=max(10, expire - 10))

    return private_url

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import private_download_url [as 别名]
    def content_process(self, content):
        # render content included gist
        content = re.sub(r'http(s)?:\/\/gist.github.com\/(\d+)(.js)?', r'<script src="http://gist.github.com/\2.js"></script>', content)
        # render sinaimg pictures
        content = re.sub(r'(http:\/\/\w+.sinaimg.cn\/.*?\.(jpg|gif|png))', r'<img src="\1" />', content)
        # render qiniu private image link
        qiniu_re = re.compile(r'(%s/.*?\.(?:jpg|jpeg|gif|png))' % bucket_domain)
        image_urls = qiniu_re.findall(content)
        q = Auth(access_key, secret_key)
        private_url = "jk"
        for image_url in image_urls:
            private_url = q.private_download_url(image_url, expires=10)
            #private_url = re.sub(r'&', '&amp;', private_url)
            content = re.sub(image_url, r'<img src="%s" />' % private_url, content)

        # render @ mention links
        content = re.sub(r'@(\w+)(\s|)', r'@<a href="/u/\1">\1</a> ', content)
        # render youku videos
        content = re.sub(r'http://v.youku.com/v_show/id_(\w+).html', r'<iframe height=498 width=510 src="http://player.youku.com/embed/\1" frameborder=0 allowfullscreen style="width:100%;max-width:510px;"></iframe>', content)
        return content

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import private_download_url [as 别名]
path = os.path.join(path, r'dest_photo')




for root, dirs, files in os.walk(path):
    print(files)
    fileLength = len(files)
    # filename = os.path.split(path)[1]

    for i in range(fileLength):
        localfile = path + "\%s" % files[i]  # 照片路径
        # file_name= os.path.splitext(files[i])  #文件名
        img_url = url + files[i] + para
        # 可以设置token过期时间
        private_url = q.private_download_url(img_url, expires=3600)
        r = requests.get(private_url)
        img_name = os.getcwd()
        img_name = os.path.join(img_name, r'restore_photo')
        if not os.path.isdir(img_name):
            os.mkdir(img_name)
        img_name =img_name + "\%s" % files[i]
        print(img_name)
        with open(img_name, 'wb') as f:
            for chunk in r.iter_content(chunk_size=1024):
                f.write(chunk)
        

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import private_download_url [as 别名]

#.........这里部分代码省略.........
        final_path = urljoin(base_path.rstrip('/') + "/", name)

        base_path_len = len(base_path)
        if (not final_path.startswith(base_path) or
                final_path[base_path_len:base_path_len + 1] not in ('', '/')):
            raise SuspiciousOperation("Attempted access to '%s' denied." %
                                      name)
        return final_path.lstrip('/')

    def _open(self, name, mode='rb'):
        return QiniuFile(name, self, mode)

    def _save(self, name, content):
        cleaned_name = self._clean_name(name)
        name = self._normalize_name(cleaned_name)

        if hasattr(content, 'open'):
            # Since Django 1.6, content should be a instance
            # of `django.core.files.File`
            content.open()

        if hasattr(content, 'chunks'):
            content_str = b''.join(chunk for chunk in content.chunks())
        else:
            content_str = content.read()

        self._put_file(name, content_str)
        content.close()
        return cleaned_name

    def _put_file(self, name, content):
        token = self.auth.upload_token(self.bucket_name)
        ret, info = put_data(token, name, content)
        if ret is None or ret['key'] != name:
            raise QiniuError(info)

    def _read(self, name):
        return requests.get(self.url(name)).content

    def delete(self, name):
        name = self._normalize_name(self._clean_name(name))
        if six.PY2:
            name = name.encode('utf-8')
        ret, info = self.bucket_manager.delete(self.bucket_name, name)

        if ret is None or info.status_code == 612:
            raise QiniuError(info)

    def _file_stat(self, name, silent=False):
        name = self._normalize_name(self._clean_name(name))
        if six.PY2:
            name = name.encode('utf-8')
        ret, info = self.bucket_manager.stat(self.bucket_name, name)
        if ret is None and not silent:
            raise QiniuError(info)
        return ret

    def exists(self, name):
        stats = self._file_stat(name, silent=True)
        return True if stats else False

    def size(self, name):
        stats = self._file_stat(name)
        return stats['fsize']

    def modified_time(self, name):
        stats = self._file_stat(name)
        time_stamp = float(stats['putTime']) / 10000000
        return datetime.datetime.fromtimestamp(time_stamp)

    def listdir(self, name):
        name = self._normalize_name(self._clean_name(name))
        if name and not name.endswith('/'):
            name += '/'

        dirlist = bucket_lister(self.bucket_manager, self.bucket_name,
                                prefix=name)
        files = []
        dirs = set()
        base_parts = name.split("/")[:-1]
        for item in dirlist:
            parts = item['key'].split("/")
            parts = parts[len(base_parts):]
            if len(parts) == 1:
                # File
                files.append(parts[0])
            elif len(parts) > 1:
                # Directory
                dirs.add(parts[0])
        return list(dirs), files

    def url(self, name):
        name = self._normalize_name(self._clean_name(name))
        name = filepath_to_uri(name)
        protocol = u'https://' if self.secure_url else u'http://'
        url = urljoin(protocol + self.bucket_domain, name)
        if self.private_url:
            return self.auth.private_download_url(url, self.private_url_expires)
        else:
            return url

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import private_download_url [as 别名]

#.........这里部分代码省略.........
            if self.log_state == 4:
                break
            elif self.log_state != 1 or len(self.order)==0:
                time.sleep(0.1)
            else:
                self.ordlock.acquire()
                tord = self.order[0]
                self.ordlock.release()
                print tord
                if tord[0] == 'up':
                    self.__upload_file(tord[1])
                elif tord[0] == 'down':
                    self.__download_file(tord[1])
                elif tord[0] == 'dir':
                    self.__list_all()
                elif tord[0] == 'del':
                    self.__delete_file(tord[1])
                elif tord[0] == 'upd':
                    self.__update_file(tord[1])
                self.ordlock.acquire()
                del self.order[0]
                self.ordlock.release()

    def __get_mime_type(self,__path):
        mime_type = "text/plain"
        return mime_type

    def __list_all(self):
        marker = None
        limit = None
        eof = False
        self.lislock.acquire()
        self.filelist = []
        self.lislock.release()
        temp = []
        while eof is False:
            ret, eof, info = self.bucket.list(self.BN, prefix=self.pre, marker=marker, limit=limit)
            marker = ret.get('marker', None)
            for item in ret['items']:
                if item['key'][-4:] == '.txt':
                    continue
                if item['key'][-4:] == '.inf':
                    info = item['key'].split('&&')
                    filename = info[0]+'&&'+info[1]+'&&'+info[2]
                    mood = int(info[3])
                    pl = info[4]
                    self.inf[filename] = [mood,pl]
                    continue
                temp.append(item['key'].split(self.pre)[1])  
                
        self.lislock.acquire()
        self.filelist = temp
        self.lislock.release()

    def __delete_file(self,key):
        ret ,info = self.bucket.delete(self.BN,self.pre+key)

    def __update_file(self,localphoto):
        localfile = localphoto.getpath()
        key = self.pre + localfile.split('\\')[-1]
        inf_key = key + '&&' + str(localphoto.getmood())\
                  +'&&'+localphoto.getcomment()+'&&.inf'
        self.inf[key] = [localphoto.getmood(),localphoto.getcomment]
        token1 = self.q.upload_token(self.BN,inf_key)
        mime_type = self.__get_mime_type(localfile)
        params = {'x:a': 'a'}
        progress_handler = lambda progress, total: progress
        ret1, info1 = qiniu.put_file(token1, inf_key, self.static_file,params,\
                                   mime_type, progress_handler=progress_handler)

    #now it need a photo object
    def __upload_file(self,localphoto):
        localfile = localphoto.getpath()
        key = self.pre + localfile.split('\\')[-1]
        inf_key = key + '&&' + str(localphoto.getmood())\
                  +'&&'+localphoto.getcomment()+'&&.inf'
        self.inf[key] = [localphoto.getmood(),localphoto.getcomment]
        token1 = self.q.upload_token(self.BN,inf_key)
        token = self.q.upload_token(self.BN, key)
        mime_type = self.__get_mime_type(localfile)
        params = {'x:a': 'a'}
        progress_handler = lambda progress, total: progress
        ret1, info1 = qiniu.put_file(token1, inf_key, self.static_file,params,\
                                   mime_type, progress_handler=progress_handler)
        ret, info = qiniu.put_file(token, key, localfile, params,\
                                   mime_type, progress_handler=progress_handler)

    def __download_file(self,key):
        filename = self.pre + key
        base_url = 'http://%s/%s' % (self.BD,filename)
        private_url = self.q.private_download_url(base_url,expires=3600)
        r = requests.get(private_url)
        with open(self.path+'\\'+key,'wb') as code:
            code.write(r.content)
        p = photo(self.path + '\\' +key)
        if filename in self.inf:
            p.setmood(self.inf[filename][0])
            p.setcomment(self.inf[filename][1])
        p.setcloud(1)
        self.clouds.append(p)

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import private_download_url [as 别名]
def get_download_file_url(file_name):
    """获取文件url"""
    q = Auth(settings.QINIU_KEY, settings.QINIU_TOKEN)
    base_url = 'http://%s/%s' % (settings.QINIU_HOST, file_name)
    private_url = q.private_download_url(base_url, expires=3600*24)
    return private_url

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import private_download_url [as 别名]
class QiniuStorage(object):
    storage_type = 'qiniu'

    def __init__(self, user_id, dbQiniuStorage, use_system=False):
        if use_system is True:
            self.access_key = 'lnjEMrmedpqOhO2IAw4WtyGNbNVQrFPGEVLQuyFp'
            self.secret_key = 'Nw_4Cn0L0Z3LLOL-t-OvGOVVV2kSxY3_my85UJwG'
            self.bucket_name = 'czlib-system'
            self.download_url = '7xjrbh.com1.z0.glb.clouddn.com'
            self.q = Auth(self.access_key, self.secret_key)
        else:
            self.access_key = dbQiniuStorage.access_key.encode('utf-8')  # unicode to str
            self.secret_key = dbQiniuStorage.secret_key.encode('utf-8')
            self.bucket_name = dbQiniuStorage.bucket_name.encode('utf-8')
            self.download_url = dbQiniuStorage.download_url.encode('utf-8')
            self.q = Auth(self.access_key, self.secret_key)
            # print('QiniuStorage - __init__: user_id: %s' % user_id)
            # print('QiniuStorage - __init__: ak:%s, sk:%s, b_name:%s, d_url:%s' % (self.access_key, self.secret_key, self.bucket_name, self.download_url))

    def upload_stream(self, key, input_stream, data_size):
        # print('upload_stream: key=%s, data_size=%s' % (key, data_size))
        # key = ''
        # input_stream=self.fileobj.stream
        # print('upload_stream: 1')
        token = self.q.upload_token(self.bucket_name, key)
        # print('upload_stream: 2')
        ret, info = put_stream(token, key, input_stream, data_size)
        # print(info)
        assert ret['key'] == key
        return self.get_download_url(key)

    # 直接上传二进制流
    def upload_binary_stream(self, key, data):
        # key = ''
        # data = 'hello bubby!'
        token = self.q.upload_token(self.bucket_name, key)
        ret, info = put_data(token, key, data, mime_type="application/octet-stream", check_crc=True)
        # print(info)
        assert ret['key'] == key
        return self.get_download_url(key)

    # 上传本地文件
    def upload_file(self, key, localfile):
        # key = 'home/carlo/test_file.py'
        mime_type = "text/plain"
        params = {'x:a': 'a'}

        token = self.q.upload_token(self.bucket_name, key)
        ret, info = put_file(token, key, localfile, mime_type=mime_type, check_crc=True)
        # print(info)
        assert ret['key'] == key
        assert ret['hash'] == etag(localfile)

    #断点续上传、分块并行上传
    def upload_big_file(self, key, localfile):
        mime_type = "text/plain"
        params = {'x:a': 'a'}
        # key = 'big'

        token = self.q.upload_token(self.bucket_name, key)
        progress_handler = lambda progress, total: progress
        ret, info = put_file(token, key, localfile, params, mime_type, progress_handler=progress_handler)
        # print(info)
        assert ret['key'] == key

    def single_delete(self, key):
        bucket = BucketManager(self.q)
        ret, info = bucket.delete(self.bucket_name, key)
        # print(info)
        assert info.status_code == 200 or info.status_code == 612

    # 批量删除文件
    def multi_delete(self, key_list):
        # key_list: [key1, key2, key3, ...]
        from qiniu import build_batch_delete
        bucket = BucketManager(self.q)
        ops = build_batch_delete(self.bucket_name, key_list)
        ret, info = bucket.batch(ops)
        # print('QiniuStorage - multi_delete: %s' % info)

        json_info = json.loads(info.text_body)
        for m_info in json_info:
            # "code":612,"data":{"error":"no such file or directory"
            assert m_info[u'code'] == 200 or m_info[u'code'] == 612

    def get_private_download_url(self, key):
        # bucket is private, http://<domain>/<key>?e=<deadline>&token=<dntoken>
        base_url = 'http://%s/%s' % (self.bucket_name + '.qiniudn.com', key)
        download_url = self.q.private_download_url(base_url, expires=3600)
        assert isinstance(download_url, object)
        return download_url

    def get_download_url(self, key):
        # bucket is public, http://<domain>/<key>
        download_url = 'http://%s/%s' % (self.download_url, key)
        return download_url

# 需要导入模块: from qiniu import Auth [as 别名]
# 或者: from qiniu.Auth import private_download_url [as 别名]
def get_private_url(username, path,filename):
    q = Auth(settings.QINIU_ACCESS_KEY, settings.QINIU_SECRET_KEY)  # 授权
    base_url = ''.join([settings.QINIU_DOMAIN,username, path, '/', filename])
    return q.private_download_url(base_url, expires=3600)