Python util.format_path函数代码示例

  def put(self, path, content):
    """
    Args:
      path: string
      content: string

    Returns:
      None
    """
    path = util.format_path(path)
    name = os.path.basename(path)
    parent_folder = os.path.dirname(path)

    if parent_folder == '/':
      parent_id = BoxAPI.ROOT_FOLDER_ID
    else:
      parent = self._path_to_metadata(parent_folder, isfolder=True)
      if not parent:
        # if the parent folder doesn't exist, then create one
        self.putdir(parent_folder)
        parent = self._path_to_metadata(parent_folder, isfolder=True)
      parent_id = parent['id']

    url = BoxAPI.UPLOAD_URL + '/files/content'
    form = {"parent_id": parent_id}
    strobj = StringIO(content)

    resp = self._request('POST', url, data=form, files={name: strobj})

    metadata = resp['entries'][0]
    self._cache_metadata(path, metadata)
    return True 

  def get_logs(self, path, last_clock):

    beg = time.time()

    path = '/Public' + util.format_path(path)
    length = 5
    offset = 0

    # latest comment comes first
    comments = self.get_comments(path, length, offset)
    if not comments:
      return [], None
    
    new_logs = []
    new_clock = comments[0]['id']
    end = False

    while True:
      for comment in comments:
        if last_clock and comment['id'] == last_clock:
          end = True
          break
        new_logs.insert(0, comment['message'])
      if end: break
      if len(comments) < length: break
      # if haven't reached to end, read next batch
      offset += length
      comments = self.get_comments(path, length, offset)

    end = time.time()
    dbg.paxos_time("get_log %s", end-beg)
    return new_logs, new_clock

  def listdir(self, path):
    """
    Args:
      path: string

    Returns:
      list of file/dir names
    """
    path = util.format_path(path)

    if path == '/':
      folder_id = BoxAPI.ROOT_FOLDER_ID
    else:
      folder = self.search(path)
      folder_id = folder['id']

    result = []
    offset = 0
    while True:
      metalist = self._listdir(folder_id, offset)
    
      for metadata in metalist:
        self._cache_metadata(os.path.join(path, metadata['name']), metadata)
        result.append(metadata['name'])

      if(len(metalist) < 1000): break
      offset += 1000
      
    return result

  def listdir(self, path):
    result = []
    path = util.format_path(path)
    if path == '/':
      folder_id = 'root'
    else:
      folder_id = self._path_to_metadata(path)['id']

    param = {}
    param['q'] = '"%s" in parents and trashed=false' % (folder_id)
    param['maxResults'] = 500
    page_token = None

    while True:
      try:
        if page_token:
          param['pageToken'] = page_token
        files = self.service.files().list(**param).execute()
        result.extend(map(lambda x: x['title'], files['items']))

        page_token = files.get('nextPageToken', None)
        if not page_token:
          break
      except errors.HttpError, error:
        print 'An error occurred: %s' % error
        return None

  def putdir(self, path):
    """
    Args:
      path: string

    Returns:
      None
    """
    path = util.format_path(path)
    name = os.path.basename(path)
    parent_folder = os.path.dirname(path)

    if parent_folder == '/':
      parent_id = BoxAPI.ROOT_FOLDER_ID
    else:
      parent = self._path_to_metadata(parent_folder, isfolder=True)
      if not parent:
        # if the parent folder doesn't exist, then create one
        self.putdir(parent_folder)
        parent = self._path_to_metadata(parent_folder, isfolder=True)
      parent_id = parent['id']

    url = BoxAPI.BASE_URL + '/folders'
    data = '{"name":"%s", "parent":{"id":"%s"}}' % (name, parent_id)
    resp = self._request('POST', url, data=data)

    self._cache_metadata(path, resp)

  def rmdir(self, path):
    path = util.format_path(path)
    metadata = self._path_to_metadata(path, isfolder=True)
    file_id = metadata['id']

    url = OneDriveAPI.BASE_URL + '/%s' % file_id
    self._request('DELETE', url, raw=True)

 def metadata(self, path):
   path = util.format_path(path)
   _md = self.search(path)
   md = {}
   md['size'] = _md['size']
   md['mtime'] = util.convert_time(_md['updated_time'])
   return md

  def putdir(self, path):
    """
    Args:
      path: string

    Returns:
      None
    """
    path = util.format_path(path)
    name = os.path.basename(path)
    parent_folder = os.path.dirname(path)

    parent = self._path_to_metadata(parent_folder, isfolder=True)
    if not parent:
      # if the parent folder doesn't exist, then create one
      self.putdir(parent_folder)
      parent = self._path_to_metadata(parent_folder, isfolder=True)

    parent_id = parent['id']
    url = OneDriveAPI.BASE_URL + '/%s' % parent_id
    headers = {
      "Authorization": "Bearer " + self.token.access_token,
      "Content-Type": "application/json"
    }
    data = '{"name": "%s"}' % name
    resp = self._request('POST', url, headers=headers, data=data)
    self._cache_metadata(path, resp)

  def put(self, path, content):
    """
    Args:
      path: string
      content: string

    Returns:
      None
    """
    path = util.format_path(path)
    name = os.path.basename(path)
    parent_folder = os.path.dirname(path)

    parent = self._path_to_metadata(parent_folder, isfolder=True)
    if not parent:
      # if the parent folder doesn't exist, then create one
      self.putdir(parent_folder)
      parent = self._path_to_metadata(parent_folder, isfolder=True)

    parent_id = parent['id']
    url = OneDriveAPI.BASE_URL + '/%s/files/%s' % (parent_id, name)
    strobj = StringIO(content)
    params = { 'overwrite': 'false' }
    metadata = self._request('PUT', url, params=params, data=strobj)

    metadata[u'type'] = u'file'
    self._cache_metadata(path, metadata)
    return True

  def update(self, path, content):
    """Update the file
    Args and returns same as put
    """
    dbg.dbg(path)
    path = util.format_path(path)
    metadata = self._path_to_metadata(path)
    file_id = metadata['id']

    uri = GoogleAPI.UPLOAD_URL + '/files/%s?uploadType=media' % file_id

    headers = {
      'Content-Type': 'text/plain',
      'Content-Length': len(content),
	 	}

    for retry_num in xrange(self._num_retries + 1):
      resp, data = self.service._http.request(uri, method='PUT',
        body=content, headers=headers)
      if resp.status < 500:
        break

    if resp.status >= 300:
      raise errors.HttpError(resp, data, uri=uri)
    if resp.status == 200:
      drive_file = json.loads(data)
      self._cache_metadata(path, drive_file)
      return True
    else:
      return False

  def putdir(self, path):

    uri = GoogleAPI.UPLOAD_URL + '/files?uploadType=multipart&alt=json'

    path = util.format_path(path)
    name = os.path.basename(path)
    folder = os.path.dirname(path)

    parent_id = None
    if folder != '/':
      # if it's not at the root folder, find out the parent id
      parent = self._path_to_metadata(folder, isfolder=True)
      if not parent:
        # if the parent folder doesn't exist, then create one
        self.putdir(folder)
        parent = self._path_to_metadata(folder, isfolder=True)
      parent_id = parent['id']

    body = {
      'title': name,
      'mimeType': 'application/vnd.google-apps.folder'
    }
    if parent_id:
      # if not at root folder
      body['parents'] = [{'id': parent_id}]

    try:
      drive_file = self.service.files().insert(body=body).execute()
      self._cache_metadata(path, drive_file)
      return True
    except errors.HttpError, error:
      print 'An error occurred: %s' % error
      return False

  def rmdir(self, path):
    path = util.format_path(path)
    metadata = self._path_to_metadata(path, isfolder=True)
    file_id = metadata['id']

    self.service.files().delete(fileId=file_id).execute()
    self._decache_metadata(path, metadata)

 def metadata(self, path):
   path = util.format_path(path)
   _md = self.search(path)
   md = {}
   md['size'] = eval(_md['fileSize'])
   md['mtime'] = util.convert_time(_md['modifiedDate'])
   return md

  def get_logs(self, path, last_clock):
    path = util.format_path(path)
    file_id = self._path_to_metadata(path)['id']

    # latest comment comes first
    comments = self.service.comments().list(fileId=file_id, maxResults=5).execute()
    if not comments['items']:
      return [], None
    
    new_logs = []
    new_clock = comments['items'][0]['commentId']
    end = False

    while True:
      for comment in comments['items']:
        if last_clock and comment['commentId'] == last_clock:
          end = True
          break
        new_logs.insert(0, comment['content'])
      if end: break
      if 'nextPageToken' not in comments: break
      # get a new batch (5) comments
      comments = self.service.comments().list(fileId=file_id, maxResults=5, pageToken=comments['nextPageToken']).execute()

    return new_logs, new_clock

  def listdir_old(self, path):
    result = []
    page_token = None

    path = util.format_path(path)
    folder_metadata = self.search(path)
    if folder_metadata:
      folder_id = folder_metadata['id']
    else:
      folder_id = 'root'

    while True:
      try:
        param = {}
        if page_token:
          param['pageToken'] = page_token

        children = self.service.children().list(folderId=folder_id, **param).execute()

        for child in children.get('items', []):
          request = self.service.files().get(fileId=child['id'])
          metadata = request.execute()
          self._cache_metadata(os.path.join(path, metadata['title']), metadata)
          result.append(metadata['title'])

        page_token = children.get('nextPageToken')

        if not page_token:
          break
      except errors.HttpError, error:
        print 'An error occurred: %s' % error
        break