def setup(clazz, where, options=None):
check.check_string_seq(where)
check.check_file_duplicates_options(options, allow_none=True)
options = options or file_duplicates_options()
resolved_files = clazz._resolve_files(where, options)
return file_duplicates_setup(where, resolved_files, options)
def combine_info(clazz, files, options=None):
check.check_string_seq(files)
check.check_dir_combine_options(options, allow_none=True)
options = options or dir_combine_options()
if options.ignore_empty:
should_ignore = lambda d: not path.exists(d) or dir_util.is_empty(d
)
files = [f for f in files if not should_ignore(f)]
resolved_files = clazz._resolve_files(files, options.recursive)
if not resolved_files:
return clazz._combine_info_result(dir_operation_item_list(),
resolved_files)
destination_dir = options.destination_dir or resolved_files[0].dirname
destination_dir_abs = path.abspath(destination_dir)
items = dir_operation_item_list()
for resolved_file in resolved_files:
src_filename = resolved_file.filename_abs
if options.flatten:
src_basename = path.basename(src_filename)
else:
src_basename = resolved_file.filename
dst_filename = path.join(destination_dir_abs, src_basename)
item = dir_operation_item(src_filename, dst_filename)
items.append(item)
return clazz._combine_info_result(items, resolved_files)
def partition_info(clazz, files, options=None):
check.check_string_seq(files)
check.check_dir_partition_options(options, allow_none=True)
dst_dir_abs = path.abspath(options.dst_dir)
options = options or dir_partition_options()
clazz._log.log_d(f'options={options}')
if options.partition_type == None:
return items
elif options.partition_type == dir_partition_type.MEDIA_TYPE:
criteria = dir_partition_criteria_media_type()
result = clazz._partition_info_by_criteria(files, dst_dir_abs,
criteria, options)
elif options.partition_type == dir_partition_type.PREFIX:
criteria = dir_partition_criteria_prefix()
result = clazz._partition_info_by_criteria(files, dst_dir_abs,
criteria, options)
elif options.partition_type == dir_partition_type.CRITERIA:
result = clazz._partition_info_by_criteria(
files, dst_dir_abs, options.partition_criteria, options)
else:
raise RuntimeError(
f'Unkown partition type: {options.partition_type}')
return result
def run_script(clazz, script_name, args, options):
'Download and run a brew script with optional args.'
check.check_brew_installer_options(options)
check.check_string(script_name)
check.check_string_seq(args, allow_none=True)
if not shell.has_shell('/bin/bash'):
raise brew_error('/bin/bash is needed to run brew scripts.')
args = args or []
tmp_script = clazz.download_script(script_name)
sudo_options = sudo_cli_options()
sudo_options.error_message = clazz._SUDO_ERROR_MESSAGE
sudo_options.prompt = clazz._SUDO_PROMPT
sudo_options.password = options.password
clazz._log.log_d(
'run_script: calling sudo if needed: options={}'.format(options))
sudo.authenticate_if_needed(options=sudo_options)
cmd = ['/bin/bash', tmp_script] + args
clazz._log.log_d('run_script: script_name={} cmd={}'.format(
script_name, cmd))
env = os_env.make_clean_env()
env.update({
'CI': '1',
})
execute.execute(cmd,
shell=False,
env=env,
non_blocking=options.verbose)
def _call_softwareupdate(clazz, args, verbose):
check.check_string_seq(args)
check.check_bool(verbose)
command_line.check_args_type(args)
args = object_util.listify(args)
exe = which.which('softwareupdate')
if not exe:
raise softwareupdater_error('softwareupdate not found')
clazz._log.log_d('_call_softwareupdate: exe={} args={}'.format(
exe, args))
cmd = [exe] + args
env = os_env.clone_current_env()
rv = execute.execute(cmd,
env=env,
stderr_to_stdout=True,
raise_error=False,
non_blocking=verbose)
if rv.exit_code != 0:
cmd_flat = ' '.join(cmd)
msg = 'softwareupdate command failed: {} - {}\n{}'.format(
cmd, rv.exit_code, rv.stdout)
raise softwareupdater_error(msg, status_code=rv.exit_code)
return rv
def find_duplicates(clazz, where, options=None):
check.check_string_seq(where)
check.check_file_duplicates_options(options, allow_none=True)
options = options or file_duplicates_options()
setup = clazz.setup(where, options=options)
return clazz.find_duplicates_with_setup(setup)
def media_type_matches(clazz, filename, media_types):
filename = file_check.check_file(filename)
check.check_string_seq(media_types)
media_type = clazz.get_metadata(filename, 'media_type')
if not media_type:
return False
return media_type in media_types
def find_and_unsplit(clazz, files, options=None):
check.check_string_seq(files)
check.check_file_split_options(options, allow_none=True)
info = clazz.find_and_unsplit_info(files, options=options)
for item in info.items:
item_target = item.target
options.blurber.blurb_verbose(
f'Unsplitting {item_target} - {len(item.files)} parts.')
tmp = temp_file.make_temp_file(prefix=path.basename(item_target),
dir=path.dirname(item_target))
clazz.unsplit_files(tmp, item.files)
if options.unzip:
if archiver.is_valid(tmp):
members = archiver.members(tmp)
num_members = len(members)
if num_members != 1:
options.blurber.blurb(
f'{item_target} archive should have exactly 1 member instead of {num_members}'
)
else:
archive_filename = members[0]
archive_tmp_dir = temp_file.make_temp_dir(
prefix=path.basename(archive_filename),
dir=path.dirname(item_target),
delete=False)
archiver.extract_all(tmp, archive_tmp_dir)
archive_tmp_file = path.join(archive_tmp_dir,
archive_filename)
assert path.exists(archive_tmp_file)
file_util.rename(archive_tmp_file, tmp)
file_util.remove(archive_tmp_dir)
item_target = path.join(path.dirname(item_target),
archive_filename)
target = None
if path.exists(item_target):
if file_util.files_are_the_same(tmp, item_target):
options.blurber.blurb(
f'{item_target} already exists and is the same')
file_util.remove(tmp)
else:
ts = time_util.timestamp(
delimiter='',
milliseconds=False,
when=options.existing_file_timestamp)
target = clazz._make_timestamp_filename(item_target, ts)
options.blurber.blurb(
f'{item_target} already exists but is different. Renaming to {target}'
)
else:
target = item_target
if target:
file_util.rename(tmp, target)
file_util.remove(item.files)
def run_script(self, script_name, args, print_only):
check.check_string(script_name)
check.check_string_seq(args, allow_none = True)
check.check_bool(print_only)
if print_only:
tmp = brew_installer.download_script(script_name)
file_util.page(tmp)
return 0
brew_installer.run_script(script_name, args, self.options)
return 0
def combine(clazz, files, options=None):
check.check_string_seq(files)
check.check_dir_combine_options(options, allow_none=True)
options = options or dir_combine_options()
info = clazz.combine_info(files, options=options)
info.items.move_files(options.dup_file_timestamp,
options.dup_file_count)
root_dirs = info.resolved_files.root_dirs()
for next_possible_empty_root in root_dirs:
file_find.remove_empty_dirs(next_possible_empty_root)
def partition(clazz, files, options=None):
check.check_string_seq(files)
check.check_dir_partition_options(options, allow_none=True)
options = options or dir_partition_options()
info = clazz.partition_info(files, options=options)
info.items.move_files(options.dup_file_timestamp,
options.dup_file_count)
if options.delete_empty_dirs:
clazz._log.log_d(f'resolved_files={info.resolved_files}')
root_dirs = info.resolved_files.root_dirs()
clazz._log.log_d(f'root_dirs={root_dirs}')
for next_possible_empty_root in root_dirs:
file_find.remove_empty_dirs(next_possible_empty_root)
def __new__(clazz, name, unixpath, pythonpath, requires, variables):
check.check_string(name)
unixpath = unixpath or []
if check.is_string(unixpath):
unixpath = unixpath.split(':')
check.check_string_seq(unixpath)
pythonpath = pythonpath or []
if check.is_string(pythonpath):
pythonpath = pythonpath.split(':')
check.check_string_seq(pythonpath)
requires = requires or set()
check.check_set(requires)
unixpath = [file_path.normalize_sep(p) for p in unixpath]
pythonpath = [file_path.normalize_sep(p) for p in pythonpath]
return clazz.__bases__[0].__new__(clazz, name, unixpath, pythonpath,
requires, variables)
def find_and_unsplit_info(clazz, files, options=None):
check.check_string_seq(files)
check.check_file_split_options(options, allow_none=True)
options = options or file_split_options()
resolver_options = file_resolver_options(
recursive=options.recursive,
match_basename=True,
match_function=clazz._match_unsplit_files)
resolved_files = file_resolver.resolve_files(files,
options=resolver_options)
items = []
for f in resolved_files:
item = clazz._unsplit_one_info(f.filename_abs, options)
if item:
items.append(item)
return clazz._split_result(items, resolved_files)
def call_pkgutil(clazz, args, msg=None, use_sudo=False):
check.check_string_seq(args)
check.check_string(msg, allow_none=True)
check.check_bool(use_sudo)
env = os_env.clone_current_env(d={})
rv = pkgutil_command.call_command(args,
raise_error=False,
env=env,
use_sudo=use_sudo)
if rv.exit_code != 0:
if not msg:
cmd_flat = ' '.join(args)
msg = 'pkgutil command failed: {}\n{}'.format(
cmd_flat, rv.stdout)
raise pkgutil_error(msg)
return rv
def run(self, cmd):
check.check_string_seq(cmd)
sudo.call_sudo(cmd, self.options)
return 0
def test_string_seq(self):
C.check_string_seq(['x'])
with self.assertRaises(TypeError) as context:
C.check_string_seq(6)
C.check_string(6)
