robotframework 6.1.1__zip → 7.0a1__zip

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/libraries/Collections.py

@@ -18,19 +18,12 @@ from ast import literal_eval
 
 from robot.api import logger
 from robot.utils import (get_error_message, is_dict_like, is_list_like, is_truthy,
-                         Matcher, plural_or_not as s, seq2str, seq2str2, type_name)
+                         Matcher, NOT_SET, plural_or_not as s, seq2str, seq2str2,
+                         type_name)
 from robot.utils.asserts import assert_equal
 from robot.version import get_version
 
 
-class NotSet:
-    def __repr__(self):
-        return ""
-
-
-NOT_SET = NotSet()
-
-
 class _List:
 
     def convert_to_list(self, item):

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/libraries/DateTime.py

@@ -619,7 +619,7 @@ class Time:
         return secs_to_timestr(seconds, compact=True)
 
     def _convert_to_timer(self, seconds, millis=True):
-        return elapsed_time_to_string(seconds * 1000, include_millis=millis)
+        return elapsed_time_to_string(seconds, include_millis=millis, seconds=True)
 
     def _convert_to_timedelta(self, seconds, millis=True):
         return timedelta(seconds=seconds)

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/libraries/OperatingSystem.py

@@ -21,6 +21,7 @@ import re
 import shutil
 import tempfile
 import time
+from datetime import datetime
 
 from robot.version import get_version
 from robot.api import logger
@@ -28,7 +29,7 @@ from robot.api.deco import keyword
 from robot.utils import (abspath, ConnectionCache, console_decode, del_env_var,
                          get_env_var, get_env_vars, get_time, is_truthy,
                          is_string, normpath, parse_time, plural_or_not,
-                         safe_str, secs_to_timestamp, secs_to_timestr, seq2str,
+                         safe_str, secs_to_timestr, seq2str,
                          set_env_var, timestr_to_secs, CONSOLE_ENCODING, WINDOWS)
 
 __version__ = get_version()
@@ -1297,8 +1298,8 @@ class OperatingSystem:
         if not os.path.isfile(path):
             self._error("Path '%s' is not a regular file." % path)
         os.utime(path, (mtime, mtime))
-        time.sleep(0.1)  # Give os some time to really set these times
-        tstamp = secs_to_timestamp(mtime, seps=('-', ' ', ':'))
+        time.sleep(0.1)    # Give OS some time to really set these times.
+        tstamp = datetime.fromtimestamp(mtime).isoformat(' ', timespec='seconds')
         self._link("Set modified time of '%%s' to %s." % tstamp, path)
 
     def get_file_size(self, path):

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/libraries/Process.py

@@ -75,7 +75,7 @@ class Process:
     optional ``**configuration`` keyword arguments. Configuration arguments
     must be given after other arguments passed to these keywords and must
     use syntax like ``name=value``. Available configuration arguments are
-    listed below and discussed further in sections afterwards.
+    listed below and discussed further in sections afterward.
 
     |  = Name =  |                  = Explanation =                      |
     | shell      | Specifies whether to run the command in shell or not. |
@@ -96,7 +96,7 @@ class Process:
     == Running processes in shell ==
 
     The ``shell`` argument specifies whether to run the process in a shell or
-    not. By default shell is not used, which means that shell specific commands,
+    not. By default, shell is not used, which means that shell specific commands,
     like ``copy`` and ``dir`` on Windows, are not available. You can, however,
     run shell scripts and batch files without using a shell.
 
@@ -129,8 +129,8 @@ class Process:
 
     == Environment variables ==
 
-    By default the child process will get a copy of the parent process's
-    environment variables. The ``env`` argument can be used to give the
+    The child process will get a copy of the parent process's environment
+    variables by default. The ``env`` argument can be used to give the
     child a custom environment as a Python dictionary. If there is a need
     to specify only certain environment variable, it is possible to use the
     ``env:<name>=<value>`` format to set or override only that named variables.
@@ -143,12 +143,12 @@ class Process:
 
     == Standard output and error streams ==
 
