robotframework 7.0.1rc2__zip → 7.1rc1__zip

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/running/namespace.py

@@ -87,9 +87,7 @@ class Namespace:
             self.variables.set_from_variable_section(resource.variables, overwrite)
             self._kw_store.resources[path] = resource
             self._handle_imports(resource.imports)
-            LOGGER.imported("Resource", resource.name,
-                            importer=str(import_setting.source),
-                            source=path)
+            LOGGER.resource_import(resource, import_setting)
         else:
             LOGGER.info(f"Resource file '{path}' already imported by "
                         f"suite '{self._suite_name}'.")
@@ -109,10 +107,10 @@ class Namespace:
         if overwrite or (path, args) not in self._imported_variable_files:
             self._imported_variable_files.add((path, args))
             self.variables.set_from_file(path, args, overwrite)
-            LOGGER.imported("Variables", os.path.basename(path),
-                            args=list(args),
-                            importer=str(import_setting.source),
-                            source=path)
+            LOGGER.variables_import({'name': os.path.basename(path),
+                                     'args': args,
+                                     'source': path},
+                                    importer=import_setting)
         else:
             msg = f"Variable file '{path}'"
             if args:
@@ -131,11 +129,7 @@ class Namespace:
                         f"'{self._suite_name}'.")
             return
         if notify:
-            LOGGER.imported("Library", lib.name,
-                            args=list(import_setting.args),
-                            originalname=lib.real_name,
-                            importer=str(import_setting.source),
-                            source=str(lib.source or ''))
+            LOGGER.library_import(lib, import_setting)
         self._kw_store.libraries[lib.name] = lib
         lib.scope_manager.start_suite()
         if self._running_test:
@@ -287,30 +281,30 @@ class KeywordStore:
         else:
             raise KeywordError(message)
 
-    def _get_runner(self, name):
+    def _get_runner(self, name, strip_bdd_prefix=True):
         if not name:
             raise DataError('Keyword name cannot be empty.')
         if not is_string(name):
             raise DataError('Keyword name must be a string.')
-        runner = self._get_runner_from_suite_file(name)
+        runner = None
+        if strip_bdd_prefix:
+            runner = self._get_bdd_style_runner(name)
+        if not runner:
+            runner = self._get_runner_from_suite_file(name)
         if not runner and '.' in name:
             runner = self._get_explicit_runner(name)
         if not runner:
             runner = self._get_implicit_runner(name)
-        if not runner:
-            runner = self._get_bdd_style_runner(name, self.languages.bdd_prefixes)
         return runner
 
-    def _get_bdd_style_runner(self, name, prefixes):
-        parts = name.split()
-        for index in range(1, len(parts)):
-            prefix = ' '.join(parts[:index]).title()
-            if prefix in prefixes:
-                runner = self._get_runner(' '.join(parts[index:]))
-                if runner:
-                    runner = copy.copy(runner)
-                    runner.name = name
-                    return runner
+    def _get_bdd_style_runner(self, name):
+        match = self.languages.bdd_prefix_regexp.match(name)
+        if match:
+            runner = self._get_runner(name[match.end():], strip_bdd_prefix=False)
+            if runner:
+                runner = copy.copy(runner)
+                runner.name = name
+                return runner
         return None
 
     def _get_implicit_runner(self, name):

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/running/resourcemodel.py

@@ -28,10 +28,13 @@ from .model import Body, BodyItemParent, Keyword, TestSuite
 from .userkeywordrunner import UserKeywordRunner, EmbeddedArgumentsRunner
 
 if TYPE_CHECKING:
+    from robot.conf import LanguagesLike
     from robot.parsing import File
 
 
 class ResourceFile(ModelObject):
+    """Represents a resource file."""
+
     repr_args = ('source',)
     __slots__ = ('_source', 'owner', 'doc', 'keyword_finder')
 
