robotframework 7.1rc2__zip → 7.2b1__zip

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/running/suiterunner.py

@@ -19,7 +19,8 @@ from robot.errors import ExecutionFailed, ExecutionStatus, DataError, PassExecut
 from robot.model import SuiteVisitor, TagPatterns
 from robot.result import (Keyword as KeywordResult, TestCase as TestResult,
                           TestSuite as SuiteResult, Result)
-from robot.utils import is_list_like, NormalizedDict, test_or_task
+from robot.utils import (is_list_like, NormalizedDict, plural_or_not as s, seq2str,
+                         test_or_task)
 from robot.variables import VariableScopes
 
 from .bodyrunner import BodyRunner, KeywordRunner
@@ -60,7 +61,7 @@ class SuiteRunner(SuiteVisitor):
                              start_time=datetime.now(),
                              rpa=self.settings.rpa)
         if not self.result:
-            self.result = Result(root_suite=result, rpa=self.settings.rpa)
+            self.result = Result(suite=result, rpa=self.settings.rpa)
             self.result.configure(status_rc=self.settings.status_rc,
                                   stat_config=self.settings.statistics_config)
         else:
@@ -125,19 +126,20 @@ class SuiteRunner(SuiteVisitor):
 
     def visit_test(self, data: TestData):
         settings = self.settings
-        if data.tags.robot('exclude'):
-            return
-        if data.name in self.executed[-1]:
-            self.output.warn(
-                test_or_task(f"Multiple {{test}}s with name '{data.name}' executed in "
-                             f"suite '{data.parent.full_name}'.", settings.rpa))
-        self.executed[-1][data.name] = True
         result = self.suite_result.tests.create(self._resolve_setting(data.name),
                                                 self._resolve_setting(data.doc),
                                                 self._resolve_setting(data.tags),
                                                 self._get_timeout(data),
                                                 data.lineno,
                                                 start_time=datetime.now())
+        if result.tags.robot('exclude'):
+            self.suite_result.tests.pop()
+            return
+        if result.name in self.executed[-1]:
+            self.output.warn(
+                test_or_task(f"Multiple {{test}}s with name '{result.name}' executed "
+                             f"in suite '{result.parent.full_name}'.", settings.rpa))
+        self.executed[-1][result.name] = True
         self.context.start_test(data, result)
         status = TestStatus(self.suite_status, result, settings.skip_on_failure,
                             settings.rpa)
@@ -154,14 +156,14 @@ class SuiteRunner(SuiteVisitor):
                 if settings.rpa:
                     data.error = data.error.replace('Test', 'Task')
                 status.test_failed(data.error)
-            elif data.tags.robot('skip'):
+            elif result.tags.robot('skip'):
                 status.test_skipped(
-                    test_or_task("{Test} skipped using 'robot:skip' tag.",
-                                 settings.rpa))
-            elif self.skipped_tags.match(data.tags):
+                    self._get_skipped_message(['robot:skip'], settings.rpa)
+                )
+            elif self.skipped_tags.match(result.tags):
                 status.test_skipped(
-                    test_or_task("{Test} skipped using '--skip' command line option.",
-                                 settings.rpa))
+                    self._get_skipped_message(self.skipped_tags, settings.rpa)
+                )
         self._run_setup(data, status, result)
         if status.passed:
             runner = BodyRunner(self.context, templated=bool(data.template))
@@ -198,6 +200,11 @@ class SuiteRunner(SuiteVisitor):
         self.context.end_test(result)
         self._clear_result(result)
 
+    def _get_skipped_message(self, tags, rpa):
+        kind = 'tag' if getattr(tags, 'is_constant', True) else 'tag pattern'
+        return test_or_task(f"{{Test}} skipped using {seq2str(tags)} {kind}{s(tags)}.",
+                            rpa)
+
     def _clear_result(self, result: 'SuiteResult|TestResult'):
         if result.has_setup:
             result.setup = None

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/running/userkeywordrunner.py

