def do_move(client, args):
"""OneDriveClient, [str] -> OneDriveClient
Move a remote item to a remote location.
Also can be used to rename.
Not working so well....
"""
from_location = args.rest[0]
to_location = args.rest[1]
# rename
if path_to_remote_path(from_location) == path_to_remote_path(to_location):
renamed_item = onedrivesdk.Item()
renamed_item.name = path_to_name(to_location)
get_bare_item_by_path(client, from_location).update(renamed_item)
return client
# real move
moved_item = onedrivesdk.Item()
to_item = get_bare_item_by_path(client, to_location)
# if target is folder, put the item under
if to_item.folder:
moved_item.parent_reference = to_item
get_bare_item_by_path(client, from_location).update(renamed_item)
def setUp(self):
self.temp_config_dir, self.temp_repo_dir, self.drive_config, self.repo = get_sample_repo(
)
self.root_folder_item = onedrivesdk.Item(
json.loads(get_resource('data/folder_item.json',
pkg_name='tests')))
self.root_subfolder_item = onedrivesdk.Item(
json.loads(
get_resource('data/subfolder_item.json', pkg_name='tests')))
self.root_child_item = onedrivesdk.Item(
json.loads(
get_resource('data/folder_child_item.json', pkg_name='tests')))
self.image_item = onedrivesdk.Item(
json.loads(get_resource('data/image_item.json', pkg_name='tests')))
self._add_all_items()
def createNewFolder(folderName, parent):
f = onedrivesdk.Folder()
i = onedrivesdk.Item()
i.name = folderName
i.folder = f
returned_item = parent.children.add(i)
return client.item(drive="me", id=returned_item.id)
def do_mkdir(client, args):
"""OneDriveClient, [str] -> OneDriveClient
Make a remote folder.
This is NOT a recursive one: the father folder must exist.
Nice and easy.
"""
for folder_path in args.rest:
# make sure we are making the right folder
if folder_path.endswith('/'):
folder_path = folder_path[:-1]
f = onedrivesdk.Folder()
i = onedrivesdk.Item()
i.name = path_to_name(folder_path)
i.folder = f
client.item(drive='me',
path=path_to_remote_path(folder_path)).children.add(i)
return client
def test_remote_dir_matches_record(self):
item = onedrivesdk.Item(
json.loads(get_resource('data/folder_item.json',
pkg_name='tests')))
self.repo.update_item(item, '', size_local=0)
record = self.repo.get_item_by_path(item.name, '')
merge_dir.MergeDirectoryTask._remote_dir_matches_record(item, record)
def mkdir(self, path, mode):
name, parent = basename(path), dirname(path)
item = onedrivesdk.Item()
item.name = name
item.folder = onedrivesdk.Folder()
new_item = self.api.item(path=parent).children.add(item)
self.cache.add_item(new_item.id, name, parent,
new_item.created_date_time)
def rename(self, old, new):
if old == new:
return
old_id = self.api.item(path=old).get().id
renamed_item = onedrivesdk.Item()
renamed_item.name = basename(new)
renamed_item.id = old_id
self.cache.update_name(old_id, renamed_item.name)
self.api.item(id=renamed_item.id).update(renamed_item)
def handle(self):
logging.info('Uploading file "%s" to OneDrive.', self.local_abspath)
occupy_task = self.task_pool.occupy_path(self.local_abspath, self)
if occupy_task is not self:
logging.warning(
'Cannot upload "%s" because %s.', self.local_abspath,
"path is blacklisted" if occupy_task is None else
str(occupy_task) + ' is in progress')
return False
try:
item_stat = os.stat(self.local_abspath)
if item_stat.st_size < self.PUT_FILE_SIZE_THRESHOLD_BYTES:
item_request = self.parent_dir_request.children[self.item_name]
returned_item = item_request_call(self.repo,
item_request.upload,
self.local_abspath)
if returned_item is None:
logging.warning(
'Upload API did not return metadata of remote item for "%s". '
'Make an explicit request.', self.local_abspath)
returned_item = item_request_call(self.repo,
item_request.get)
else:
logging.info('Uploading large file "%s" in chunks of 10MB.',
self.local_abspath)
item_request = self.repo.authenticator.client.item(
drive=self.repo.drive.id, path=self.rel_path)
returned_item = item_request_call(
self.repo,
item_request.upload_async,
local_path=self.local_abspath,
upload_status=self.update_progress)
if not isinstance(returned_item, onedrivesdk.Item):
if hasattr(returned_item, '_prop_dict'):
returned_item = onedrivesdk.Item(
returned_item._prop_dict)
else:
returned_item = item_request_call(
self.repo, item_request.get)
self.update_timestamp_and_record(returned_item, item_stat)
self.task_pool.release_path(self.local_abspath)
logging.info('Finished uploading file "%s".', self.local_abspath)
return True
except (onedrivesdk.error.OneDriveError, OSError) as e:
logging.error('Error uploading file "%s": %s.', self.local_abspath,
e)
# TODO: what if quota is exceeded?
if (isinstance(e, onedrivesdk.error.OneDriveError)
and e.code == onedrivesdk.error.ErrorCode.MalwareDetected):
logging.warning(
'File "%s" was detected as malware by OneDrive. '
'Do not upload during program session.',
self.local_abspath)
self.task_pool.occupy_path(self.local_abspath, None)
return False
self.task_pool.release_path(self.local_abspath)
return False
def cargarArchivosOne(self):
self.lbOdri.delete(0, END)
items = client.item(id="root").children.get()
item = onedrivesdk.Item()
for item in items:
self.lbOdri.insert('end', item.name)
def create_folder_by_name(self, name, parent=None, ignore_exists=True):
parent = parent if parent != None else self.get_root_folder()
if (not ignore_exists) and self.get_folder_by_name(name,
parent) != None:
raise Exception(
'Folder already exists and overwrite flag is set to false.')
f = onedrivesdk.Folder()
i = onedrivesdk.Item()
i.name = name
i.folder = f
new_folder = parent.children.add(i)
return self.get_object_by_id(new_folder.id)
def __create_folder(self, item_id,
folder_name): #Create folder with provided name
f = onedrivesdk.Folder()
i = onedrivesdk.Item()
i.name = folder_name
i.folder = f
folder = self.__onedrive_service.item(drive='me',
id=item_id).children.add(i)
log_success('[+] creating new directory...')
return folder.id #Return folder object ID
def put(self, filename, data):
with self.exception_handler():
max_chunk_size = 62914560 # 60 mb
size = len(data)
if size < max_chunk_size:
request = self._get_item(filename).content.request()
request.append_option(
onedrivesdk.options.HeaderOption(
"Content-Type", "application/octet-stream"))
self.client.auth_provider.authenticate_request(request)
response = self.client.http_provider.send("PUT",
request._headers,
request.request_url,
data=data)
assert response.status >= 200 and response.status < 300
else:
# create a blank file
self.put(filename, "")
f = io.BytesIO(data)
item = self._get_item(filename)
new_item = onedrivesdk.Item()
new_item.name = filename
response = item.create_session(new_item).post()
upload_url = response.upload_url
request = item.content.request()
request.append_option(
onedrivesdk.options.HeaderOption(
"Content-Type", "application/octet-stream"))
self.client.auth_provider.authenticate_request(request)
offset = 0
while offset < size:
chunk = f.read(max_chunk_size)
chunklen = len(chunk)
request.append_option(
onedrivesdk.options.HeaderOption(
"Content-Range", "bytes %s-%s/%s" %
(offset, offset + chunklen - 1, size)))
response = self.client.http_provider.send("PUT",
request._headers,
upload_url,
data=chunk)
assert response.status >= 200 and response.status < 300
offset += chunklen
def upload_folder(self, ls_dt_fld):
nm_fld = ls_dt_fld[0] # nm_fld = name of folder
pr_fld = ls_dt_fld[1] # pr_fld = id parent
f = onedrivesdk.Folder()
i = onedrivesdk.Item()
i.name = nm_fld
i.folder = f
try:
OB = self.client.item(drive="me", id=pr_fld).children.add(i)
return OB.id
except Exception:
return None
def upload_file_s(self):
def find_in_colls(prev_col=None):
self.logger.debug("Paging trough collections\n")
coll = None
if prev_col:
coll = onedrivesdk.ChildrenCollectionRequest.get_next_page_request(prev_col, client).get()
else:
coll = self.api_end.item(drive='me', id='root').children.request(top=1).get()
names = [n.name for n in coll]
end = True if len(coll) != 5 else False
found = True if dest in names else False
if end and not found:
self.logger.debug("Couldn't find destination in collections")
return False
elif found:
return True
elif end:
self.logger.debug("Collection has ended")
return False
else:
self.logger.debug("Collection has ended, but there might be more pages retrying")
return find_in_colls(coll)
u_path = src or self.u_path
u_path = os.path.abspath(u_path)
if os.path.isfile(u_path):
self.logger.info("Src is file: %s" % (u_path))
f_name = os.path.basename(u_path)
if not find_in_colls():
self.logger.info("Your destination does not exist, creating it now...\n")
f = onedrivesdk.Folder()
i = onedrivesdk.Item()
i.name = dest
i.folder = f
try:
returned_item = self.api_end.item(drive='me', id='root').children.add(i)
except Exception as e:
self.logger.critical("Error creating folder\n")
sys.exit(1)
with open(u_path, "rb") as f:
db_path = dest.lower()
db_path = "/%s" % (db_path)
f_path = "%s/%s" % (db_path, f_name)
list_d = [entry.name for entry in self.api_end.files_list_folder('').entries]
if dest.lower() not in list_d:
self.api_end.files_create_folder(db_path)
self.api_end.files_upload(f.read(), f_path, mode=WriteMode('overwrite'))
else:
print("Not implemented")
sys.exit(1)
def get_upload(client, get_sharing_link):
f = onedrivesdk.Folder()
i = onedrivesdk.Item()
i.name = FOLDER_NAME
i.folder = f
retur_folder = client.item(drive='me', id='root').children.add(i)
try:
return_file = client.item(
drive='me',
id=retur_folder.id).children['%s' %
FILE_NAME].upload(FILE_UPLOAD)
get_sharing_link(client, return_file)
print share
except IOError:
print u'Файл не найден'
def onedrive_create_folder(onedrive_access, folder_name):
try:
item_id = "root"
drive = "me"
#method to create new folder
f = onedrivesdk.Folder()
i = onedrivesdk.Item()
i.folder = f
i.name = folder_name
onedrive_access.item(drive=drive, id=item_id).children.add(i)
except Exception as e:
#print('Folder create:: ', str(e))
return
def create_folder(self, name, parent_id=None, parent_path=None):
"""
Create a new folder in OneDrive
:param name: str, new folder name
:param parent_id: str, parent id
:param parent_path: str, parent path
:return:
"""
folder_to_create = onedrivesdk.Item()
folder_to_create.name = name
folder_to_create.folder = onedrivesdk.Folder()
item = self.client.item(id=parent_id, path=parent_path)
return item.children.add(folder_to_create)
def saveFile(foldername, fileName, tt, client):
filp='%s.html'%fileName
with open(filp, 'w', encoding='utf-8') as file:
file.write(tt)
summary_id='ED1A0D88BB2A445F%218025'
fold_id=get_folder_id(client, foldername, summary_id)
if fold_id is None:
f = onedrivesdk.Folder()
i = onedrivesdk.Item()
i.name = foldername
i.folder = f
client.item(drive='me', id=summary_id).children.add(i)
fold_id = get_folder_id(client, foldername, summary_id)
client.item(drive='me', id=fold_id).children[filp].upload(filp)
os.remove(filp)
def refresh(self):
#Dropbox--------------------------------------------------
diccionarioDrop = clientDrop.account_info()
espDrop = diccionarioDrop.values(
)[10]['quota'] - diccionarioDrop.values()[10]['normal']
self.lblEspDrop["text"] = "Espacio en Dropbox: " + str(
espDrop) + " bytes"
self.cargarArchivosDrop()
#Google Drive--------------------------------------------------
espGoo = 0
file_list = drive.ListFile({
'q': "'root' in parents and trashed=false"
}).GetList()
for file2 in file_list:
espGoo += int(file2.metadata['quotaBytesUsed'])
self.lblEspGoo["text"] = "Espacio en Google Drive: " + str(
15 * 1024 * 1024 * 1024 - espGoo) + " bytes"
self.cargarArchivosDrive()
#OneDrive--------------------------------------------------
item = onedrivesdk.Item()
espOne = 0
for item in items:
espOne += int(item.size)
self.lblEspOne["text"] = "Espacio en OneDrive: " + str(
15 * 1024 * 1024 * 1024 - espOne) + " bytes"
self.cargarArchivosOne()
def mkdir(self, *paths):
created_dirs = []
for path in paths:
path = normpath(path)
base_path, folder_name = split(path)
id = self.find_item_id(base_path)
f = onedrivesdk.Folder()
i = onedrivesdk.Item()
i.name = folder_name
i.folder = f
dir = self.client.item(drive='me', id=id).children.add(i)
created_dirs.append(dir)
return created_dirs
def newfolder(self, name, parent, dirtrans):
dirtrans = self.checkparent(parent, dirtrans)
if parent == "/":
item = 'root'
else:
item = dirtrans[parent + "/"].id
f = onedrivesdk.Folder()
i = onedrivesdk.Item()
i.name = name
i.folder = f
returned_item = self.client.item(drive='me', id=item).children.add(i)
if parent == "/":
parent = ""
newfolder = parent + "/" + name
dirtrans[newfolder] = returned_item
print("newfoldermade", newfolder)
self.logger.add("new folder " + newfolder)
return dirtrans
def move_item(self,
item_id=None,
item_path=None,
parent_id=None,
parent_path=None):
"""
Move an item on OneDrive
:param item_id: str, the item to update
:param item_path: str
:param parent_id: str, new parent id
:param parent_path: str
:return: onedrivesdk.Item
"""
item, ref = self._init_item_to_update(item_id, item_path, parent_id,
parent_path)
updated_item = onedrivesdk.Item()
updated_item.parent_reference = ref
return item.update(updated_item)
client = onedrivesdk.get_default_client(client_id='4490f18b-5c69-4aa4-8694-b84f6e8d9a15',
scopes=['wl.signin',
'wl.offline_access',
'onedrive.readwrite'])
#print client.name
auth_url = client.auth_provider.get_auth_url(redirect_uri)
#this will block until we have the code
code = GetAuthCodeServer.get_auth_code(auth_url, redirect_uri)
client.auth_provider.authenticate(code, redirect_uri, client_secret)
items = client.item(id="root").children.get()
item=onedrivesdk.Item()
espOne=0
for item in items:
espOne+=int(item.size)
#--------------------------------------------------------------------
class Application(Frame):
def __init__(self,master):
Frame.__init__(self,master)
self.grid()
def new_folder(client,parent_id,folder_name):
f = onedrivesdk.Folder()
i = onedrivesdk.Item()
i.name = folder_name
i.folder = f
return client.item(drive='me', id=parent_id).children.add(i)
def create_folder(onedrive, parent_folder, folder_name):
f = onedrivesdk.Folder()
i = onedrivesdk.Item()
i.name = folder_name
i.folder = f
return onedrive.item(id=parent_folder.id).children.add(i)
def rename(client, item_id):
new_name = input("Enter new name: ")
renamed_item = onedrivesdk.Item()
renamed_item.name = new_name
renamed_item.id = item_id
client.item(id=item_id).update(renamed_item)
def renameFile(client, newName, fileId):
renamed_item = onedrivesdk.Item()
renamed_item.name = 'newName'
renamed_item.id = fileId
new_item = client.item(drive='me', id=renamed_item.id).update(renamed_item)
def onedrive_add_folder(client):
f = onedrivesdk.Folder()
i = onedrivesdk.Item()
i.name = 'New Folder'
i.folder = f
returned_item = client.item(drive='me', id='root').children.add(i)
def create_directory(self, name, parent_path):
f = onedrivesdk.Folder()
i = onedrivesdk.Item()
i.name = name
i.folder = f
self._client.item(drive='me', path=parent_path).children.add(i)
def addFolder(folderName, client):
f = onedrivesdk.Folder()
i = onedrivesdk.Item()
i.name = folderName
i.folder = f
returned_item = client.item(drive='me', id='root').children.add(i)
