name : argparse_utils.py # coding=utf-8 # # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2019 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENSE.TXT """ Extensions for validation and output formatting argparse """ import argparse import pwd import datetime from prettytable import PrettyTable from lvestats.lib.commons.dateutil import parse_date, parse_period2 class SmartFormatter(argparse.HelpFormatter): """ Format argparse help in many line, to format many lines use "R|" at start line >>>import argparse >>>parser = argparse.ArgumentParser(formatter_class=SmartFormatter) >>>parser.add_argument('-a', '--argument', help="R| Descriptions: \\n first new line\\n second new line") """ def _split_lines(self, text, width): if text.startswith('R|'): return text[2:].splitlines() return argparse.HelpFormatter._split_lines(self, text, width) # pylint: disable=protected-access def _format_args(self, action, default_metavar): if isinstance(action, ParseDatetime): get_metavar = self._metavar_formatter(action, default_metavar) return str(get_metavar(1)) return argparse.HelpFormatter._format_args(self, action, default_metavar) # pylint: disable=protected-access class ParseDatetime(argparse.Action): """ Interprets a string ([YY]YY-MM-DD[ HH:MM]) as a datetime for argument parsing. return parsed data as <type 'datetime.datetime'> """ def __call__(self, parser, namespace, values, option_string=None): datetime_str = ' '.join(values) if hasattr(values, '__iter__') else values try: result_datetime = parse_date(datetime_str) except ValueError as e: raise argparse.ArgumentError( self, f"{datetime_str} is an invalid; use [YY]YY-MM-DD[ HH:MM] format", ) from e setattr(namespace, self.dest, result_datetime) def check_percentages(value): """ Check if input argument between 0 and 100 :param str value: :return int: percent :except argparse.ArgumentTypeError: generate exception for command line warning message """ value = int(value) if value < 0 or value > 100: raise argparse.ArgumentTypeError(f"{value} is an invalid; this value can range from 0 to 100") return value def check_non_negative_int(value): """ Check if input argument greater than (or equal to) zero and not float :param str value: :return int: :except argparse.ArgumentTypeError: generate exception for command line warning message """ try: non_negative_int = int(value) except ValueError as e: raise argparse.ArgumentTypeError( f'"{value}" is an invalid; must be a number greater than (or equal to) zero' ) from e if '.' in value or non_negative_int < 0: raise argparse.ArgumentTypeError( f'"{value}" is an invalid; must be a number greater than (or equal to) zero' ) return non_negative_int def check_positive_int(value): """ Check if input argument is digest, greater than zero and not float :param str value: line to check :return int: positive integer :except argparse.ArgumentTypeError: generate exception for command line warning message """ try: positive_int = int(value) except ValueError as e: raise argparse.ArgumentTypeError( f'"{value}" is an invalid; must be a number greater than zero' ) from e if '.' in value or positive_int <= 0: raise argparse.ArgumentTypeError( f'"{value}" is an invalid; must be a number greater than zero' ) return positive_int def check_timestamp(value): """ Check if input argument is a correct timestamp 253370754000.0 == time.mktime(datetime.datetime(year=datetime.MAXYEAR, month=1, day=1).timetuple()) :param str value: line to check :return float: timestamp :except argparse.ArgumentTypeError: generate exception for command line warning message """ try: positive_float = float(value) except ValueError as e: raise argparse.ArgumentTypeError( f'"{value}" is an invalid; timestamp must be a number between 0 and 253370754000' ) from e if not 0 < positive_float < 253370754000: raise argparse.ArgumentTypeError( f'"{value}" is an invalid; timestamp must be a number between 0 and 253370754000' ) return positive_float def check_from_zero_to_max_int(value): """ Check if input argument less then maximum integer number PostgreSQL - 2147483647 MySQL - 2147483647 SQLite - 9223372036854775807 :param str value: :return int: :except argparse.ArgumentTypeError: generate exception for command line warning message """ max_int = 2147483647 try: non_negative_int = int(value) except ValueError as e: raise argparse.ArgumentTypeError( f'"{value}" is an invalid; must be a number greater than (or equal to) zero ' f'and less than {max_int}' ) from e if '.' in value or non_negative_int < 0 or non_negative_int > max_int: raise argparse.ArgumentTypeError( f'"{value}" is an invalid; must be a number greater than (or equal to) zero ' f'and less than {max_int}' ) return non_negative_int def check_user_name(value): """ Check if user present in system and convert user name to user id :param str value: user name (login) :return int: user id :except argparse.ArgumentTypeError: generate exception for command line warning message """ try: user_id = pwd.getpwnam(value).pw_uid except KeyError as e: raise argparse.ArgumentTypeError(f'user "{value}" not present in system') from e return user_id def period_type(value): """ Parse multiple period line, and validate input data :param str value: line to parsing :return int: period in seconds :except argparse.ArgumentTypeError: generate exception for command line warning message """ try: int_converted = int(value) if '.' in value or int_converted <= 0: raise argparse.ArgumentTypeError( f'"{value}" is an invalid; time period should be greater than (or equal to) ' '1 minute (60 seconds); not negative' ) value = str(int_converted) + 'm' # if only digest convert to minutes except ValueError: pass try: seconds = parse_period2(value) except ValueError as e: raise argparse.ArgumentTypeError(str(e)) from e if seconds < 60: raise argparse.ArgumentTypeError( f'"{value}" is an invalid; time period should be greater than (or equal to) ' '1 minute (60 seconds)' ) return seconds def period_type2(value, datetime_now=None, round_to_minutes=True): """ Extented period_type function Added support 'yesterday' and 'today' :param bool round_to_minutes: :param str value: line to parsing :return tuple: period from to (<type 'datetime.datetime'>, <type 'datetime.datetime'>) :except argparse.ArgumentTypeError: generate exception for command line warning message """ datetime_now = datetime_now or datetime.datetime.utcnow() value = value.lower() if value == 'yesterday': datetime_to = datetime_now.replace(hour=0, minute=0, second=0, microsecond=0) # today midnight datetime_from = datetime_to - datetime.timedelta(days=1) # yesterday midnight elif value == 'today': datetime_from = datetime_now.replace(hour=0, minute=0, second=0, microsecond=0) # today midnight datetime_to = datetime_now else: if round_to_minutes: datetime_from = datetime_now.replace(second=0, microsecond=0) # rounded to minutes datetime_to = datetime_now.replace(second=0, microsecond=0) # rounded to minutes else: datetime_from = datetime_now datetime_to = datetime_now datetime_from -= datetime.timedelta(seconds=period_type(value)) return datetime_from, datetime_to def format_aliases(description): """ Prepare aliases descriptions to table formatted :param tuple|list|iter description: massive of data :return str: ascii table """ fields = description[0] description = description[1:] table = PrettyTable(fields, padding_width=0, left_padding=2) for field in fields: table.align[field] = "l" list(map(table.add_row, description)) return table.get_string(border=False) BY_USAGE_PERCENT = 90 def alias_action(alias_dscr): alias_dscr = alias_dscr[1:] # first line is headers for descriptions in print tables aliases_func_dict = _alias_dscr_to_dict(alias_dscr) class AliasAction(argparse.Action): def __call__(self, parser, namespace, values, option_string=None): output_as_list = self.nargs in ('+', '*') if output_as_list: values_ = [] for val_ in values: # for using ',' as separator in options values_.extend(filter(bool, val_.lower().split(','))) # "filter(bool" for correct processing --show-columns=,ID, else: values_ = [values.strip('"').strip("'").lower()] # generate exception for not supported aliases not_supported_values = set(values_).difference(set(aliases_func_dict)) if not_supported_values: supported_values = tuple(aliases_func_dict) unsupported_aliases = '", "'.join(not_supported_values) raise argparse.ArgumentError( self, f'alias(es) "{unsupported_aliases}" not valid; ' f'choice from: {", ".join(supported_values)}' ) result = [aliases_func_dict[_] for _ in values_] # replace aliases to main aliases if not output_as_list: result = result[0] setattr(namespace, self.dest, result) # write result to namespace return AliasAction def _alias_dscr_to_dict(alias_dscr): """ preparation of the dictionary to extract the names of the aggregation function name (used in show_history) as aliases are used from the first to the penultimate elements alias_dscr as aggregation function name are used penultimate element >>> _alias_dscr_to_dict((('al_1', 'al_2', 'al_m1', 'description1'), ('al_3', 'al_4', 'al_m2', 'description1'))) {'al_2': 'al_m1', 'al_1': 'al_m1', 'al_m1': 'al_m1', 'al_3': 'al_m2', 'al_m2': 'al_m2', 'al_4': 'al_m2'} :param tuple|list alias_dscr: :type return: dict """ val_index_ = -2 aliases_func_pairs = [(_[val_index_].lower(), _[val_index_])for _ in alias_dscr] for key_index_ in range(len(alias_dscr[0]) - 1): aliases_func_pairs.extend([(_[key_index_], _[val_index_]) for _ in alias_dscr]) aliases_func_dict = dict(aliases_func_pairs) return aliases_func_dict def argparse_process_period(namespace): # prepare period period_from, period_to = getattr(namespace, 'from'), namespace.to if namespace.period: period_from, period_to = namespace.period setattr(namespace, 'from', period_from) namespace.to = period_to return namespace