def play(
api: BaiduPCSApi,
remotepaths: List[str],
sifters: List[Sifter] = [],
recursive: bool = False,
from_index: int = 0,
player: Player = DEFAULT_PLAYER,
player_params: List[str] = [],
m3u8: bool = False,
quiet: bool = False,
shuffle: bool = False,
ignore_ext: bool = False,
out_cmd: bool = False,
local_server: str = "",
):
"""Play media file in `remotepaths`
Args:
`from_index` (int): The start index of playing entries from EACH remote directory
"""
if shuffle:
rg = random.Random(time.time())
rg.shuffle(remotepaths)
for rp in remotepaths:
if not api.exists(rp):
print(f"[yellow]WARNING[/yellow]: `{rp}` does not exist.")
continue
if api.is_file(rp):
play_file(
api,
rp,
player=player,
player_params=player_params,
m3u8=m3u8,
quiet=quiet,
ignore_ext=ignore_ext,
out_cmd=out_cmd,
local_server=local_server,
)
else:
play_dir(
api,
rp,
sifters=sifters,
recursive=recursive,
from_index=from_index,
player=player,
player_params=player_params,
m3u8=m3u8,
quiet=quiet,
shuffle=shuffle,
ignore_ext=ignore_ext,
out_cmd=out_cmd,
local_server=local_server,
)
def download(
api: BaiduPCSApi,
remotepaths: List[str],
localdir: str,
sifters: List[Sifter] = [],
recursive: bool = False,
from_index: int = 0,
downloader: Downloader = DEFAULT_DOWNLOADER,
downloadparams: DownloadParams = DEFAULT_DOWNLOADPARAMS,
out_cmd: bool = False,
):
"""Download `remotepaths` to the `localdir`
Args:
`from_index` (int): The start index of downloading entries from EACH remote directory
"""
remotepaths = sift(remotepaths, sifters)
for rp in remotepaths:
if not api.exists(rp):
print(f"[yellow]WARNING[/yellow]: `{rp}` does not exist.")
continue
if api.is_file(rp):
download_file(
api,
rp,
localdir,
downloader=downloader,
downloadparams=downloadparams,
out_cmd=out_cmd,
)
else:
_localdir = str(Path(localdir) / os.path.basename(rp))
download_dir(
api,
rp,
_localdir,
sifters=sifters,
recursive=recursive,
from_index=from_index,
downloader=downloader,
downloadparams=downloadparams,
out_cmd=out_cmd,
)
if downloader == Downloader.me:
MeDownloader._exit_executor()
_progress.stop()
def play(
api: BaiduPCSApi,
remotepaths: List[str],
sifters: List[Sifter] = [],
recursive: bool = False,
from_index: int = 0,
player: Player = DEFAULT_PLAYER,
player_params: List[str] = [],
m3u8: bool = False,
quiet: bool = False,
out_cmd: bool = False,
):
"""Play media file in `remotepaths`
Args:
`from_index` (int): The start index of playing entries from EACH remote directory
"""
for rp in remotepaths:
if not api.exists(rp):
print(f"[yellow]WARNING[/yellow]: `{rp}` does not exist.")
continue
if api.is_file(rp):
play_file(
api,
rp,
player=player,
player_params=player_params,
m3u8=m3u8,
quiet=quiet,
out_cmd=out_cmd,
)
else:
play_dir(
api,
rp,
sifters=sifters,
recursive=recursive,
from_index=from_index,
player=player,
player_params=player_params,
m3u8=m3u8,
quiet=quiet,
out_cmd=out_cmd,
)
def sync(
api: BaiduPCSApi,
localdir: str,
remotedir: str,
encrypt_key: Any = None,
salt: Any = None,
encrypt_type: EncryptType = EncryptType.No,
max_workers: int = CPU_NUM,
slice_size: int = DEFAULT_SLICE_SIZE,
show_progress: bool = True,
):
localdir = Path(localdir).as_posix()
remotedir = Path(remotedir).as_posix()
is_file = api.is_file(remotedir)
assert not is_file, "remotedir must be a directory"
if not api.exists(remotedir):
all_pcs_files = {}
else:
all_pcs_files = {
pcs_file.path[len(remotedir) + 1:]: pcs_file
for pcs_file in recursive_list(api, remotedir)
}
fts: List[FromTo] = []
check_list: List[Tuple[str, PcsFile]] = []
all_localpaths = set()
for localpath in walk(localdir):
path = localpath[len(localdir) + 1:]
all_localpaths.add(path)
if path not in all_pcs_files:
fts.append(FromTo(localpath, join_path(remotedir, path)))
else:
check_list.append((localpath, all_pcs_files[path]))
semaphore = Semaphore(max_workers)
with ThreadPoolExecutor(max_workers=CPU_NUM) as executor:
tasks = {}
for lp, pf in check_list:
semaphore.acquire()
fut = executor.submit(sure_release, semaphore, check_file_md5, lp,
pf)
tasks[fut] = (lp, pf)
for fut in as_completed(tasks):
is_equal = fut.result()
lp, pf = tasks[fut]
if not is_equal:
fts.append(FromTo(lp, pf.path))
_upload(
api,
fts,
encrypt_key=encrypt_key,
salt=salt,
encrypt_type=encrypt_type,
max_workers=max_workers,
slice_size=slice_size,
ignore_existing=False,
show_progress=show_progress,
)
to_deletes = []
for rp in all_pcs_files.keys():
if rp not in all_localpaths:
to_deletes.append(all_pcs_files[rp].path)
if to_deletes:
api.remove(*to_deletes)
print(f"Delete: [i]{len(to_deletes)}[/i] remote paths")
def sync(
api: BaiduPCSApi,
localdir: str,
remotedir: str,
encrypt_password: bytes = b"",
encrypt_type: EncryptType = EncryptType.No,
max_workers: int = CPU_NUM,
slice_size: int = DEFAULT_SLICE_SIZE,
show_progress: bool = True,
rapiduploadinfo_file: Optional[str] = None,
user_id: Optional[int] = None,
user_name: Optional[str] = None,
check_md5: bool = False,
):
localdir = Path(localdir).as_posix()
remotedir = Path(remotedir).as_posix()
is_file = api.is_file(remotedir)
assert not is_file, "remotedir must be a directory"
if not api.exists(remotedir):
all_pcs_files = {}
else:
all_pcs_files = {
pcs_file.path[len(remotedir) + 1 :]: pcs_file
for pcs_file in recursive_list(api, remotedir)
}
fts: List[FromTo] = []
check_list: List[Tuple[str, PcsFile]] = []
all_localpaths = set()
for localpath in walk(localdir):
path = localpath[len(localdir) + 1 :]
all_localpaths.add(path)
if path not in all_pcs_files:
fts.append(FromTo(localpath, join_path(remotedir, path)))
else:
check_list.append((localpath, all_pcs_files[path]))
for lp, pf in check_list:
lstat = Path(lp).stat()
if int(lstat.st_mtime) != pf.local_mtime or lstat.st_size != pf.size:
fts.append(FromTo(lp, pf.path))
to_deletes = []
for rp in all_pcs_files.keys():
if rp not in all_localpaths:
to_deletes.append(all_pcs_files[rp].path)
logger.debug(
"`sync`: all localpaths: %s, "
"localpaths needed to upload: %s, "
"remotepaths needed to delete: %s",
len(all_localpaths),
len(fts),
len(to_deletes),
)
# The md5 of remote file is incorrect at most time, so we don't compare md5
#
# # Compare localpath content md5 with remotepath content md5
# semaphore = Semaphore(max_workers)
# with ThreadPoolExecutor(max_workers=CPU_NUM) as executor:
# tasks = {}
# for lp, pf in check_list:
# semaphore.acquire()
# fut = executor.submit(sure_release, semaphore, check_file_md5, lp, pf)
# tasks[fut] = (lp, pf)
#
# for fut in as_completed(tasks):
# is_equal = fut.result()
# lp, pf = tasks[fut]
# if not is_equal:
# fts.append(FromTo(lp, pf.path))
_upload(
api,
fts,
encrypt_password=encrypt_password,
encrypt_type=encrypt_type,
max_workers=max_workers,
slice_size=slice_size,
ignore_existing=False,
show_progress=show_progress,
rapiduploadinfo_file=rapiduploadinfo_file,
user_id=user_id,
user_name=user_name,
check_md5=check_md5,
)
if to_deletes:
api.remove(*to_deletes)
print(f"Delete: [i]{len(to_deletes)}[/i] remote paths")
def download(
api: BaiduPCSApi,
remotepaths: List[str],
localdir: str,
sifters: List[Sifter] = [],
recursive: bool = False,
from_index: int = 0,
downloader: Downloader = DEFAULT_DOWNLOADER,
downloadparams: DownloadParams = DEFAULT_DOWNLOADPARAMS,
out_cmd: bool = False,
encrypt_password: bytes = b"",
):
"""Download `remotepaths` to the `localdir`
Args:
`from_index` (int): The start index of downloading entries from EACH remote directory
"""
logger.debug(
"`download`: sifters: %s, recursive: %s, from_index: %s, "
"downloader: %s, downloadparams: %s, out_cmd: %s, has encrypt_password: %s",
sifters,
recursive,
from_index,
downloader,
downloadparams,
out_cmd,
bool(encrypt_password),
)
logger.debug(
"`download`: remotepaths should be uniq %s == %s",
len(remotepaths),
len(set(remotepaths)),
)
assert (
human_size_to_int(downloadparams.chunk_size) <= MAX_CHUNK_SIZE
), f"`chunk_size` must be less or equal then {human_size(MAX_CHUNK_SIZE)}"
for rp in remotepaths:
if not api.exists(rp):
print(f"[yellow]WARNING[/yellow]: `{rp}` does not exist.")
continue
if api.is_file(rp):
download_file(
api,
rp,
localdir,
downloader=downloader,
downloadparams=downloadparams,
out_cmd=out_cmd,
encrypt_password=encrypt_password,
)
else:
_localdir = str(Path(localdir) / os.path.basename(rp))
download_dir(
api,
rp,
_localdir,
sifters=sifters,
recursive=recursive,
from_index=from_index,
downloader=downloader,
downloadparams=downloadparams,
out_cmd=out_cmd,
encrypt_password=encrypt_password,
)
if downloader == Downloader.me:
MeDownloader._exit_executor()
_progress.stop()
def download(
api: BaiduPCSApi,
remotepaths: List[str],
localdir: str,
sifters: List[Sifter] = [],
recursive: bool = False,
from_index: int = 0,
downloader: Downloader = DEFAULT_DOWNLOADER,
downloadparams: DownloadParams = DEFAULT_DOWNLOADPARAMS,
out_cmd: bool = False,
encrypt_key: Optional[str] = None,
):
"""Download `remotepaths` to the `localdir`
Args:
`from_index` (int): The start index of downloading entries from EACH remote directory
"""
logger.debug(
"`download`: sifters: %s, recursive: %s, from_index: %s, "
"downloader: %s, downloadparams: %s, out_cmd: %s, has encrypt_key: %s",
sifters,
recursive,
from_index,
downloader,
downloadparams,
out_cmd,
bool(encrypt_key),
)
logger.debug(
"`download`: remotepaths should be uniq %s == %s",
len(remotepaths),
len(set(remotepaths)),
)
remotepaths = sift(remotepaths, sifters)
for rp in remotepaths:
if not api.exists(rp):
print(f"[yellow]WARNING[/yellow]: `{rp}` does not exist.")
continue
if api.is_file(rp):
download_file(
api,
rp,
localdir,
downloader=downloader,
downloadparams=downloadparams,
out_cmd=out_cmd,
encrypt_key=encrypt_key,
)
else:
_localdir = str(Path(localdir) / os.path.basename(rp))
download_dir(
api,
rp,
_localdir,
sifters=sifters,
recursive=recursive,
from_index=from_index,
downloader=downloader,
downloadparams=downloadparams,
out_cmd=out_cmd,
encrypt_key=encrypt_key,
)
if downloader == Downloader.me:
MeDownloader._exit_executor()
_progress.stop()