@@ -85,6 +85,10 @@ class UserKeywordRunner:
             with context.timeout(timeout):
                 exception, return_value = self._execute(kw, result, context)
                 if exception and not exception.can_continue(context):
+                    if context.in_teardown and exception.keyword_timeout:
+                        # Allow execution to continue on teardowns after timeout.
+                        # https://github.com/robotframework/robotframework/issues/3398
+                        exception.keyword_timeout = False
                     raise exception
                 return_value = self._handle_return_value(return_value, variables)
                 if exception:

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/utils/importer.py

@@ -21,6 +21,7 @@ import inspect
 from robot.errors import DataError
 
 from .error import get_error_details
+from .misc import seq2str
 from .robotpath import abspath, normpath
 from .robotinspect import is_init
 from .robottypes import type_name
@@ -43,9 +44,10 @@ class Importer:
         """
         self._type = type or ''
         self._logger = logger or NoLogger()
-        self._importers = (ByPathImporter(logger),
-                           NonDottedImporter(logger),
-                           DottedImporter(logger))
+        library_import = type and type.upper() == 'LIBRARY'
+        self._importers = (ByPathImporter(logger, library_import),
+                           NonDottedImporter(logger, library_import),
+                           DottedImporter(logger, library_import))
         self._by_path_importer = self._importers[0]
 
     def import_class_or_module(self, name_or_path, instantiate_with_args=None,
@@ -162,15 +164,14 @@ class Importer:
             self._raise_import_failed(path, err)
 
     def _log_import_succeeded(self, item, name, source):
-        import_type = '%s ' % self._type.lower() if self._type else ''
+        prefix = f'Imported {self._type.lower()}' if self._type else 'Imported'
         item_type = 'module' if inspect.ismodule(item) else 'class'
-        location = ("'%s'" % source) if source else 'unknown location'
-        self._logger.info("Imported %s%s '%s' from %s."
-                          % (import_type, item_type, name, location))
+        source = f"'{source}'" if source else 'unknown location'
+        self._logger.info(f"{prefix} {item_type} '{name}' from {source}.")
 
     def _raise_import_failed(self, name, error):
         prefix = f'Importing {self._type.lower()}' if self._type else 'Importing'
-        raise DataError(f"{prefix} '{name}' failed: {error.message}")
+        raise DataError(f"{prefix} '{name}' failed: {error}")
 
     def _instantiate_if_needed(self, imported, args):
         if args is None:
@@ -190,7 +191,8 @@ class Importer:
         try:
             return imported(*positional, **dict(named))
         except Exception:
-            raise DataError('Creating instance failed: %s\n%s' % get_error_details())
+            message, traceback = get_error_details()
+            raise DataError(f'Creating instance failed: {message}\n{traceback}')
 
     def _get_arg_spec(self, imported):
         # Avoid cyclic import. Yuck.
@@ -205,8 +207,9 @@ class Importer:
 
 class _Importer:
 
-    def __init__(self, logger):
-        self._logger = logger
+    def __init__(self, logger, library_import=False):
+        self.logger = logger
+        self.library_import = library_import
 
     def _import(self, name, fromlist=None):
         if name in sys.builtin_module_names:
@@ -223,11 +226,25 @@ class _Importer:
     def _verify_type(self, imported):
         if inspect.isclass(imported) or inspect.ismodule(imported):
             return imported
-        raise DataError('Expected class or module, got %s.' % type_name(imported))
-
-    def _get_class_from_module(self, module, name=None):
-        klass = getattr(module, name or module.__name__, None)
-        return klass if inspect.isclass(klass) else None
+        raise DataError(f'Expected class or module, got {type_name(imported)}.')
+
+    def _get_possible_class(self, module, name=None):
+        cls = self._get_class_matching_module_name(module, name)
+        if not cls and self.library_import:
+            cls = self._get_decorated_library_class_in_imported_module(module)
+        return cls or module
+
+    def _get_class_matching_module_name(self, module, name):
+        cls = getattr(module, name or module.__name__, None)
+        return cls if inspect.isclass(cls) else None
+
+    def _get_decorated_library_class_in_imported_module(self, module):
+        def predicate(item):
+            return (inspect.isclass(item)
+                    and hasattr(item, 'ROBOT_AUTO_KEYWORDS')
+                    and item.__module__ == module.__name__)
+        classes = [cls for _, cls in inspect.getmembers(module, predicate)]
+        return classes[0] if len(classes) == 1 else None
 
     def _get_source(self, imported):
         try:
@@ -248,7 +265,7 @@ class ByPathImporter(_Importer):
         self._remove_wrong_module_from_sys_modules(path)
         imported = self._import_by_path(path)
         if get_class:
-            imported = self._get_class_from_module(imported) or imported
+            imported = self._get_possible_class(imported)
         return self._verify_type(imported), path
 
     def _verify_import_path(self, path):
@@ -264,8 +281,8 @@ class ByPathImporter(_Importer):
         importing_package = os.path.splitext(path)[1] == ''
         if self._wrong_module_imported(name, importing_from, importing_package):
             del sys.modules[name]
-            self._logger.info("Removed module '%s' from sys.modules to import "
-                              "fresh module." % name)
+            self.logger.info(f"Removed module '{name}' from sys.modules to import "
+                             f"a fresh module.")
 
     def _split_path_to_module(self, path):
         module_dir, module_file = os.path.split(abspath(path))
@@ -307,7 +324,7 @@ class NonDottedImporter(_Importer):
     def import_(self, name, get_class=True):
         imported = self._import(name)
         if get_class:
-            imported = self._get_class_from_module(imported) or imported
+            imported = self._get_possible_class(imported)
         return self._verify_type(imported), self._get_source(imported)
 
 
@@ -322,10 +339,9 @@ class DottedImporter(_Importer):
         try:
             imported = getattr(parent, lib_name)
         except AttributeError:
-            raise DataError("Module '%s' does not contain '%s'."
-                            % (parent_name, lib_name))
+            raise DataError(f"Module '{parent_name}' does not contain '{lib_name}'.")
         if get_class:
-            imported = self._get_class_from_module(imported, lib_name) or imported
+            imported = self._get_possible_class(imported, lib_name)
         return self._verify_type(imported), self._get_source(imported)
 
 

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/utils/unic.py

@@ -26,13 +26,11 @@ def _safe_str(item):
     if isinstance(item, str):
         return item
     if isinstance(item, (bytes, bytearray)):
-        try:
-            return item.decode('ASCII')
-        except UnicodeError:
-            return ''.join(chr(b) if b < 128 else '\\x%x' % b for b in item)
+        # Map each byte to Unicode code point with same ordinal.
+        return item.decode('latin-1')
     try:
         return str(item)
-    except:
+    except Exception:
         return _unrepresentable_object(item)
 
 
@@ -45,7 +43,7 @@ class PrettyRepr(PrettyPrinter):
     def format(self, object, context, maxlevels, level):
         try:
             return PrettyPrinter.format(self, object, context, maxlevels, level)
-        except:
+        except Exception:
             return _unrepresentable_object(object), True, False
 
     # Don't split strings: https://stackoverflow.com/questions/31485402
@@ -63,5 +61,6 @@ class PrettyRepr(PrettyPrinter):
 
 def _unrepresentable_object(item):
     from .error import get_error_message
-    return "<Unrepresentable object %s. Error: %s>" \
-           % (item.__class__.__name__, get_error_message())
+
+    error = get_error_message()
+    return f'<Unrepresentable object {type(item).__name__}. Error: {error}>'

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/variables/evaluation.py

@@ -115,14 +115,33 @@ def _recommend_special_variables(expression):
         return ''
     example = []
     for match in matches:
-        example[-1:] += [match.before, match.identifier, match.base, match.after]
-    example = ''.join(example)
+        example[-1:] = [match.before, match.identifier + match.base, match.after]
+    example = ''.join(_remove_possible_quoting(example))
     return (f"Variables in the original expression {expression!r} were resolved "
             f"before the expression was evaluated. Try using {example!r} "
             f"syntax to avoid that. See Evaluating Expressions appendix in "
             f"Robot Framework User Guide for more details.")
 
 
+def _remove_possible_quoting(example_tokens):
+    before = var = after = None
+    for index, item in enumerate(example_tokens):
+        if index == 0:
+            before = item
+        elif index % 2 == 1:
+            var = item
+        else:
+            after = item
+            if before[-3:] in ('"""', "'''") and after[:3] == before[-3:]:
+                before, after = before[:-3], after[3:]
+            elif before[-1:] in ('"', "'") and after[:1] == before[-1:]:
+                before, after = before[:-1], after[1:]
+            yield before
+            yield var
+            before = after
+    yield after
+
+
 class EvaluationNamespace(MutableMapping):
 
     def __init__(self, variable_store, namespace):

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/variables/replacer.py