-    By default processes are run so that their standard output and standard
+    By default, processes are run so that their standard output and standard
     error streams are kept in the memory. This works fine normally,
     but if there is a lot of output, the output buffers may get full and
     the program can hang.
 
-    To avoid the above mentioned problems, it is possible to use ``stdout``
+    To avoid the above-mentioned problems, it is possible to use ``stdout``
     and ``stderr`` arguments to specify files on the file system where to
     redirect the outputs. This can also be useful if other processes or
     other keywords need to read or manipulate the outputs somehow.
@@ -172,8 +172,6 @@ class Process:
     This way the process will not hang even if there would be a lot of output,
     but naturally output is not available after execution either.
 
-    Support for the special value ``DEVNULL`` is new in Robot Framework 3.2.
-
     Examples:
     | ${result} = | `Run Process` | program | stdout=${TEMPDIR}/stdout.txt | stderr=${TEMPDIR}/stderr.txt |
     | `Log Many`  | stdout: ${result.stdout} | stderr: ${result.stderr} |
@@ -191,25 +189,23 @@ class Process:
     explained in the table below.
 
     | = Value =        | = Explanation = |
-    | String ``PIPE``  | Make stdin a pipe that can be written to. This is the default. |
-    | String ``NONE``  | Inherit stdin from the parent process. This value is case-insensitive. |
+    | String ``NONE``  | Inherit stdin from the parent process. This is the default. |
+    | String ``PIPE``  | Make stdin a pipe that can be written to. |
     | Path to a file   | Open the specified file and use it as the stdin. |
     | Any other string | Create a temporary file with the text as its content and use it as the stdin. |
     | Any non-string value | Used as-is. Could be a file descriptor, stdout of another process, etc. |
 
