def find_all_generator(clazz, text, sub_string, word_boundary=False, word_boundary_chars=None): check.check_string(text) check.check_string(sub_string) check.check_bool(word_boundary) check.check_set(word_boundary_chars, allow_none=True) word_boundary_chars = word_boundary_chars or word_boundary_module.CHARS sub_string_length = len(sub_string) i = 0 while True: i = text.find(sub_string, i) if i < 0: return start = i end = i + sub_string_length - 1 i += sub_string_length if word_boundary: assert word_boundary_chars do_yield = word_boundary_module.word_has_boundary( text, start, end, boundary_chars=word_boundary_chars) else: do_yield = True if do_yield: yield clazz._span(start, end)
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 check_value_types(self): 'Check the type of each option.' super(_test_cli_options_subclass, self).check_value_types() check.check_bool(self.sub_can_do) check.check_string(self.sub_fruit) check.check_string(self.sub_username, allow_none=True) check.check_string(self.sub_password, allow_none=True)
def get_value(clazz, filename, key, fallback=False, cached=False): check.check_string(filename) check.check_string(key) check.check_bool(fallback) check.check_bool(cached) if not key in clazz._getters: raise KeyError(f'No getter registered for: \"{key}\"') getter_item = clazz._getters[key] if cached: cache_key = clazz._make_cache_key(filename) if not cache_key in getter_item.cache: value = clazz.get_value(filename, key, fallback=fallback, cached=False) getter_item.cache[cache_key] = value return getter_item.cache[cache_key] def _value_maker(f): return getter_item.getter.get_value(clazz, f) value = clazz.get_bytes(filename, key, _value_maker, fallback=fallback) if value == None: return None return getter_item.getter.decode_value(value)
def replace(clazz, filename, replacements, backup=True, word_boundary=False, word_boundary_chars=None): check.check_string(filename) check.check_dict(replacements, check.STRING_TYPES, check.STRING_TYPES) check.check_bool(backup) check.check_bool(word_boundary) check.check_set(word_boundary_chars, allow_none=True) content = file_util.read(filename, codec='utf-8') new_content = text_replace.replace( content, replacements, word_boundary=word_boundary, word_boundary_chars=word_boundary_chars) if content == new_content: return False if backup: file_util.backup(filename) file_util.save(filename, content=new_content.encode('utf-8'), mode=file_util.mode(filename)) return True
def replace_all(clazz, text, src_string, dst_string, word_boundary=False, word_boundary_chars=None): 'Replace src_string with dst_string optionally respecting word boundaries.' check.check_string(text) check.check_string(src_string) check.check_string(dst_string) check.check_bool(word_boundary) check.check_set(word_boundary_chars, allow_none=True) spans = clazz.find_all(text, src_string, word_boundary=word_boundary, word_boundary_chars=word_boundary_chars) if not spans: return text last_start = 0 buf = StringIO() last_span = None for span in spans: left = text[last_start:span.start] if left: buf.write(left) buf.write(dst_string) last_start = span.end + 1 last_span = span if last_span: right = text[last_span.end + 1:] buf.write(right) return buf.getvalue()
def _command_foo(self, address, version, debug, verbose): check.check_string(address) check.check_string(version) check.check_bool(debug) check.check_bool(verbose) print('foo:%s:%s:%s:%s' % (address, version, int(debug), int(verbose))) return 0
def __init__(self, *args, **kargs): self.verbose = False self.blurber = blurber() for key, value in kargs.items(): setattr(self, key, value) check.check_bool(self.verbose) check.check_blurber(self.blurber)
def reindent_files(clazz, files, indent, backup): check.check_int(indent) check.check_bool(backup) clazz._log.log_method_d() python_files = clazz.resolve_python_files(files) for filename in python_files: refactor_reindent.reindent_file(filename, indent, backup)
def check_value_types(self): 'Check the type of each option.' check.check_bool(self.verbose) check.check_bool(self.debug) check.check_string(self.username, allow_none=True) check.check_string(self.password, allow_none=True) check.check_int(self.port, allow_none=True) check.check_int(self.num_tries) check.check_float(self.sleep_time)
def __init__(self, *args, **kargs): self.verbose = False self.password = None self.blurber = blurber() for key, value in kargs.items(): setattr(self, key, value) check.check_bool(self.verbose) check.check_string(self.password, allow_none=True) check.check_blurber(self.blurber)
def get_string(clazz, filename, key, value_maker, fallback=False): check.check_string(filename) check.check_string(key) check.check_callable(value_maker) check.check_bool(fallback) value = clazz.get_bytes(filename, key, value_maker, fallback=fallback) if value == None: return None return value.decode('utf-8')
def get_bool(clazz, filename, key, value_maker, fallback=False): check.check_string(filename) check.check_string(key) check.check_callable(value_maker) check.check_bool(fallback) value = clazz.get_string(filename, key, value_maker, fallback=fallback) if value == None: return None return bool_util.parse_bool(value)
def reindent_file(clazz, filename, indent, backup): check.check_string(filename) check.check_int(indent) check.check_bool(backup) file_check.check_file(filename) clazz._log.log_method_d() backup_args = [] if backup else ['--nobackup'] args = ['--indent', str(indent)] + backup_args + [filename] reindent_main(args)
def copy(clazz, files, src_pattern, dst_pattern, copy_dirs, options = None): check.check_string(src_pattern) check.check_string(dst_pattern) check.check_refactor_options(options, allow_none = True) check.check_bool(copy_dirs) clazz._log.log_method_d() copied_items = refactor_files.copy_files(files, src_pattern, dst_pattern, copy_dirs, options = options) copied_files = sorted([ item.dst for item in copied_items ]) clazz.replace_text(copied_files, src_pattern, dst_pattern, options = options)
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 files(self, package_name, print_inode): check.check_string(package_name) check.check_bool(print_inode) files = self._brew.files(package_name) for f in files: if print_inode: inode = '{} '.format(file_util.inode_number(f)) else: inode = '' print('{}{}'.format(inode, f)) return 0
def install(self, label, verbose): 'Install an item by label.' check.check_string(label) check.check_bool(verbose) args = [ '--verbose', '--install', #'--agree-to-license', # big sur only '"{}"'.format(label), ] self._call_softwareupdate(args, verbose)
def call_handle(clazz, args, raise_error=True): command_line.check_args_type(args) check.check_bool(raise_error) if isinstance(args, (list, tuple)): parsed_args = list(args) else: parsed_args = command_line.parse_args(args) handle_exe = clazz._find_handle_exe() cmd = [handle_exe, '-nobanner'] + args return execute.execute(cmd, raise_error=raise_error)
def save_file(clazz, filename, o, indent=None, sort_keys=False, codec=None): check.check_string(filename) check.check_int(indent, allow_none=True) check.check_bool(sort_keys) check.check_string(codec, allow_none=True) content = clazz.to_json(o, indent=indent, sort_keys=sort_keys) codec = codec or 'utf-8' with open(filename, 'w', encoding=codec) as f: f.write(content)
def copy_files(clazz, files, src_pattern, dst_pattern, copy_dirs, options=None): check.check_string(src_pattern) check.check_string(dst_pattern) check.check_refactor_options(options, allow_none=True) check.check_bool(copy_dirs) clazz._log.log_method_d() options = options or refactor_options() return clazz._do_operation(refactor_operation_type.COPY_FILES, files, src_pattern, dst_pattern, copy_dirs, options)
def to_json(clazz, o, indent=None, sort_keys=False): check.check_int(indent, allow_none=True) check.check_bool(sort_keys) ''' Like json.dumps plus the following: - same white space results on both python 2 and 3 - __dict__ is used when object is not json encodable ''' def default(o): return o.__dict__ return json.dumps(o, indent=indent, default=default, sort_keys=sort_keys, separators=(', ', ': '))
def __init__(self, *args, **kargs): self.verbose = False self.password = None self.blurber = blurber() self.working_dir = tempfile.gettempdir() self.prompt = 'sudo password: ' self.force_auth = False self.error_message = None for key, value in kargs.items(): setattr(self, key, value) check.check_bool(self.verbose) check.check_string(self.password, allow_none=True) check.check_blurber(self.blurber) check.check_string(self.working_dir, allow_none=True) check.check_string(self.prompt, allow_none=True) check.check_bool(self.force_auth) check.check_string(self.error_message, allow_none=True)
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 find_all(clazz, text, sub_string, word_boundary=False, word_boundary_chars=None): 'Returns a list of of all the spans containing sub_string in text' check.check_string(text) check.check_string(sub_string) check.check_bool(word_boundary) check.check_set(word_boundary_chars, allow_none=True) return [ span for span in clazz.find_all_generator( text, sub_string, word_boundary=word_boundary, word_boundary_chars=word_boundary_chars) ]
def replace(clazz, s, replacements, word_boundary=False, word_boundary_chars=None): 'Replace all instances of dict d in string s.' check.check_string(s) check.check_dict(replacements, check.STRING_TYPES, check.STRING_TYPES) check.check_bool(word_boundary) check.check_set(word_boundary_chars, allow_none=True) for src_string, dst_string in replacements.items(): s = clazz.replace_all(s, src_string, dst_string, word_boundary=word_boundary, word_boundary_chars=word_boundary_chars) return s
def search(clazz, root_dir, text, relative=True, min_depth=None, max_depth=None): check.check_string(root_dir) check.check_string(text) check.check_bool(relative) check.check_int(min_depth, allow_none=True) check.check_int(max_depth, allow_none=True) files = file_find.find(root_dir, relative=relative, min_depth=min_depth, max_depth=max_depth) items = [] for f in files: fpath = path.join(root_dir, f) next_items = clazz.search_file(fpath, text) items += next_items if relative: return [item.become_relative(root_dir) for item in items] return items
def _command_bar(self, branch, verbose): check.check_string(branch) check.check_bool(verbose) print('bar:%s:%s' % (branch, int(verbose))) return 0
def randomize(self, randomize): check.check_bool(randomize) self._randomize = randomize
def test_check_bool(self): C.check_bool(True) with self.assertRaises(TypeError) as context: C.check_bool(6)