@@ -59,14 +59,11 @@ class VariableReplacer:
         result = []
         for item in items:
             match = search_variable(item, ignore_errors=ignore_errors)
-            if not match:
-                result.append(unescape(item))
+            value = self._replace(match, ignore_errors)
+            if match.is_list_variable() and is_list_like(value):
+                result.extend(value)
             else:
-                value = self._replace_scalar(match, ignore_errors)
-                if match.is_list_variable() and is_list_like(value):
-                    result.extend(value)
-                else:
-                    result.append(value)
+                result.append(value)
         return result
 
     def replace_scalar(self, item, ignore_errors=False):
@@ -80,37 +77,36 @@ class VariableReplacer:
             match = item
         else:
             match = search_variable(item, ignore_errors=ignore_errors)
-        if not match:
-            return unescape(match.string)
-        return self._replace_scalar(match, ignore_errors)
-
-    def _replace_scalar(self, match, ignore_errors=False):
-        if match.is_variable():
-            return self._get_variable_value(match, ignore_errors)
-        return self._replace_string(match, unescape, ignore_errors)
+        return self._replace(match, ignore_errors)
 
     def replace_string(self, item, custom_unescaper=None, ignore_errors=False):
         """Replaces variables from a string. Result is always a string.
 
         Input can also be an already found VariableMatch.
         """
