robotframework 6.1.1__zip → 7.0a1__zip

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

@@ -171,11 +171,11 @@ class JsonConverter:
             'relativeSource': self._get_relative_source(suite.source),
             'id': suite.id,
             'name': self._escape(suite.name),
-            'fullName': self._escape(suite.longname),
+            'fullName': self._escape(suite.full_name),
             'doc': self._html(suite.doc),
             'metadata': [(self._escape(name), self._html(value))
                          for name, value in suite.metadata.items()],
-            'numberOfTests': suite.test_count   ,
+            'numberOfTests': suite.test_count,
             'suites': self._convert_suites(suite),
             'tests': self._convert_tests(suite),
             'keywords': list(self._convert_keywords((suite.setup, suite.teardown)))
@@ -205,7 +205,7 @@ class JsonConverter:
             test.body.append(test.teardown)
         return {
             'name': self._escape(test.name),
-            'fullName': self._escape(test.longname),
+            'fullName': self._escape(test.full_name),
             'id': test.id,
             'doc': self._html(test.doc),
             'tags': [self._escape(t) for t in test.tags],
@@ -217,10 +217,8 @@ class JsonConverter:
         for kw in keywords:
             if not kw:
                 continue
-            if kw.type == kw.SETUP:
-                yield self._convert_keyword(kw, 'SETUP')
-            elif kw.type == kw.TEARDOWN:
-                yield self._convert_keyword(kw, 'TEARDOWN')
+            if kw.type in kw.KEYWORD_TYPES:
+                yield self._convert_keyword(kw)
             elif kw.type == kw.FOR:
                 yield self._convert_for(kw)
             elif kw.type == kw.WHILE:
@@ -229,11 +227,11 @@ class JsonConverter:
                 yield from self._convert_if(kw)
             elif kw.type == kw.TRY_EXCEPT_ROOT:
                 yield from self._convert_try(kw)
-            else:
-                yield self._convert_keyword(kw, 'KEYWORD')
+            elif kw.type == kw.VAR:
+                yield self._convert_var(kw)
 
     def _convert_for(self, data):
-        name = '%s %s %s' % (', '.join(data.variables), data.flavor,
+        name = '%s %s %s' % (', '.join(data.assign), data.flavor,
                              seq2str2(data.values))
         return {'type': 'FOR', 'name': self._escape(name), 'arguments': ''}
 
@@ -250,15 +248,22 @@ class JsonConverter:
         for branch in data.body:
             if branch.type == branch.EXCEPT:
                 patterns = ', '.join(branch.patterns)
-                as_var = f'AS {branch.variable}' if branch.variable else ''
+                as_var = f'AS {branch.assign}' if branch.assign else ''
                 name = f'{patterns} {as_var}'.strip()
             else:
                 name = ''
             yield {'type': branch.type, 'name': name, 'arguments': ''}
 
-    def _convert_keyword(self, kw, kw_type):
+    def _convert_var(self, data):
+        if data.name[0] == '$' and len(data.value) == 1:
+            value = data.value[0]
+        else:
+            value = '[' + ', '.join(data.value) + ']'
+        return {'type': 'VAR', 'name': f'{data.name} = {value}'}
+
+    def _convert_keyword(self, kw):
         return {
-            'type': kw_type,
+            'type': kw.type,
             'name': self._escape(self._get_kw_name(kw)),
             'arguments': self._escape(', '.join(kw.args))
         }

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

@@ -33,6 +33,8 @@ or::
     assert Matcher('H?llo').match('Hillo')
 """
 
+import warnings
+
 from .argumentparser import ArgumentParser, cmdline2list
 from .application import Application
 from .compress import compress_text
@@ -52,6 +54,7 @@ from .match import eq, Matcher, MultiMatcher
 from .misc import (classproperty, isatty, parse_re_flags, plural_or_not,
                    printable_name, seq2str, seq2str2, test_or_task)
 from .normalizing import normalize, normalize_whitespace, NormalizedDict
+from .notset import NOT_SET
 from .platform import PY_VERSION, PYPY, UNIXY, WINDOWS, RERAISED_EXCEPTIONS
 from .recommendations import RecommendationFinder
 from .robotenv import get_env_var, set_env_var, del_env_var, get_env_vars
@@ -61,7 +64,7 @@ from .robotpath import abspath, find_file, get_link_path, normpath
 from .robottime import (elapsed_time_to_string, format_time, get_elapsed_time,
                         get_time, get_timestamp, secs_to_timestamp,
                         secs_to_timestr, timestamp_to_secs, timestr_to_secs,
-                        parse_time)
+                        parse_time, parse_timestamp)
 from .robottypes import (has_args, is_bytes, is_dict_like, is_falsy, is_integer,
                          is_list_like, is_number, is_pathlike, is_string, is_truthy,
                          is_union, type_name, type_repr, typeddict_types)
@@ -79,37 +82,49 @@ def read_rest_data(rstfile):
     return read_rest_data(rstfile)
 
 
-# Quietly deprecated utils. Should be deprecated loudly in RF 7.0.
-# https://github.com/robotframework/robotframework/issues/4501
-
-from .robottypes import FALSE_STRINGS, TRUE_STRINGS
-
-
-# Deprecated Python 2/3 compatibility layer. Not needed by Robot Framework itself
-# after RF 5.0 when Python 2 support was dropped. Should be deprecated loudly in
-# RF 7.0. Notice that there's also `PY2` in the `platform` submodule.
-# https://github.com/robotframework/robotframework/issues/4501
-
-from io import StringIO
-
-
-PY3 = True
-PY2 = JYTHON = IRONPYTHON = False
-is_unicode = is_string
-unicode = str
-unic = safe_str
-roundup = round
-
-
-def py2to3(cls):
-    """Deprecated since RF 5.0. Use Python 3 features directly instead."""
-    if hasattr(cls, '__unicode__'):
-        cls.__str__ = lambda self: self.__unicode__()
-    if hasattr(cls, '__nonzero__'):
-        cls.__bool__ = lambda self: self.__nonzero__()
-    return cls
-
-
-def py3to2(cls):
-    """Deprecated since RF 5.0. Never done anything when used on Python 3."""
-    return cls
+def unic(item):
+    # Cannot be deprecated using '__getattr__' because a module with same name exists.
+    warnings.warn("'robot.utils.unic' is deprecated and will be removed in "
+                  "Robot Framework 8.0.")
+    return safe_str(item)
+
+
+def __getattr__(name):
+    # Deprecated utils mostly related to the old Python 2/3 compatibility layer.
+    # See also 'unic' above 'PY2' in the 'platform' module. TODO: Remove in RF 8.0.
+    # https://github.com/robotframework/robotframework/issues/4501
+
+    from io import StringIO
+    from .robottypes import FALSE_STRINGS, TRUE_STRINGS
+
+    def py2to3(cls):
+        if hasattr(cls, '__unicode__'):
+            cls.__str__ = lambda self: self.__unicode__()
+        if hasattr(cls, '__nonzero__'):
+            cls.__bool__ = lambda self: self.__nonzero__()
+        return cls
+
+    def py3to2(cls):
+        return cls
+
+    deprecated = {
+        'FALSE_STRINGS': FALSE_STRINGS,
+        'TRUE_STRINGS': TRUE_STRINGS,
+        'StringIO': StringIO,
+        'PY3': True,
+        'PY2': False,
+        'JYTHON': False,
+        'IRONPYTHON': False,
+        'is_unicode': is_string,
+        'unicode': str,
+        'roundup': round,
+        'py2to3': py2to3,
+        'py3to2': py3to2,
+    }
+
+    if name in deprecated:
+        warnings.warn(f"'robot.utils.{name}' is deprecated and will be removed in "
+                      f"Robot Framework 8.0.")
+        return deprecated[name]
+
+    raise AssertionError(f"'robot.utils' has no attribute '{name}'.")

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/utils/connectioncache.py

@@ -13,17 +13,21 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from typing import Any
+
 from .normalizing import NormalizedDict
-from .robottypes import is_string
+
+
+Connection = Any
 
 
 class ConnectionCache:
     """Cache for libraries to use with concurrent connections, processes, etc.
 
     The cache stores the registered connections (or other objects) and allows
-    switching between them using generated indices or user given aliases.
-    This is useful with any library where there's need for multiple concurrent
-    connections, processes, etc.
+    switching between them using generated indices, user given aliases or
+    connection objects themselves. This is useful with any library having a need
+    for multiple concurrent connections, processes, etc.
 
     This class is used also outside the core framework by SeleniumLibrary,
     SSHLibrary, etc. Backwards compatibility is thus important when doing changes.
@@ -33,10 +37,10 @@ class ConnectionCache:
         self._no_current = NoConnection(no_current_msg)
         self.current = self._no_current  #: Current active connection.
         self._connections = []
-        self._aliases = NormalizedDict()
+        self._aliases = NormalizedDict[int]()
 
     @property
-    def current_index(self):
+    def current_index(self) -> 'int|None':
         if not self:
             return None
         for index, conn in enumerate(self):
@@ -44,11 +48,13 @@ class ConnectionCache:
                 return index + 1
 
     @current_index.setter
-    def current_index(self, index):
-        self.current = self._connections[index - 1] \
-            if index is not None else self._no_current
+    def current_index(self, index: 'int|None'):
+        if index is None:
+            self.current = self._no_current
+        else:
+            self.current = self._connections[index - 1]
 
-    def register(self, connection, alias=None):
+    def register(self, connection: Connection, alias: 'str|None' = None):
         """Registers given connection with optional alias and returns its index.
 
         Given connection is set to be the :attr:`current` connection.
@@ -62,52 +68,74 @@ class ConnectionCache:
         self.current = connection
         self._connections.append(connection)
         index = len(self._connections)
-        if is_string(alias):
+        if alias:
             self._aliases[alias] = index
         return index
 
-    def switch(self, alias_or_index):
-        """Switches to the connection specified by the given alias or index.
+    def switch(self, identifier: 'int|str|Connection') -> Connection:
+        """Switches to the connection specified using the ``identifier``.
 
-        Updates :attr:`current` and also returns its new value.
+        Identifier can be an index, an alias, or a registered connection.
+        Raises an error if no matching connection is found.
 
-        Alias is whatever was given to :meth:`register` method and indices
-        are returned by it. Index can be given either as an integer or
-        as a string that can be converted to an integer. Raises an error
-        if no connection with the given index or alias found.
+        Updates :attr:`current` and also returns its new value.
         """
-        self.current = self.get_connection(alias_or_index)
+        self.current = self.get_connection(identifier)
         return self.current
 
-    def get_connection(self, alias_or_index=None):
-        """Get the connection specified by the given alias or index..
+    def get_connection(self, identifier: 'int|str|Connection|None' = None) -> Connection:
+        """Returns the connection specified using the ``identifier``.
 
-        If ``alias_or_index`` is ``None``, returns the current connection
-        if it is active, or raises an error if it is not.
-
-        Alias is whatever was given to :meth:`register` method and indices
-        are returned by it. Index can be given either as an integer or
-        as a string that can be converted to an integer. Raises an error
-        if no connection with the given index or alias found.
+        Identifier can be an index (integer or string), an alias, a registered
+        connection or ``None``. If the identifier is ``None``, returns the
+        current connection if it is active and raises an error if it is not.
+        Raises an error also if no matching connection is found.
         """
-        if alias_or_index is None:
+        if identifier is None:
             if not self:
                 self.current.raise_error()
             return self.current
         try:
-            index = self.resolve_alias_or_index(alias_or_index)
+            index = self.get_connection_index(identifier)
         except ValueError as err:
             raise RuntimeError(err.args[0])
         return self._connections[index-1]
 
-    __getitem__ = get_connection
+    def get_connection_index(self, identifier: 'int|str|Connection') -> int:
+        """Returns the index of the connection specified using the ``identifier``.
+
+        Identifier can be an index (integer or string), an alias, or a registered
+        connection.
 
-    def close_all(self, closer_method='close'):
-        """Closes connections using given closer method and empties cache.
+        New in Robot Framework 7.0. :meth:`resolve_alias_or_index` can be used
+        with earlier versions.
+        """
+        if isinstance(identifier, str) and identifier in self._aliases:
+            return self._aliases[identifier]
+        if identifier in self._connections:
+            return self._connections.index(identifier) + 1
+        try:
+            index = int(identifier)
+        except (ValueError, TypeError):
+            index = -1
+        if 0 < index <= len(self._connections):
+            return index
+        raise ValueError(f"Non-existing index or alias '{identifier}'.")
+
+    def resolve_alias_or_index(self, alias_or_index):
+        """Deprecated in RF 7.0. Use :meth:`get_connection_index` instead."""
+        # This was initially added for SeleniumLibrary in RF 3.1.2.
+        # https://github.com/robotframework/robotframework/issues/3125
+        # The new method was added in RF 7.0. We can loudly deprecate this
+        # earliest in RF 8.0.
+        return self.get_connection_index(alias_or_index)
+
+    def close_all(self, closer_method: str = 'close'):
+        """Closes connections using the specified closer method and empties cache.
 
         If simply calling the closer method is not adequate for closing
         connections, clients should close connections themselves and use
-        :meth:`empty_cache` afterwards.
+        :meth:`empty_cache` afterward.
         """
         for conn in self._connections:
             getattr(conn, closer_method)()
@@ -123,6 +151,8 @@ class ConnectionCache:
         self._connections = []
         self._aliases = NormalizedDict()
 
+    __getitem__ = get_connection
+
     def __iter__(self):
         return iter(self._connections)
 
@@ -132,31 +162,6 @@ class ConnectionCache:
     def __bool__(self):
         return self.current is not self._no_current
 
-    def resolve_alias_or_index(self, alias_or_index):
-        for resolver in self._resolve_alias, self._resolve_index, self._is_connection:
-            try:
-                return resolver(alias_or_index)
-            except ValueError:
-                pass
-        raise ValueError(f"Non-existing index or alias '{alias_or_index}'.")
-
-    def _resolve_alias(self, alias):
-        if is_string(alias) and alias in self._aliases:
-            return self._aliases[alias]
-        raise ValueError
-
-    def _resolve_index(self, index):
-        try:
-            index = int(index)
-        except TypeError:
-            raise ValueError
-        if not 0 < index <= len(self._connections):
-            raise ValueError
-        return index
-
-    def _is_connection(self, conn):
-        return self._connections.index(conn) + 1
-
 
 class NoConnection:
 

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/utils/encodingsniffer.py

@@ -75,7 +75,7 @@ def _get_unixy_encoding():
 
 
 def _get_stream_output_encoding():
-    # Python 3.6+ uses UTF-8 as encoding with output streams.
+    # Python uses UTF-8 as encoding with output streams.
     # We want the real console encoding regardless the platform.
     if WINDOWS:
         return None

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/utils/escaping.py

@@ -94,27 +94,29 @@ unescape = Unescaper().unescape
 
 
 def split_from_equals(string):
-    from robot.variables import VariableIterator
+    from robot.variables import VariableMatches
     if not is_string(string) or '=' not in string:
         return string, None
-    variables = VariableIterator(string, ignore_errors=True)
-    if not variables and '\\' not in string:
+    matches = VariableMatches(string, ignore_errors=True)
+    if not matches and '\\' not in string:
         return tuple(string.split('=', 1))
     try:
-        index = _find_split_index(string, variables)
+        index = _find_split_index(string, matches)
     except ValueError:
         return string, None
     return string[:index], string[index+1:]
 
 
-def _find_split_index(string, variables):
+def _find_split_index(string, matches):
+    remaining = string
     relative_index = 0
-    for before, match, string in variables:
+    for match in matches:
         try:
-            return _find_split_index_from_part(before) + relative_index
+            return _find_split_index_from_part(match.before) + relative_index
         except ValueError:
-            relative_index += len(before) + len(match)
-    return _find_split_index_from_part(string) + relative_index
+            remaining = match.after
+            relative_index += match.end
+    return _find_split_index_from_part(remaining) + relative_index
 
 
 def _find_split_index_from_part(string):

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/utils/markupwriters.py

@@ -36,17 +36,18 @@ class _MarkupWriter:
     def _preamble(self):
         pass
 
-    def start(self, name, attrs=None, newline=True):
-        attrs = self._format_attrs(attrs)
+    def start(self, name, attrs=None, newline=True, write_empty=None):
+        attrs = self._format_attrs(attrs, write_empty)
         self._start(name, attrs, newline)
 
     def _start(self, name, attrs, newline):
         self._write(f'<{name} {attrs}>' if attrs else f'<{name}>', newline)
 
-    def _format_attrs(self, attrs):
+    def _format_attrs(self, attrs, write_empty):
         if not attrs:
             return ''
-        write_empty = self._write_empty
+        if write_empty is None:
+            write_empty = self._write_empty
         return ' '.join(f"{name}=\"{attribute_escape(value or '')}\""
                         for name, value in self._order_attrs(attrs)
                         if write_empty or value)
@@ -64,9 +65,12 @@ class _MarkupWriter:
     def end(self, name, newline=True):
         self._write(f'</{name}>', newline)
 
-    def element(self, name, content=None, attrs=None, escape=True, newline=True):
-        attrs = self._format_attrs(attrs)
-        if self._write_empty or content or attrs:
+    def element(self, name, content=None, attrs=None, escape=True, newline=True,
+                write_empty=None):
+        attrs = self._format_attrs(attrs, write_empty)
+        if write_empty is None:
+            write_empty = self._write_empty
+        if write_empty or content or attrs:
             self._start(name, attrs, newline=False)
             self.content(content, escape)
             self.end(name, newline)
@@ -98,15 +102,18 @@ class XmlWriter(_MarkupWriter):
     def _escape(self, text):
         return xml_escape(text)
 
-    def element(self, name, content=None, attrs=None, escape=True, newline=True):
+    def element(self, name, content=None, attrs=None, escape=True, newline=True,
+                write_empty=None):
         if content:
-            super().element(name, content, attrs, escape, newline)
+            super().element(name, content, attrs, escape, newline, write_empty)
         else:
-            self._self_closing_element(name, attrs, newline)
+            self._self_closing_element(name, attrs, newline, write_empty)
 
-    def _self_closing_element(self, name, attrs, newline):
-        attrs = self._format_attrs(attrs)
-        if self._write_empty or attrs:
+    def _self_closing_element(self, name, attrs, newline, write_empty):
+        attrs = self._format_attrs(attrs, write_empty)
+        if write_empty is None:
+            write_empty = self._write_empty
+        if write_empty or attrs:
             self._write(f'<{name} {attrs}/>' if attrs else f'<{name}/>', newline)
 
 

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/utils/normalizing.py

@@ -14,47 +14,32 @@
 #  limitations under the License.
 
 import re
-from collections.abc import Iterable, Iterator, Mapping, Sequence
-from typing import Any, MutableMapping, overload, TypeVar
+from collections.abc import Iterator, Mapping, Sequence
+from typing import Any, MutableMapping, TypeVar
 
 
 V = TypeVar('V')
 Self = TypeVar('Self', bound='NormalizedDict')
 
 
-@overload
 def normalize(string: str, ignore: 'Sequence[str]' = (), caseless: bool = True,
               spaceless: bool = True) -> str:
-    ...
-
-
-@overload
-def normalize(string: bytes, ignore: 'Sequence[bytes]' = (), caseless: bool = True,
-              spaceless: bool = True) -> bytes:
-    ...
-
-
-# TODO: Remove bytes support in RF 7.0. There shouldn't be needs for that with Python 3.
-def normalize(string, ignore=(), caseless=True, spaceless=True):
     """Normalize the ``string`` according to the given spec.
 
-    By default, string is turned to lower case and all whitespace is removed.
-    Additional characters can be removed by giving them in ``ignore`` list.
+    By default, string is turned to lower case (actually case-folded) and all
+    whitespace is removed. Additional characters can be removed by giving them
+    in ``ignore`` list.
     """
-    empty = '' if isinstance(string, str) else b''
-    if isinstance(ignore, bytes):
-        # Iterating bytes in Python3 yields integers.
-        ignore = [bytes([i]) for i in ignore]
     if spaceless:
-        string = empty.join(string.split())
+        string = ''.join(string.split())
     if caseless:
-        string = string.lower()
-        ignore = [i.lower() for i in ignore]
+        string = string.casefold()
+        ignore = [i.casefold() for i in ignore]
     # both if statements below enhance performance a little
     if ignore:
         for ign in ignore:
             if ign in string:
-                string = string.replace(ign, empty)
+                string = string.replace(ign, '')
     return string
 
 

robotframework-7.0a1/src/robot/utils/notset.py

@@ -0,0 +1,33 @@
+#  Copyright 2008-2015 Nokia Networks
+#  Copyright 2016-     Robot Framework Foundation
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+class NotSet:
+    """Represents value that is not set.
+
+    Can be used instead of the standard ``None`` in cases where ``None``
+    itself is a valid value.
+
+    Use the constant ``robot.utils.NOT_SET`` instead of creating new instances
+    of the class.
+
+    New in Robot Framework 7.0.
+    """
+
+    def __repr__(self):
+        return ''
+
+
+NOT_SET = NotSet()
+

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/utils/platform.py

@@ -23,11 +23,6 @@ UNIXY = os.sep == '/'
 WINDOWS = not UNIXY
 RERAISED_EXCEPTIONS = (KeyboardInterrupt, SystemExit, MemoryError)
 
-# Part of the deprecated Python 2/3 compatibility layer. For more details see
-# the comment in `utils/__init__.py`. This constant was added to support
-# SSHLibrary: https://github.com/robotframework/SSHLibrary/issues/401
-PY2 = False
-
 
 def isatty(stream):
     # first check if buffer was detached
@@ -39,3 +34,18 @@ def isatty(stream):
         return stream.isatty()
     except ValueError:  # Occurs if file is closed.
         return False
+
+
+def __getattr__(name):
+    # Part of the deprecated Python 2/3 compatibility layer. For more details see
+    # the comment in `utils/__init__.py`. The 'PY2' constant exists here to support
+    # SSHLibrary: https://github.com/robotframework/SSHLibrary/issues/401
+
+    import warnings
+
+    if name == 'PY2':
+        warnings.warn("'robot.utils.platform.PY2' is deprecated and will be removed "
+                      "in Robot Framework 8.0.")
+        return False
+
+    raise AttributeError(f"'robot.utils.platform' has no attribute '{name}'.")

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/utils/robotpath.py

@@ -44,6 +44,7 @@ def normpath(path, case_normalize=False):
        That includes Windows and also OSX in default configuration.
     4. Turn ``c:`` into ``c:\\`` on Windows instead of keeping it as ``c:``.
     """
+    # FIXME: Support pathlib.Path
     if not is_string(path):
         path = system_decode(path)
     path = safe_str(path)  # Handles NFC normalization on OSX