def list_sum(*argv, **kwargs): """ Summarise items in provided list Arguments: - argv: list of item for summarise Options: - type: list item type (int if omitted) Note: All types provided by this lib supported Returns sum number in 'type' format """ _type_name = kwargs.get('type', 'int') _type = type_factory(_type_name) _result: _type = 0 try: for _list in argv: if isinstance(_list, (list, tuple)): _result += sum([_type(_item) for _item in _list]) else: _number = _type(_list) _result += _number except (ValueError, IndexError) as e: raise FrameworkError(f"ROBOT_MATH.LIST_SUM: {e}") else: return _result
def __init__(self, usage, name=None, version=None, arg_limits=None, validator=None, env_options=None, auto_help=True, auto_version=True, auto_pythonpath=True, auto_argumentfile=True): """Available options and tool name are read from the usage. Tool name is got from the first row of the usage. It is either the whole row or anything before first ' -- '. """ if not usage: raise FrameworkError('Usage cannot be empty') self.name = name or usage.splitlines()[0].split(' -- ')[0].strip() self.version = version or get_full_version() self._usage = usage self._arg_limit_validator = ArgLimitValidator(arg_limits) self._validator = validator self._auto_help = auto_help self._auto_version = auto_version self._auto_pythonpath = auto_pythonpath self._auto_argumentfile = auto_argumentfile self._env_options = env_options self._short_opts = '' self._long_opts = [] self._multi_opts = [] self._flag_opts = [] self._short_to_long = {} self._expected_args = () self._create_options(usage)
def __init__(self, usage, name=None, version=None, arg_limits=None, validator=None, env_options=None, auto_help=True, auto_version=True, auto_pythonpath='DEPRECATED', auto_argumentfile=True): """Available options and tool name are read from the usage. Tool name is got from the first row of the usage. It is either the whole row or anything before first ' -- '. """ if not usage: raise FrameworkError('Usage cannot be empty') self.name = name or usage.splitlines()[0].split(' -- ')[0].strip() self.version = version or get_full_version() self._usage = usage self._arg_limit_validator = ArgLimitValidator(arg_limits) self._validator = validator self._auto_help = auto_help self._auto_version = auto_version # TODO: Change DeprecationWarning to more loud UserWarning in RF 5.1. if auto_pythonpath == 'DEPRECATED': auto_pythonpath = False else: warnings.warn("ArgumentParser option 'auto_pythonpath' is deprecated " "since Robot Framework 5.0.", DeprecationWarning) self._auto_pythonpath = auto_pythonpath self._auto_argumentfile = auto_argumentfile self._env_options = env_options self._short_opts = '' self._long_opts = [] self._multi_opts = [] self._flag_opts = [] self._short_to_long = {} self._expected_args = () self._create_options(usage)
def _import(self, import_setting): try: action = {'Library': self._import_library, 'Resource': self._import_resource, 'Variables': self._import_variables}[import_setting.type] action(import_setting, self.variables.current) except KeyError: raise FrameworkError("Invalid import setting: %s" % import_setting)
def __setitem__(self, key, item): if not is_string(key) and not isinstance(key, tuple): raise FrameworkError('Invalid key for ImportCache') key = self._norm_path_key(key) if key not in self._keys: self._keys.append(key) self._items.append(item) else: self._items[self._keys.index(key)] = item
def run(self, runnable, args=None, kwargs=None): if self.error: raise DataError(self.error) if not self.active: raise FrameworkError('Timeout is not active') timeout = self.time_left() if timeout <= 0: raise TimeoutError(self.get_message()) executable = lambda: runnable(*(args or ()), **(kwargs or {})) return Timeout(timeout, self._timeout_error).execute(executable)
def _get_output_extension(self, extension, file_type): if extension: return extension if file_type in ['Output', 'XUnit']: return '.xml' if file_type in ['Log', 'Report']: return '.html' if file_type == 'DebugFile': return '.txt' raise FrameworkError(f"Invalid output file type '{file_type}'.")
def _get_output_extension(self, ext, type_): if ext != '': return ext if type_ in ['Output', 'XUnit']: return '.xml' if type_ in ['Log', 'Report']: return '.html' if type_ == 'DebugFile': return '.txt' raise FrameworkError("Invalid output file type: %s" % type_)
def _unescape_opts_and_args(self, opts, args): try: escape_strings = opts['escape'] except KeyError: raise FrameworkError("No 'escape' in options") escapes = self._get_escapes(escape_strings) for name, value in opts.items(): if name != 'escape': opts[name] = self._unescape(value, escapes) return opts, [self._unescape(arg, escapes) for arg in args]
def _unescape_opts_and_args(self, opts, args, escape_opt): try: escape_strings = opts[escape_opt] except KeyError: raise FrameworkError("No escape option '%s' in given options") escapes = self._get_escapes(escape_strings) for name, value in opts.items(): if name != escape_opt: opts[name] = self._unescape(value, escapes) args = [self._unescape(arg, escapes) for arg in args] return opts, args
def run(self, runnable, args=None, kwargs=None): if self.error: raise DataError(self.error) if not self.active: raise FrameworkError('Timeout is not active') timeout = self.time_left() error = TimeoutError(self._timeout_error, test_timeout=isinstance(self, TestTimeout)) if timeout <= 0: raise error executable = lambda: runnable(*(args or ()), **(kwargs or {})) return Timeout(timeout, error).execute(executable)
def _check_args(self, args): if not self._arg_limits: raise FrameworkError('No argument information specified.') minargs, maxargs = self._arg_limits if minargs <= len(args) <= maxargs: return minend = plural_or_not(minargs) if minargs == maxargs: exptxt = "%d argument%s" % (minargs, minend) elif maxargs != sys.maxint: exptxt = "%d to %d arguments" % (minargs, maxargs) else: exptxt = "at least %d argument%s" % (minargs, minend) raise DataError("Expected %s, got %d." % (exptxt, len(args)))
def _unescape_opts_and_args(self, opts, args): from robot.output import LOGGER with LOGGER.cache_only: LOGGER.warn("Option '--escape' is deprecated. Use console escape " "mechanism instead.") try: escape_strings = opts['escape'] except KeyError: raise FrameworkError("No 'escape' in options") escapes = self._get_escapes(escape_strings) for name, value in opts.items(): if name != 'escape': opts[name] = self._unescape(value, escapes) return opts, [self._unescape(arg, escapes) for arg in args]
def run(self, runnable, args=None, kwargs=None): if self.error: raise DataError(self.error) if not self.active: raise FrameworkError('Timeout is not active') timeout = self.time_left() if timeout <= 0: raise TimeoutError(self.get_message()) runner = ThreadedRunner(runnable, args, kwargs) if runner.run_in_thread(timeout): return runner.get_result() try: runner.stop_thread() except: raise TimeoutError('Stopping keyword after %s failed: %s' % (self.type.lower(), utils.get_error_message())) raise TimeoutError(self._get_timeout_error())
def packet_operation(expression_str, deviation_str=None, reason=None): """ Provide logical and mathematical operation with packet - expression_str: operand1 operation operand2 | Example | Comments | | 1M * 2 | Multiple Packet size 2M | | 1M + 10K | Return packet size 1.01M | | 1M + 10% | Return packet size 1.1M | Options: - deviation: add on for comparison verifications (eq, ,gt, lt, ge, le) Equality Examples: | Operand1 Operation Operand2 | Deviation | Result | Comments | | 10M == 12M | 25% | TRUE | (10M - 25%) < 12M < (10M + 25%) | | 10M == 12M | 0.25 | TRUE | (10M - 25%) < 12M < (10M + 25%) | | 10M == 12M | -25% | FALSE | (10M - 25%) < 12M < 10M | | 10M == 12M | +25% | TRUE | 10M < 12M < (10M + 25%) | - reason: Custom fail reason return: TRUE/FALSE for logical operation and value for math operation """ try: logger.trace( f"{expression_str}{', ' + deviation_str if deviation_str else ''}" ) _deviation = format_factory(deviation_str, Percent) if deviation_str else None operand1, operation, operand2 = _parse_line(expression_str, DataPacket, Percent) result = _type_evaluation(operand1=operand1, operand2=operand2, operation=operation, deviation=_deviation, special_eq=packet_eq) assert result is not False, f"{operand1} {operation.__name__} {operand2} False" if reason is None else reason return result except AssertionError as e: raise e except Exception as e: raise FrameworkError(e)
def time_operation(expression_str, deviation_str=None, reason=None): """ RF_MATH_OPERATION - expression: operand1 operation operand2 | Example | Comments | | 1h * 3 | Return 3h | | 1h + 10% | Return 1h 6m | - deviation: add on for comparison verifications (eq, ,gt, lt, ge, le) Equality Examples: | Operand1 | Operand2 | Percent | Result | Comments | | 10m | 12m | 25% | TRUE | 10m - 25% < 12m < 10m + 25% | | 10m | 12m | -25% | FALSE | 10m - 25% < 12m < 10m | | 10m | 12m | +25% | TRUE | 10m < 12m < 10m + 25% | - reason: Custom fail reason return: TRUE/FALSE for logical operation and value for math operation """ try: logger.trace( f"{expression_str}{', ' + deviation_str if deviation_str else ''}") _deviation = format_factory(deviation_str, Percent) if deviation_str else None operand1, operation, operand2 = _parse_line(expression_str, float, TimeInterval, Percent) result = _type_evaluation(operand1=operand1, operand2=operand2, operation=operation, deviation=_deviation, special_eq=robot_time_eq) assert result is not False, f"{operand1} {operation.__name__} {operand2} False" if reason is None else reason return result except AssertionError as e: raise e except Exception as e: raise FrameworkError(e)
def __init__(self, usage, version=None, arg_limits=None): """Available options and tool name are read from the usage. Tool name is got from the first row of the usage. It is either the whole row or anything before first ' -- '. See for example 'runner.py' and 'rebot.py' for examples. """ if not usage: raise FrameworkError('Usage cannot be empty') self._usage = usage self._name = usage.splitlines()[0].split(' -- ')[0].strip() self._version = version self._arg_limits = arg_limits self._short_opts = '' self._long_opts = [] self._multi_opts = [] self._toggle_opts = [] self._names = [] self._short_to_long = {} self._expected_args = () self._parse_usage(usage)
def _raise_option_multiple_times_in_usage(self, opt): raise FrameworkError("Option '%s' multiple times in usage" % opt)
def _raise_version(self): if not self._version: raise FrameworkError('Version not set') raise Information('%s %s' % (self._name, self._version))