-        unescaper = custom_unescaper or unescape
         if isinstance(item, VariableMatch):
             match = item
         else:
             match = search_variable(item, ignore_errors=ignore_errors)
-        if not match:
-            return safe_str(unescaper(match.string))
-        return self._replace_string(match, unescaper, ignore_errors)
+        result = self._replace(match, ignore_errors, custom_unescaper or unescape)
+        return safe_str(result)
 
-    def _replace_string(self, match, unescaper, ignore_errors):
+    def _replace(self, match, ignore_errors, unescaper=unescape):
+        if not match:
+            return unescaper(match.string)
+        if match.is_variable():
+            return self._get_variable_value(match, ignore_errors)
         parts = []
         while match:
-            parts.append(unescaper(match.before))
-            parts.append(safe_str(self._get_variable_value(match, ignore_errors)))
+            if match.before:
+                parts.append(unescaper(match.before))
+            parts.append(self._get_variable_value(match, ignore_errors))
             match = search_variable(match.after, ignore_errors=ignore_errors)
-        parts.append(unescaper(match.string))
-        return ''.join(parts)
+        if match.string:
+            parts.append(unescaper(match.string))
+        if all(isinstance(p, (bytes, bytearray)) for p in parts):
+            return b''.join(parts)
+        return ''.join(safe_str(p) for p in parts)
 
     def _get_variable_value(self, match, ignore_errors):
         match.resolve_base(self, ignore_errors)

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/variables/scopes.py

@@ -16,7 +16,6 @@
 import os
 import tempfile
 