@@ -234,7 +237,8 @@ class UserKeyword(KeywordImplementation):
         """
         return bool(self._teardown)
 
-    def create_runner(self, name: 'str|None', languages=None) \
+    def create_runner(self, name: 'str|None',
+                      languages: 'LanguagesLike' = None) \
             -> 'UserKeywordRunner|EmbeddedArgumentsRunner':
         if self.embedded:
             return EmbeddedArgumentsRunner(self, name)
@@ -317,8 +321,12 @@ class Variable(ModelObject):
             data['error'] = self.error
         return data
 
+    def _include_in_repr(self, name: str, value: Any) -> bool:
+        return not (name == 'separator' and value is None)
+
 
 class Import(ModelObject):
+    """Represents library, resource file or variable file import."""
     repr_args = ('type', 'name', 'args', 'alias')
     LIBRARY = 'LIBRARY'
     RESOURCE = 'RESOURCE'

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/running/statusreporter.py

@@ -52,10 +52,10 @@ class StatusReporter:
             message = ' ' + doc.split('*', 2)[-1].strip()
             self.context.warn(f"Keyword '{name}' is deprecated.{message}")
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
+    def __exit__(self, exc_type, exc_value, exc_traceback):
         context = self.context
         result = self.result
-        failure = self._get_failure(exc_type, exc_val, exc_tb, context)
+        failure = self._get_failure(exc_value, context)
         if failure is None:
             result.status = self.pass_status
         else:
@@ -65,12 +65,17 @@ class StatusReporter:
         if self.initial_test_status == 'PASS':
             context.test.status = result.status
         result.elapsed_time = datetime.now() - result.start_time
+        orig_status = (result.status, result.message)
         context.end_body_item(self.data, result, self.implementation)
-        if failure is not exc_val and not self.suppress:
+        if orig_status != (result.status, result.message):
+            if result.passed or result.not_run:
+                return True
+            raise ExecutionFailed(result.message, skip=result.skipped)
+        if failure is not exc_value and not self.suppress:
             raise failure
         return self.suppress
 
-    def _get_failure(self, exc_type, exc_value, exc_tb, context):
+    def _get_failure(self, exc_value, context):
         if exc_value is None:
             return None
         if isinstance(exc_value, ExecutionStatus):

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/running/testlibraries.py

@@ -171,7 +171,7 @@ class TestLibrary:
         if inspect.ismodule(code):
             lib = cls.from_module(code, name, real_name, source, create_keywords, logger)
             if args:    # Resolving arguments reports an error.
-                lib.init.resolve_arguments(args, variables)
+                lib.init.resolve_arguments(args, variables=variables)
             return lib
         return cls.from_class(code, name, real_name, source, args or (), variables,
                               create_keywords, logger)
@@ -316,7 +316,7 @@ class ClassLibrary(TestLibrary):
                    logger=LOGGER) -> 'ClassLibrary':
         init = LibraryInit.from_class(klass)
         library = cls(klass, init, name, real_name, source, logger)
-        positional, named = init.args.resolve(args, variables)
+        positional, named = init.args.resolve(args, variables=variables)
         init.positional, init.named = list(positional), dict(named)
         if create_keywords:
             library.create_keywords()

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/running/userkeywordrunner.py

@@ -55,13 +55,16 @@ class UserKeywordRunner:
 
     def _config_result(self, result: KeywordResult, data: KeywordData,
                        kw: 'UserKeyword', assignment, variables):
+        args = tuple(data.args)
+        if data.named_args:
+            args += tuple(f'{n}={v}' for n, v in data.named_args.items())
         doc = variables.replace_string(kw.doc, ignore_errors=True)
         doc, tags = split_tags_from_doc(doc)
         tags = variables.replace_list(kw.tags, ignore_errors=True) + tags
         result.config(name=self.name,
                       owner=kw.owner.name,
                       doc=getshortdoc(doc),
-                      args=data.args,
+                      args=args,
                       assign=tuple(assignment),
                       tags=tags,
                       type=data.type)
@@ -71,7 +74,7 @@ class UserKeywordRunner:
             for message in self.pre_run_messages:
                 context.output.message(message)
         variables = context.variables
-        positional, named = self._resolve_arguments(kw, data.args, variables)
+        positional, named = self._resolve_arguments(data, kw, variables)
         with context.user_keyword(kw):
             self._set_arguments(kw, positional, named, context)
             if kw.timeout:
@@ -89,8 +92,8 @@ class UserKeywordRunner:
                     raise exception
                 return return_value
 
-    def _resolve_arguments(self, kw: 'UserKeyword', args, variables=None):
-        return kw.resolve_arguments(args, variables)
+    def _resolve_arguments(self, data: KeywordData, kw: 'UserKeyword', variables=None):
+        return kw.resolve_arguments(data.args, data.named_args, variables)
 
     def _set_arguments(self, kw: 'UserKeyword', positional, named, context):
         variables = context.variables
@@ -222,7 +225,7 @@ class UserKeywordRunner:
         if self.pre_run_messages:
             for message in self.pre_run_messages:
                 context.output.message(message)
-        self._resolve_arguments(kw, data.args)
+        self._resolve_arguments(data, kw)
         with context.user_keyword(kw):
             if kw.timeout:
                 timeout = KeywordTimeout(kw.timeout, context.variables)
@@ -238,8 +241,8 @@ class EmbeddedArgumentsRunner(UserKeywordRunner):
         super().__init__(keyword, name)
         self.embedded_args = keyword.embedded.match(name).groups()
 
-    def _resolve_arguments(self, kw: 'UserKeyword', args, variables=None):
-        result = super()._resolve_arguments(kw, args, variables)
+    def _resolve_arguments(self, data: KeywordData, kw: 'UserKeyword', variables=None):
+        result = super()._resolve_arguments(data, kw, variables)
         if variables:
             embedded = [variables.replace_scalar(e) for e in self.embedded_args]
             self.embedded_args = kw.embedded.map(embedded)

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/utils/encodingsniffer.py

@@ -18,7 +18,7 @@ import sys
 import locale
 
 from .misc import isatty
-from .platform import UNIXY, WINDOWS
+from .platform import PY_VERSION, UNIXY, WINDOWS
 
 
 if UNIXY:
@@ -53,6 +53,8 @@ def _get_encoding(platform_getters, default):
 
 
 def _get_python_system_encoding():
+    if PY_VERSION >= (3, 11):
+        return locale.getencoding()
     # ValueError occurs with PyPy 3.10 if language config is invalid.
     # https://foss.heptapod.net/pypy/pypy/-/issues/3975
     try:

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/utils/robottime.py

@@ -86,7 +86,7 @@ def _time_string_to_secs(timestr):
     timestr = _normalize_timestr(timestr)
     if not timestr:
         return None
-    nanos = micros = millis = secs = mins = hours = days = 0
+    nanos = micros = millis = secs = mins = hours = days = weeks = 0
     if timestr[0] == '-':
         sign = -1
         timestr = timestr[1:]
@@ -102,13 +102,14 @@ def _time_string_to_secs(timestr):
             elif c == 'm': mins   = float(''.join(temp)); temp = []
             elif c == 'h': hours  = float(''.join(temp)); temp = []
             elif c == 'd': days   = float(''.join(temp)); temp = []
+            elif c == 'w': weeks  = float(''.join(temp)); temp = []
             else: temp.append(c)
         except ValueError:
             return None
     if temp:
         return None
     return sign * (nanos/1E9 + micros/1E6 + millis/1000 + secs +
-                   mins*60 + hours*60*60 + days*60*60*24)
+                   mins*60 + hours*60*60 + days*60*60*24 + weeks*60*60*24*7)
 
 
 def _normalize_timestr(timestr):
@@ -120,7 +121,8 @@ def _normalize_timestr(timestr):
                                ('s', ['second', 'sec']),
                                ('m', ['minute', 'min']),
                                ('h', ['hour']),
-                               ('d', ['day'])]:
+                               ('d', ['day']),
+                               ('w', ['week'])]:
         plural_aliases = [a+'s' for a in aliases if not a.endswith('s')]
         for alias in plural_aliases + aliases:
             if alias in timestr:

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/variables/evaluation.py

@@ -27,9 +27,6 @@ from .search import VariableMatches
 from .notfound import variable_not_found
 
 
-PYTHON_BUILTINS = set(builtins.__dict__)
-
-
 def evaluate_expression(expression, variables, modules=None, namespace=None,
                         resolve_variables=False):
     original = expression
@@ -146,7 +143,7 @@ class EvaluationNamespace(MutableMapping):
         self.namespace.pop(key)
 
     def _import_module(self, name):
-        if name in PYTHON_BUILTINS:
+        if hasattr(builtins, name):
             raise KeyError
         try:
             return __import__(name)

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/src/robot/variables/tablesetter.py

@@ -13,8 +13,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from contextlib import contextmanager
-from typing import Sequence, TYPE_CHECKING
+from typing import Any, Sequence, TYPE_CHECKING
 
 from robot.errors import DataError
 from robot.utils import DotDict, split_from_equals
@@ -23,7 +22,7 @@ from .resolvable import Resolvable
 from .search import is_assign, is_list_variable, is_dict_variable
 
 if TYPE_CHECKING:
-    from robot.running.model import Var, Variable
+    from robot.running import Var, Variable
     from .store import VariableStore
 
 
@@ -35,8 +34,8 @@ class VariableTableSetter:
     def set(self, variables: 'Sequence[Variable]', overwrite: bool = False):
         for var in variables:
             try:
-                value = VariableResolver.from_variable(var)
-                self.store.add(var.name, value, overwrite)
+                resolver = VariableResolver.from_variable(var)
+                self.store.add(var.name, resolver, overwrite)
             except DataError as err:
                 var.report_error(str(err))
 
@@ -46,7 +45,8 @@ class VariableResolver(Resolvable):
     def __init__(self, value: Sequence[str], error_reporter=None):
         self.value = tuple(value)
         self.error_reporter = error_reporter
-        self._resolving = False
+        self.resolving = False
+        self.resolved = False
 
     @classmethod
     def from_name_and_value(cls, name: str, value: 'str|Sequence[str]',
@@ -69,22 +69,19 @@ class VariableResolver(Resolvable):
         return cls.from_name_and_value(var.name, var.value, var.separator,
                                        getattr(var, 'report_error', None))
 
-    def resolve(self, variables):
-        with self._avoid_recursion:
-            return self._replace_variables(variables)
-
-    @property
-    @contextmanager
-    def _avoid_recursion(self):
-        if self._resolving:
+    def resolve(self, variables) -> Any:
+        if self.resolving:
             raise DataError('Recursive variable definition.')
-        self._resolving = True
-        try:
-            yield
-        finally:
-            self._resolving = False
+        if not self.resolved:
+            self.resolving = True
+            try:
+                self.value = self._replace_variables(variables)
+            finally:
+                self.resolving = False
+            self.resolved = True
+        return self.value
 
-    def _replace_variables(self, variables):
+    def _replace_variables(self, variables) -> Any:
         raise NotImplementedError
 
     def report_error(self, error):

{robotframework-7.0.1rc2 → robotframework-7.1rc1}/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.0.1rc2'
+VERSION = '7.1rc1'
 
 
 def get_version(naked=False):

{robotframework-7.0.1rc2 → robotframework-7.1rc1/src/robotframework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework
-Version: 7.0.1rc2
+Version: 7.1rc1
 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.0.1rc2.rst
+Project-URL: Release Notes, https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.1rc1.rst
 Project-URL: Slack, http://slack.robotframework.org
 Description: Robot Framework
         ===============
@@ -176,6 +176,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Software Development :: Testing