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)