-from robot.errors import VariableError
 from robot.model import Tags
 from robot.output import LOGGER
 from robot.utils import abspath, find_file, get_error_details, DotDict, NormalizedDict
@@ -31,6 +30,7 @@ class VariableScopes:
         self._global = GlobalVariables(settings)
         self._suite = None
         self._test = None
+        self._suite_locals = []
         self._scopes = [self._global]
         self._variables_set = SetVariables()
 
@@ -59,16 +59,18 @@ class VariableScopes:
     def start_suite(self):
         self._suite = self._global.copy()
         self._scopes.append(self._suite)
+        self._suite_locals.append(NormalizedDict(ignore='_'))
         self._variables_set.start_suite()
         self._variables_set.update(self._suite)
 
     def end_suite(self):
         self._scopes.pop()
+        self._suite_locals.pop()
         self._suite = self._scopes[-1] if len(self._scopes) > 1 else None
         self._variables_set.end_suite()
 
     def start_test(self):
-        self._test = self._suite.copy()
+        self._test = self._suite.copy(exclude=self._suite_locals[-1])
         self._scopes.append(self._test)
         self._variables_set.start_test()
 
@@ -78,7 +80,8 @@ class VariableScopes:
         self._variables_set.end_test()
 
     def start_keyword(self):
-        kw = self._suite.copy()
+        exclude = self._suite_locals[-1] if self._test else ()
+        kw = self._suite.copy(exclude)
         self._variables_set.start_keyword()
         self._variables_set.update(kw)
         self._scopes.append(kw)
@@ -141,13 +144,19 @@ class VariableScopes:
         for scope in self._scopes_until_suite:
             name, value = self._set_global_suite_or_test(scope, name, value)
         self._variables_set.set_suite(name, value, children)
+        # Override possible "suite local variables" (i.e. test variables set on
+        # suite level) if real suite level variable is set.
+        if name in self._suite_locals[-1]:
+            self._suite_locals[-1].pop(name)
 
     def set_test(self, name, value):
-        if self._test is None:
-            raise VariableError('Cannot set test variable when no test is started.')
-        for scope in self._scopes_until_test:
-            name, value = self._set_global_suite_or_test(scope, name, value)
-        self._variables_set.set_test(name, value)
+        if self._test:
+            for scope in self._scopes_until_test:
+                name, value = self._set_global_suite_or_test(scope, name, value)
+            self._variables_set.set_test(name, value)
+        else:
+            self.set_suite(name, value)
+            self._suite_locals[-1][name] = None
 
     def set_keyword(self, name, value):
         self.current[name] = value
@@ -192,7 +201,8 @@ class GlobalVariables(Variables):
                                 'include': Tags(settings.include),
                                 'exclude': Tags(settings.exclude),
                                 'skip': Tags(settings.skip),
-                                'skip_on_failure': Tags(settings.skip_on_failure)
+                                'skip_on_failure': Tags(settings.skip_on_failure),
+                                'console_width': settings.console_width
                             })),
                             ('${/}', os.sep),
                             ('${:}', os.pathsep),

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/variables/variables.py

@@ -68,9 +68,12 @@ class Variables:
     def clear(self):
         self.store.clear()
 
-    def copy(self):
+    def copy(self, exclude=None):
         variables = Variables()
         variables.store.data = self.store.data.copy()
+        if exclude:
+            for name in exclude:
+                variables.store.data.pop(name[2:-1])
         return variables
 
     def update(self, variables):

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robot/version.py

@@ -18,7 +18,7 @@ import sys
 
 # Version number typically updated by running `invoke set-version <version>`.
 # Run `invoke --help set-version` or see tasks.py for details.
-VERSION = '7.1rc2'
+VERSION = '7.2b1'
 
 
 def get_version(naked=False):

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robotframework.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework
-Version: 7.1rc2
+Version: 7.2b1
 Summary: Generic automation framework for acceptance testing and robotic process automation (RPA)
 Home-page: https://robotframework.org
 Author: Pekka Klärck