-    Values ``PIPE`` and ``NONE`` are internally mapped directly to
+    Values ``PIPE`` and ``NONE`` are case-insensitive and internally mapped to
     ``subprocess.PIPE`` and ``None``, respectively, when calling
     [https://docs.python.org/3/library/subprocess.html#subprocess.Popen|subprocess.Popen].
-    The default behavior may change from ``PIPE`` to ``NONE`` in future
-    releases. If you depend on the ``PIPE`` behavior, it is a good idea to use
-    it explicitly.
 
     Examples:
-    | `Run Process` | command | stdin=NONE |
+    | `Run Process` | command | stdin=PIPE |
     | `Run Process` | command | stdin=${CURDIR}/stdin.txt |
     | `Run Process` | command | stdin=Stdin as text. |
 
-    The support to configure ``stdin`` is new in Robot Framework 4.1.2.
+    The support to configure ``stdin`` is new in Robot Framework 4.1.2. Its default
+    value used to be ``PIPE`` until Robot Framework 7.0.
 
     == Output encoding ==
 
@@ -298,8 +294,6 @@ class Process:
     | `Terminate Process` | kill=${EMPTY} | # Empty string is false.       |
     | `Terminate Process` | kill=${FALSE} | # Python ``False`` is false.   |
 
-    Considering ``OFF`` and ``0`` false is new in Robot Framework 3.1.
-
     = Example =
 
     | ***** Settings *****
@@ -337,9 +331,15 @@ class Process:
         configuration` for more details about configuration related to starting
         processes. Configuration related to waiting for processes consists of
         ``timeout`` and ``on_timeout`` arguments that have same semantics as
-        with `Wait For Process` keyword. By default there is no timeout, and
+        with `Wait For Process` keyword. By default, there is no timeout, and
         if timeout is defined the default action on timeout is ``terminate``.
 
+        Process outputs are, by default, written into in-memory buffers.
+        If there is a lot of output, these buffers may get full causing
+        the process to hang. To avoid that, process outputs can be redirected
+        using the ``stdout`` and ``stderr`` configuration parameters. For more
+        information see the `Standard output and error streams` section.
+
         Returns a `result object` containing information about the execution.
 
         Note that possible equal signs in ``*arguments`` must be escaped
@@ -349,7 +349,7 @@ class Process:
         Examples:
         | ${result} = | Run Process | python | -c | print('Hello, world!') |
         | Should Be Equal | ${result.stdout} | Hello, world! |
-        | ${result} = | Run Process | ${command} | stderr=STDOUT | timeout=10s |
+        | ${result} = | Run Process | ${command} | stdout=${CURDIR}/stdout.txt | stderr=STDOUT |
         | ${result} = | Run Process | ${command} | timeout=1min | on_timeout=continue |
         | ${result} = | Run Process | java -Dname\\=value Example | shell=True | cwd=${EXAMPLE} |
 
@@ -369,11 +369,13 @@ class Process:
 
         See `Specifying command and arguments` and `Process configuration`
         for more information about the arguments, and `Run Process` keyword
-        for related examples.
+        for related examples. This includes information about redirecting
+        process outputs to avoid process handing due to output buffers getting
+        full.
 
         Makes the started process new `active process`. Returns the created
         [https://docs.python.org/3/library/subprocess.html#popen-constructor |
-        subprocess.Popen] object which can be be used later to active this
+        subprocess.Popen] object which can be used later to activate this
         process. ``Popen`` attributes like ``pid`` can also be accessed directly.
 
         Processes are started so that they create a new process group. This
@@ -381,7 +383,7 @@ class Process:
 
         Examples:
 
-        Start process and wait for it to end later using alias:
+        Start process and wait for it to end later using an alias:
         | `Start Process` | ${command} | alias=example |
         | # Other keywords |
         | ${result} = | `Wait For Process` | example |
@@ -492,9 +494,6 @@ class Process:
         | ${result} =                 | Wait For Process | timeout=1min 30s | on_timeout=kill |
         | Process Should Be Stopped   |                  |                  |
         | Should Be Equal As Integers | ${result.rc}     | -9               |
-
-        Ignoring timeout if it is string ``NONE``, zero, or negative is new
-        in Robot Framework 3.2.
         """
         process = self._processes[handle]
         logger.info('Waiting for process to complete.')
@@ -882,7 +881,7 @@ class ExecutionResult:
 
 class ProcessConfiguration:
 
-    def __init__(self, cwd=None, shell=False, stdout=None, stderr=None, stdin='PIPE',
+    def __init__(self, cwd=None, shell=False, stdout=None, stderr=None, stdin=None,
                  output_encoding='CONSOLE', alias=None, env=None, **rest):
         self.cwd = os.path.normpath(cwd) if cwd else os.path.abspath('.')
         self.shell = is_truthy(shell)

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/libraries/Remote.py

@@ -20,6 +20,7 @@ import re
 import socket
 import sys
 import xmlrpc.client
+from datetime import date, datetime, timedelta
 from xml.parsers.expat import ExpatError
 
 from robot.errors import RemoteError
@@ -59,8 +60,8 @@ class Remote:
         try:
             return self._client.get_keyword_names()
         except TypeError as error:
-            raise RuntimeError('Connecting remote server at %s failed: %s'
-                               % (self._uri, error))
+            raise RuntimeError(f'Connecting remote server at {self._uri} '
+                               f'failed: {error}')
 
     def _is_lib_info_available(self):
         if not self._lib_info_initialized:
@@ -107,47 +108,53 @@ class Remote:
 
 class ArgumentCoercer:
     binary = re.compile('[\x00-\x08\x0B\x0C\x0E-\x1F]')
-    non_ascii = re.compile('[\x80-\xff]')
 
     def coerce(self, argument):
         for handles, handler in [(is_string, self._handle_string),
-                                 (is_bytes, self._handle_bytes),
-                                 (is_number, self._pass_through),
+                                 (self._no_conversion_needed, self._pass_through),
+                                 (self._is_date, self._handle_date),
+                                 (self._is_timedelta, self._handle_timedelta),
                                  (is_dict_like, self._coerce_dict),
-                                 (is_list_like, self._coerce_list),
-                                 (lambda arg: True, self._to_string)]:
+                                 (is_list_like, self._coerce_list)]:
             if handles(argument):
                 return handler(argument)
+        return self._to_string(argument)
+
+    def _no_conversion_needed(self, arg):
+        return is_number(arg) or is_bytes(arg) or isinstance(arg, datetime)
 
     def _handle_string(self, arg):
-        if self._string_contains_binary(arg):
+        if self.binary.search(arg):
             return self._handle_binary_in_string(arg)
         return arg
 
-    def _string_contains_binary(self, arg):
-        return (self.binary.search(arg) or
-                is_bytes(arg) and self.non_ascii.search(arg))
-
     def _handle_binary_in_string(self, arg):
         try:
-            if not is_bytes(arg):
-                # Map Unicode code points to bytes directly
-                arg = arg.encode('latin-1')
+            # Map Unicode code points to bytes directly
+            return arg.encode('latin-1')
         except UnicodeError:
-            raise ValueError('Cannot represent %r as binary.' % arg)
-        return xmlrpc.client.Binary(arg)
-
-    def _handle_bytes(self, arg):
-        return xmlrpc.client.Binary(arg)
+            raise ValueError(f'Cannot represent {arg!r} as binary.')
 
     def _pass_through(self, arg):
         return arg
 
+    def _is_date(self, arg):
+        return isinstance(arg, date)
+
+    def _handle_date(self, arg):
+        return datetime(arg.year, arg.month, arg.day)
+
+    def _is_timedelta(self, arg):
+        return isinstance(arg, timedelta)
+
+    def _handle_timedelta(self, arg):
+        return arg.total_seconds()
+
     def _coerce_list(self, arg):
         return [self.coerce(item) for item in arg]
 
     def _coerce_dict(self, arg):
-        return dict((self._to_key(key), self.coerce(arg[key])) for key in arg)
+        return {self._to_key(key): self.coerce(arg[key]) for key in arg}
 
     def _to_key(self, item):
         item = self._to_string(item)
@@ -159,15 +166,15 @@ class ArgumentCoercer:
         return self._handle_string(item)
 
     def _validate_key(self, key):
-        if isinstance(key, xmlrpc.client.Binary):
-            raise ValueError('Dictionary keys cannot be binary. Got %r.' % (key.data,))
+        if isinstance(key, bytes):
+            raise ValueError(f'Dictionary keys cannot be binary. Got {key!r}.')
 
 
 class RemoteResult:
 
     def __init__(self, result):
         if not (is_dict_like(result) and 'status' in result):
-            raise RuntimeError('Invalid remote result dictionary: %s' % result)
+            raise RuntimeError(f'Invalid remote result dictionary: {result!r}')
         self.status = result['status']
         self.output = safe_str(self._get(result, 'output'))
         self.return_ = self._get(result, 'return')
@@ -181,8 +188,6 @@ class RemoteResult:
         return self._convert(value)
 
     def _convert(self, value):
-        if isinstance(value, xmlrpc.client.Binary):
-            return bytes(value.data)
         if is_dict_like(value):
             return DotDict((k, self._convert(v)) for k, v in value.items())
         if is_list_like(value):
@@ -204,6 +209,7 @@ class XmlRpcRemoteClient:
         else:
             transport = TimeoutHTTPTransport(timeout=self.timeout)
         server = xmlrpc.client.ServerProxy(self.uri, encoding='UTF-8',
+                                           use_builtin_types=True,
                                            transport=transport)
         try:
             yield server
@@ -244,12 +250,12 @@ class XmlRpcRemoteClient:
             except xmlrpc.client.Fault as err:
                 message = err.faultString
             except socket.error as err:
-                message = 'Connection to remote server broken: %s' % err
+                message = f'Connection to remote server broken: {err}'
             except ExpatError as err:
-                message = ('Processing XML-RPC return value failed. '
-                           'Most often this happens when the return value '
-                           'contains characters that are not valid in XML. '
-                           'Original error was: ExpatError: %s' % err)
+                message = (f'Processing XML-RPC return value failed. '
+                           f'Most often this happens when the return value '
+                           f'contains characters that are not valid in XML. '
+                           f'Original error was: ExpatError: {err}')
             raise RuntimeError(message)
 
 
@@ -259,11 +265,9 @@ class XmlRpcRemoteClient:
 class TimeoutHTTPTransport(xmlrpc.client.Transport):
     _connection_class = http.client.HTTPConnection
 
-    def __init__(self, use_datetime=0, timeout=None):
-        xmlrpc.client.Transport.__init__(self, use_datetime)
-        if not timeout:
-            timeout = socket._GLOBAL_DEFAULT_TIMEOUT
-        self.timeout = timeout
+    def __init__(self, timeout=None):
+        super().__init__(use_builtin_types=True)
+        self.timeout = timeout or socket._GLOBAL_DEFAULT_TIMEOUT
 
     def make_connection(self, host):
         if self._connection and host == self._connection[0]:

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/libraries/String.py

@@ -293,8 +293,8 @@ class String:
         if you need more complex pattern matching.
         """
         if is_truthy(case_insensitive):
-            pattern = pattern.lower()
-            contains = lambda line: pattern in line.lower()
+            pattern = pattern.casefold()
+            contains = lambda line: pattern in line.casefold()
         else:
             contains = lambda line: pattern in line
         return self._get_matching_lines(string, contains)
@@ -329,8 +329,8 @@ class String:
         literal strings is enough.
         """
         if is_truthy(case_insensitive):
-            pattern = pattern.lower()
-            matches = lambda line: fnmatchcase(line.lower(), pattern)
+            pattern = pattern.casefold()
+            matches = lambda line: fnmatchcase(line.casefold(), pattern)
         else:
             matches = lambda line: fnmatchcase(line, pattern)
         return self._get_matching_lines(string, matches)

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/libraries/XML.py

@@ -34,8 +34,7 @@ else:
 from robot.api import logger
 from robot.api.deco import keyword
 from robot.libraries.BuiltIn import BuiltIn
-from robot.utils import (asserts, ET, ETSource, is_bytes, is_falsy, is_string,
-                         is_truthy, plural_or_not as s)
+from robot.utils import asserts, ET, ETSource, is_falsy, is_truthy, plural_or_not as s
 from robot.version import get_version
 
 
@@ -53,7 +52,7 @@ class XML:
     The library has the following main usages:
 
     - Parsing an XML file, or a string containing XML, into an XML element
-      structure and finding certain elements from it for for further analysis
+      structure and finding certain elements from it for further analysis
       (e.g. `Parse XML` and `Get Element` keywords).
     - Getting text or attributes of elements
       (e.g. `Get Element Text` and `Get Element Attribute`).
@@ -75,10 +74,10 @@ class XML:
     children and their children. Possible comments and processing instructions
     in the source XML are removed.
 
-    XML is not validated during parsing even if has a schema defined. How
+    XML is not validated during parsing even if it has a schema defined. How
     possible doctype elements are handled otherwise depends on the used XML
     module and on the platform. The standard ElementTree strips doctypes
-    altogether but when `using lxml` they are preserved when XML is saved.
+    altogether, but when `using lxml` they are preserved when XML is saved.
 
     The element structure returned by `Parse XML`, as well as elements
     returned by keywords such as `Get Element`, can be used as the ``source``
@@ -168,7 +167,7 @@ class XML:
 
     If lxml support is enabled when `importing` the library, the whole
     [http://www.w3.org/TR/xpath/|xpath 1.0 standard] is supported.
-    That includes everything listed below but also lot of other useful
+    That includes everything listed below but also a lot of other useful
     constructs.
 
     == Tag names ==
@@ -304,7 +303,7 @@ class XML:
     = Handling XML namespaces =
 
     ElementTree and lxml handle possible namespaces in XML documents by adding
-    the namespace URI to tag names in so called Clark Notation. That is
+    the namespace URI to tag names in so-called Clark Notation. That is
     inconvenient especially with xpaths, and by default this library strips
     those namespaces away and moves them to ``xmlns`` attribute instead. That
     can be avoided by passing ``keep_clark_notation`` argument to `Parse XML`
@@ -1279,7 +1278,7 @@ class XML:
         The element to copy is specified using ``source`` and ``xpath``. They
         have exactly the same semantics as with `Get Element` keyword.
 
-        If the copy or the original element is modified afterwards, the changes
+        If the copy or the original element is modified afterward, the changes
         have no effect on the other.
 
         Examples using ``${XML}`` structure from `Example`:

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/libraries/__init__.py

@@ -27,5 +27,5 @@ the http://robotframework.org web site.
 """
 
 STDLIBS = frozenset(('BuiltIn', 'Collections', 'DateTime', 'Dialogs', 'Easter',
-                     'OperatingSystem', 'Process', 'Remote', 'Reserved',
-                     'Screenshot', 'String', 'Telnet', 'XML'))
+                     'OperatingSystem', 'Process', 'Remote', 'Screenshot',
+                     'String', 'Telnet', 'XML'))

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/model/__init__.py

@@ -27,14 +27,14 @@ This package is considered stable.
 
 from .body import BaseBody, Body, BodyItem, BaseBranches
 from .configurer import SuiteConfigurer
-from .control import Break, Continue, Error, For, If, IfBranch, Return, Try, TryBranch, While
+from .control import (Break, Continue, Error, For, If, IfBranch, Return, Try,
+                      TryBranch, Var, While)
 from .fixture import create_fixture
 from .itemlist import ItemList
-from .keyword import Keyword, Keywords
-from .message import Message, Messages
+from .keyword import Keyword
+from .message import Message, MessageLevel, Messages
 from .modelobject import DataDict, ModelObject
 from .modifier import ModelModifier
-from .namepatterns import SuiteNamePatterns, TestNamePatterns
 from .statistics import Statistics
 from .tags import Tags, TagPattern, TagPatterns
 from .testcase import TestCase, TestCases

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/model/body.py

@@ -26,7 +26,7 @@ if TYPE_CHECKING:
     from robot.result.model import ForIteration, WhileIteration
     from robot.running.model import UserKeyword, ResourceFile
     from .control import (Break, Continue, Error, For, If, IfBranch, Return,
-                          Try, TryBranch, While)
+                          Try, TryBranch, Var, While)
     from .keyword import Keyword
     from .message import Message
     from .testcase import TestCase
@@ -35,13 +35,14 @@ if TYPE_CHECKING:
 
 BodyItemParent = Union['TestSuite', 'TestCase', 'UserKeyword', 'For', 'ForIteration',
                        'If', 'IfBranch', 'Try', 'TryBranch', 'While', 'WhileIteration',
-                       'Keyword', 'Return', 'Continue', 'Break', 'Error', None]
+                       'Keyword', 'Var', 'Return', 'Continue', 'Break', 'Error', None]
 BI = TypeVar('BI', bound='BodyItem')
 KW = TypeVar('KW', bound='Keyword')
 F = TypeVar('F', bound='For')
 W = TypeVar('W', bound='While')
 I = TypeVar('I', bound='If')
 T = TypeVar('T', bound='Try')
+V = TypeVar('V', bound='Var')
 R = TypeVar('R', bound='Return')
 C = TypeVar('C', bound='Continue')
 B = TypeVar('B', bound='Break')
@@ -65,11 +66,13 @@ class BodyItem(ModelObject):
     EXCEPT = 'EXCEPT'
     FINALLY = 'FINALLY'
     WHILE = 'WHILE'
+    VAR = 'VAR'
     RETURN = 'RETURN'
     CONTINUE = 'CONTINUE'
     BREAK = 'BREAK'
     ERROR = 'ERROR'
     MESSAGE = 'MESSAGE'
+    KEYWORD_TYPES = (KEYWORD, SETUP, TEARDOWN)
     type = None
     __slots__ = ['parent']
 
@@ -111,7 +114,7 @@ class BodyItem(ModelObject):
         raise NotImplementedError
 
 
-class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, R, C, B, M, E]):
+class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, V, R, C, B, M, E]):
     """Base class for Body and Branches objects."""
     __slots__ = []
     # Set using 'BaseBody.register' when these classes are created.
@@ -120,6 +123,7 @@ class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, R, C, B, M, E]):
     while_class: Type[W] = KnownAtRuntime
     if_class: Type[I] = KnownAtRuntime
     try_class: Type[T] = KnownAtRuntime
+    var_class: Type[V] = KnownAtRuntime
     return_class: Type[R] = KnownAtRuntime
     continue_class: Type[C] = KnownAtRuntime
     break_class: Type[B] = KnownAtRuntime
@@ -185,6 +189,10 @@ class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, R, C, B, M, E]):
     def create_while(self, *args, **kwargs) -> while_class:
         return self._create(self.while_class, 'create_while', args, kwargs)
 
+    @copy_signature(var_class)
+    def create_var(self, *args, **kwargs) -> var_class:
+        return self._create(self.var_class, 'create_var', args, kwargs)
+
     @copy_signature(return_class)
     def create_return(self, *args, **kwargs) -> return_class:
         return self._create(self.return_class, 'create_return', args, kwargs)
@@ -267,8 +275,8 @@ class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, R, C, B, M, E]):
         return steps
 
 
-class Body(BaseBody['Keyword', 'For', 'While', 'If', 'Try', 'Return', 'Continue',
-                    'Break', 'Message', 'Error']):
+class Body(BaseBody['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
+                    'Continue', 'Break', 'Message', 'Error']):
     """A list-like object representing a body of a test, keyword, etc.
 
     Body contains the keywords and other structures such as FOR loops.
@@ -281,7 +289,7 @@ class BranchType(Generic[IT]):
     pass
 
 
-class BaseBranches(BaseBody[KW, F, W, I, T, R, C, B, M, E], BranchType[IT]):
+class BaseBranches(BaseBody[KW, F, W, I, T, V, R, C, B, M, E], BranchType[IT]):
     """A list-like object representing IF and TRY branches."""
     __slots__ = ['branch_class']
     branch_type: Type[IT] = KnownAtRuntime

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/model/configurer.py

@@ -66,22 +66,26 @@ class SuiteConfigurer(SuiteVisitor):
         parts = [{False: 'tests', True: 'tasks', None: 'tests or tasks'}[rpa],
                  self._get_test_selector_msgs(),
                  self._get_suite_selector_msg()]
-        raise DataError("Suite '%s' contains no %s."
-                        % (name, ' '.join(p for p in parts if p)))
+        raise DataError(f"Suite '{name}' contains no "
+                        f"{' '.join(p for p in parts if p)}.")
 
     def _get_test_selector_msgs(self):
         parts = []
-        for explanation, selector in [('matching tags', self.include_tags),
-                                      ('not matching tags', self.exclude_tags),
-                                      ('matching name', self.include_tests)]:
-            if selector:
-                parts.append(self._format_selector_msg(explanation, selector))
-        return seq2str(parts, quote='')
+        for separator, explanation, selectors in [
+                (None, 'matching name', self.include_tests),
+                ('or', 'matching tags', self.include_tags),
+                ('and', 'not matching tags', self.exclude_tags)
+        ]:
+            if selectors:
+                if parts:
+                    parts.append(separator)
+                parts.append(self._format_selector_msg(explanation, selectors))
+        return ' '.join(parts)
 
-    def _format_selector_msg(self, explanation, selector):
-        if len(selector) == 1 and explanation[-1] == 's':
+    def _format_selector_msg(self, explanation, selectors):
+        if len(selectors) == 1 and explanation[-1] == 's':
             explanation = explanation[:-1]
-        return '%s %s' % (explanation, seq2str(selector, lastsep=' or '))
+        return f"{explanation} {seq2str(selectors, lastsep=' or ')}"
 
     def _get_suite_selector_msg(self):
         if not self.include_suites: