cmd/rarpar.py

457 lines
12 KiB
Python
Raw Normal View History

2020-03-13 21:59:49 +00:00
import argparse
import os
import re
import send2trash
2020-03-13 21:59:49 +00:00
import shutil
import subprocess
2020-03-13 21:59:49 +00:00
import sys
import time
from voussoirkit import betterhelp
from voussoirkit import bytestring
from voussoirkit import pathclass
from voussoirkit import winglob
from voussoirkit import winwhich
WINRAR = winwhich.which('winrar')
PAR2 = winwhich.which('phpar2')
2020-03-13 21:59:49 +00:00
RESERVE_SPACE_ON_DRIVE = 30 * bytestring.GIBIBYTE
class RarParException(Exception):
pass
2020-11-06 08:20:20 +00:00
class RarExists(RarParException):
pass
class NotEnoughSpace(RarParException):
pass
2020-03-13 21:59:49 +00:00
def RARCOMMAND(
path,
2020-03-13 21:59:49 +00:00
basename,
workdir,
compression=None,
2020-03-13 21:59:49 +00:00
password=None,
profile=None,
2020-03-13 21:59:49 +00:00
rec=None,
rev=None,
volume=None,
):
'''
winrar
a = make archive
-cp{profile} = use compression profile. this must come first so that
all subsequent options override the ones provided by
the profile.
2020-03-13 21:59:49 +00:00
-ibck = run in the background
-ma = rar5 mode
-m{compression} = 0: store, 5: max
2020-03-13 21:59:49 +00:00
-mt1 = thread count: 1
-v{x}M = split into x megabyte volumes
-ri x:y = x priority (lower is less pri) y ms sleep between ops
-r = include subdirectories
-ep1 = arcnames will start relative to the main folder,
instead of having the whole abspath of the input_pattern.
-rr{x}% = x% recovery record
-rv{x}% = x% recovery volumes
-hp{x} = encrypt with password x
-y = yes on all prompts
-x = exclude certain filenames
destination
workdir/basename.rar
files to include
input_pattern
'''
command = [WINRAR, 'a']
if profile is not None:
command.append(f'-cp{profile}')
command.extend([
'-ibck', '-ma', '-mt1', '-ri1:30', '-ep1',
'-y', '-xthumbs.db', '-xdesktop.ini',
])
if compression is not None:
command.append(f'-m{compression}')
2020-03-13 21:59:49 +00:00
if volume is not None:
command.append(f'-v{volume}M')
if rec is not None:
command.append(f'-rr{rec}%')
if rev is not None:
command.append(f'-rv{rev}%')
if password is not None:
command.append(f'-hp{password}')
if path.is_dir:
command.append('-r')
if path.is_dir:
input_pattern = path.absolute_path + '\\*'
else:
input_pattern = path.absolute_path
command.append(f'{workdir.absolute_path}{os.sep}{basename}.rar')
command.append(f'{input_pattern}')
2020-03-13 21:59:49 +00:00
return command
def PARCOMMAND(workdir, basename, par):
'''
phpar2
c = create pars
-t1 = thread count: 1
-r{x} = x% recovery
destination
workdir/basename.par2
'''
command = [
PAR2,
'c', '-t1',
2020-03-13 21:59:49 +00:00
f'-r{par}',
f'{workdir.absolute_path}{os.sep}{basename}',
f'{workdir.absolute_path}{os.sep}{basename}*.rar',
2020-03-13 21:59:49 +00:00
]
return command
def assert_enough_space(pathsize, workdir, moveto, rec, rev, par):
plus_percent = (rec + rev + par) / 100
needed = pathsize * (1 + plus_percent)
reserve = RESERVE_SPACE_ON_DRIVE + needed
workdir_drive = os.path.splitdrive(workdir.absolute_path)[0] + os.sep
2020-03-13 21:59:49 +00:00
free_space = shutil.disk_usage(workdir_drive).free
if moveto is not None:
moveto_drive = os.path.splitdrive(moveto.absolute_path)[0]
moveto_drive = pathclass.Path(moveto_drive)
free_space = min(free_space, shutil.disk_usage(moveto_drive.absolute_path).free)
2020-03-13 21:59:49 +00:00
message = ' '.join([
f'For {bytestring.bytestring(pathsize)},',
f'Reserving {bytestring.bytestring(reserve)} /',
f'{bytestring.bytestring(free_space)}.',
])
print(message)
if reserve > free_space:
raise NotEnoughSpace('Please leave more space')
2020-03-13 21:59:49 +00:00
def move(pattern, directory):
files = winglob.glob(pattern)
for file in files:
print(file)
shutil.move(file, directory)
def _normalize_percentage(rec):
if rec is None:
return None
if rec == 0:
return None
if isinstance(rec, str):
rec = rec.strip('%')
rec = int(rec)
if not (0 <= rec <= 100):
raise ValueError(f'rec, rev, par {rec} must be 0-100.')
return rec
def normalize_password(password):
if password is None:
return None
if not isinstance(password, str):
raise TypeError(f'password must be a {str}, not {type(password)}')
if password == '':
return None
return password
def _normalize_volume(volume, pathsize):
if volume is None:
return None
if isinstance(volume, int):
return volume
if isinstance(volume, float):
return int(volume)
if isinstance(volume, str):
volume = volume.strip()
if volume == '100%':
return None
minmax_parts = re.findall(r'(min|max)\((.+?), (.+?)\)', volume)
if minmax_parts:
(func, left, right) = minmax_parts[0]
func = {'min': min, 'max': max}[func]
left = _normalize_volume(left, pathsize=pathsize)
right = _normalize_volume(right, pathsize=pathsize)
return func(left, right)
if volume.endswith('%'):
volume = volume[:-1]
volume = float(volume) / 100
volume = (pathsize * volume) / bytestring.MIBIBYTE
volume = max(1, volume)
return int(volume)
return int(volume)
raise TypeError(f'Invalid volume {type(volume)}.')
def normalize_volume(volume, pathsize):
volume = _normalize_volume(volume, pathsize)
if volume is not None and volume < 1:
raise ValueError('Volume must be >= 1.')
return volume
def run_script(script, dry=False):
'''
`script` can be a list of strings, which are command line commands, or
callable Python functions. They will be run in order, and the sequence
will terminate if any step returns a bad status code. Your Python functions
must return either 0 or None to be considered successful, all other return
values will be considered failures.
'''
2020-03-13 21:59:49 +00:00
status = 0
if dry:
for command in script:
print(command)
return status
for command in script:
print(command)
if isinstance(command, str):
status = os.system(command)
elif isinstance(command, list):
# sys.stdout is None indicates pythonw.
creationflags = subprocess.CREATE_NO_WINDOW if sys.stdout is None else 0
status = subprocess.run(command, creationflags=creationflags).returncode
2020-03-13 21:59:49 +00:00
else:
status = command()
if status not in [0, None]:
2020-08-24 05:18:10 +00:00
print('!!!! error status:', status)
2020-03-13 21:59:49 +00:00
break
return status
def rarpar(
path,
*,
basename=None,
compression=None,
2020-03-13 21:59:49 +00:00
dry=False,
moveto=None,
par=None,
password=None,
rar_profile=None,
recycle_original=False,
2020-03-13 21:59:49 +00:00
rec=None,
rev=None,
volume=None,
workdir='.',
):
path = pathclass.Path(path)
path.assert_exists()
workdir = pathclass.Path(workdir)
workdir.assert_is_directory()
if moveto:
moveto = pathclass.Path(moveto)
moveto.assert_is_directory()
pathsize = path.size
volume = normalize_volume(volume, pathsize)
rec = _normalize_percentage(rec)
rev = _normalize_percentage(rev)
par = _normalize_percentage(par)
if RESERVE_SPACE_ON_DRIVE:
assert_enough_space(
pathsize,
workdir=workdir,
moveto=moveto,
rec=rec or 0,
rev=rev or 0,
par=par or 0,
)
timestamp = time.strftime('%Y-%m-%d')
if not basename:
basename = f'{path.basename} ({timestamp})'
else:
basename = basename.format(timestamp=timestamp)
existing = None
if workdir:
existing = existing or workdir.glob(f'{basename}*.rar')
if moveto:
existing = existing or moveto.glob(f'{basename}*.rar')
2020-03-13 21:59:49 +00:00
if existing:
2020-11-06 08:20:20 +00:00
raise RarExists(f'{existing[0]} already exists.')
2020-03-13 21:59:49 +00:00
#### ####
script = []
rarcommand = RARCOMMAND(
path=path,
2020-03-13 21:59:49 +00:00
basename=basename,
compression=compression,
2020-03-13 21:59:49 +00:00
password=password,
profile=rar_profile,
2020-03-13 21:59:49 +00:00
rec=rec,
rev=rev,
volume=volume,
workdir=workdir,
)
script.append(rarcommand)
if par:
parcommand = PARCOMMAND(
basename=basename,
par=par,
workdir=workdir,
)
script.append(parcommand)
def move_rars():
move(f'{workdir.absolute_path}\\{basename}*.rar', f'{moveto.absolute_path}')
def move_revs():
move(f'{workdir.absolute_path}\\{basename}*.rev', f'{moveto.absolute_path}')
def move_pars():
move(f'{workdir.absolute_path}\\{basename}*.par2', f'{moveto.absolute_path}')
if moveto:
if True:
script.append(move_rars)
if rev:
script.append(move_revs)
if par:
script.append(move_pars)
def recycle():
send2trash.send2trash(path.absolute_path)
if recycle_original:
script.append(recycle)
2020-03-13 21:59:49 +00:00
#### ####
status = run_script(script, dry)
return status
# COMMAND LINE #####################################################################################
2020-03-13 21:59:49 +00:00
DOCSTRING = '''
rarpar
======
> rarpar path <flags>
2020-03-13 21:59:49 +00:00
path:
The input file or directory to rarpar.
--volume X | X% | min(A, B) | max(A, B):
2020-03-13 21:59:49 +00:00
Split rars into volumes of this many megabytes. Should be
An integer number of megabytes, or;
A percentage "X%" to calculate volumes as X% of the file size, down to
a 1 MB minimum, or;
A string "min(A, B)" or "max(A, B)" where A and B follow the above rules.
--rec X:
2020-03-13 21:59:49 +00:00
A integer to generate X% recovery record in the rars.
See winrar documentation for information about recovery records.
--rev X:
2020-03-13 21:59:49 +00:00
A integer to generate X% recovery volumes.
Note that winrar's behavior is the number of revs will always be less than
the number of rars. If you don't split volumes, you will have 1 rar and
thus 0 revs even if you ask for 100% rev.
See winrar documentation for information about recovery volumes.
--par X:
2020-03-13 21:59:49 +00:00
A number to generate X% recovery with par2.
--basename X:
2020-03-13 21:59:49 +00:00
A basename for the rar and par files. You will end up with
basename.partXX.rar and basename.par2.
Without this argument, the default basename is "basename ({timestamp})".
Your string may include {timestamp} including the braces to get the
timestamp there.
--password X:
2020-03-13 21:59:49 +00:00
A password with which to encrypt the rar files.
--workdir X:
2020-03-13 21:59:49 +00:00
The directory in which the rars and pars will be generated while the
program is working.
--moveto X:
2020-03-13 21:59:49 +00:00
The directory to which the rars and pars will be moved after the program
has finished working.
--recycle:
The input file or directory will be recycled at the end.
2020-03-13 21:59:49 +00:00
--dry:
Print the commands that will be run, but don't actually run them.
'''
def rarpar_argparse(args):
return rarpar(
path=args.path,
volume=args.volume,
basename=args.basename,
dry=args.dry,
moveto=args.moveto,
par=args.par,
password=args.password,
rar_profile=args.rar_profile,
rec=args.rec,
rev=args.rev,
recycle_original=args.recycle_original,
workdir=args.workdir,
)
2020-03-13 21:59:49 +00:00
def main(argv):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('path')
parser.add_argument('--volume', dest='volume')
parser.add_argument('--rec', dest='rec')
parser.add_argument('--rev', dest='rev')
parser.add_argument('--par', dest='par')
parser.add_argument('--basename', dest='basename')
parser.add_argument('--password', dest='password')
parser.add_argument('--profile', dest='rar_profile')
2020-03-13 21:59:49 +00:00
parser.add_argument('--workdir', dest='workdir', default='.')
parser.add_argument('--moveto', dest='moveto')
parser.add_argument('--recycle', dest='recycle_original', action='store_true')
2020-03-13 21:59:49 +00:00
parser.add_argument('--dry', dest='dry', action='store_true')
parser.set_defaults(func=rarpar_argparse)
return betterhelp.single_main(argv, parser, DOCSTRING)
if __name__ == '__main__':
raise SystemExit(main(sys.argv[1:]))