@@ -10,7 +10,7 @@ Download-URL: https://pypi.org/project/robotframework
 Project-URL: Source, https://github.com/robotframework/robotframework
 Project-URL: Issue Tracker, https://github.com/robotframework/robotframework/issues
 Project-URL: Documentation, https://robotframework.org/robotframework
-Project-URL: Release Notes, https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.1rc2.rst
+Project-URL: Release Notes, https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.2b1.rst
 Project-URL: Slack, http://slack.robotframework.org
 Description: Robot Framework
         ===============

{robotframework-7.1rc2 → robotframework-7.2b1}/src/robotframework.egg-info/SOURCES.txt

@@ -42,11 +42,7 @@ src/robot/htmldata/lib/jquery.tablesorter.min.js
 src/robot/htmldata/lib/jquery.tmpl.min.js
 src/robot/htmldata/lib/jsxcompressor.min.js
 src/robot/htmldata/libdoc/__init__.py
-src/robot/htmldata/libdoc/doc_formatting.css
-src/robot/htmldata/libdoc/libdoc.css
 src/robot/htmldata/libdoc/libdoc.html
-src/robot/htmldata/libdoc/print.css
-src/robot/htmldata/libdoc/pygments.css
 src/robot/htmldata/rebot/__init__.py
 src/robot/htmldata/rebot/common.css
 src/robot/htmldata/rebot/doc_formatting.css
@@ -119,12 +115,15 @@ src/robot/model/visitor.py
 src/robot/output/__init__.py
 src/robot/output/debugfile.py
 src/robot/output/filelogger.py
+src/robot/output/jsonlogger.py
 src/robot/output/librarylogger.py
 src/robot/output/listeners.py
 src/robot/output/logger.py
 src/robot/output/loggerapi.py
 src/robot/output/loggerhelper.py
+src/robot/output/loglevel.py
 src/robot/output/output.py
+src/robot/output/outputfile.py
 src/robot/output/pyloggingconf.py
 src/robot/output/stdoutlogsplitter.py
 src/robot/output/xmllogger.py

robotframework-7.1rc2/src/robot/htmldata/libdoc/doc_formatting.css

@@ -1,74 +0,0 @@
-#introduction-container > h2,
-.doc > h1,
-.doc > h2,
-.section > h1,
-.section > h2 {
-    margin-top: 4rem;
-    margin-bottom: 1rem;
-}
-
-.doc > h3, .section > h3 {
-    margin-top: 3rem;
-    margin-bottom: 1rem;
-}
-
-.doc > h4, .section > h4 {
-    margin-top: 2rem;
-    margin-bottom: 1rem;
-}
-
-.doc > p, .section > p {
-    margin-top: 1rem;
-    margin-bottom: 0.5rem;
-}
-.doc > *:first-child {
-    margin-top: 0.1em;
-}
-.doc table {
-    border: none;
-    background: transparent;
-    border-collapse: collapse;
-    empty-cells: show;
-    font-size: 0.9em;
-    overflow-y: auto;
-    display: block;
-}
-.doc table th, .doc table td {
-    border: 1px solid var(--border-color);
-    background: transparent;
-    padding: 0.1em 0.3em;
-    height: 1.2em;
-}
-.doc table th {
-    text-align: center;
-    letter-spacing: 0.1em;
-}
-.doc pre {
-    font-size: 1.1em;
-    letter-spacing: 0.05em;
-    background: var(--light-background-color);
-    overflow-y: auto;
-    padding: 0.3rem;
-    border-radius: 3px;
-}
-
-.doc code,
-.docutils.literal {
-    font-size: 1.1em;
-    letter-spacing: 0.05em;
-    background: var(--light-background-color);
-    padding: 1px;
-    border-radius: 3px;
-}
-.doc li {
-    list-style-position: inside;
-    list-style-type: square;
-}
-.doc img {
-    border: 1px solid #ccc;
-}
-.doc hr {
-    background: #ccc;
-    height: 1px;
-    border: 0;
-}