robotframework 6.1.1__zip → 7.0__zip

robotframework-7.0/src/robot/running/userkeywordrunner.py

@@ -0,0 +1,260 @@
+#  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.
+
+from itertools import chain
+from typing import TYPE_CHECKING
+
+from robot.errors import (DataError, ExecutionFailed, ExecutionPassed, ExecutionStatus,
+                          PassExecution, ReturnFromKeyword, UserKeywordExecutionFailed,
+                          VariableError)
+from robot.result import Keyword as KeywordResult
+from robot.utils import DotDict, getshortdoc, prepr, split_tags_from_doc
+from robot.variables import is_list_variable, VariableAssignment
+
+from .arguments import ArgumentSpec, DefaultValue
+from .bodyrunner import BodyRunner, KeywordRunner
+from .model import Keyword as KeywordData
+from .statusreporter import StatusReporter
+from .timeouts import KeywordTimeout
+
+if TYPE_CHECKING:
+    from .resourcemodel import UserKeyword
+
+
+class UserKeywordRunner:
+
+    def __init__(self, keyword: 'UserKeyword', name: 'str|None' = None):
+        self.keyword = keyword
+        self.name = name or keyword.name
+        self.pre_run_messages = ()
+
+    def run(self, data: KeywordData, result: KeywordResult, context, run=True):
+        kw = self.keyword.bind(data)
+        assignment = VariableAssignment(data.assign)
+        self._config_result(result, data, kw, assignment, context.variables)
+        with StatusReporter(data, result, context, run, implementation=kw):
+            if kw.private:
+                context.warn_on_invalid_private_call(kw)
+            with assignment.assigner(context) as assigner:
+                if run:
+                    return_value = self._run(data, kw, result, context)
+                    assigner.assign(return_value)
+                    return return_value
+
+    def _config_result(self, result: KeywordResult, data: KeywordData,
+                       kw: 'UserKeyword', assignment, variables):
+        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,
+                      assign=tuple(assignment),
+                      tags=tags,
+                      type=data.type)
+
+    def _run(self, data: KeywordData, kw: 'UserKeyword', result: KeywordResult, context):
+        if self.pre_run_messages:
+            for message in self.pre_run_messages:
+                context.output.message(message)
+        variables = context.variables
+        positional, named = self._resolve_arguments(kw, data.args, variables)
+        with context.user_keyword(kw):
+            self._set_arguments(kw, positional, named, context)
+            if kw.timeout:
+                timeout = KeywordTimeout(kw.timeout, variables)
+                result.timeout = str(timeout)
+            else:
+                timeout = None
+            with context.timeout(timeout):
+                exception, return_value = self._execute(kw, result, context)
+                if exception and not exception.can_continue(context):
+                    raise exception
+                return_value = self._handle_return_value(return_value, variables)
+                if exception:
+                    exception.return_value = return_value
+                    raise exception
+                return return_value
+
+    def _resolve_arguments(self, kw: 'UserKeyword', args, variables=None):
+        return kw.resolve_arguments(args, variables)
+
+    def _set_arguments(self, kw: 'UserKeyword', positional, named, context):
+        variables = context.variables
+        positional, named = kw.args.map(positional, named, replace_defaults=False)
+        self._set_variables(kw.args, positional, named, variables)
+        context.output.trace(lambda: self._trace_log_args_message(kw, variables),
+                             write_if_flat=False)
+
+    def _set_variables(self, spec: ArgumentSpec, positional, named, variables):
+        positional, var_positional = self._separate_positional(spec, positional)
+        named_only, var_named = self._separate_named(spec, named)
+        for name, value in chain(zip(spec.positional, positional), named_only):
+            if isinstance(value, DefaultValue):
+                value = value.resolve(variables)
+            variables[f'${{{name}}}'] = value
+        if spec.var_positional:
+            variables[f'@{{{spec.var_positional}}}'] = var_positional
+        if spec.var_named:
+            variables[f'&{{{spec.var_named}}}'] = DotDict(var_named)
+
+    def _separate_positional(self, spec: ArgumentSpec, positional):
+        if not spec.var_positional:
+            return positional, []
+        count = len(spec.positional)
+        return positional[:count], positional[count:]
+
+    def _separate_named(self, spec: ArgumentSpec, named):
+        named_only = []
+        var_named = []
+        for name, value in named:
+            target = named_only if name in spec.named_only else var_named
+            target.append((name, value))
+        return named_only, var_named
+
+    def _trace_log_args_message(self, kw: 'UserKeyword', variables):
+        return self._format_trace_log_args_message(
+            self._format_args_for_trace_logging(kw.args), variables
+        )
+
+    def _format_args_for_trace_logging(self, spec: ArgumentSpec):
+        args = [f'${{{arg}}}' for arg in spec.positional]
+        if spec.var_positional:
+            args.append(f'@{{{spec.var_positional}}}')
+        if spec.var_named:
+            args.append(f'&{{{spec.var_named}}}')
+        return args
+
+    def _format_trace_log_args_message(self, args, variables):
+        args = ' | '.join(f'{name}={prepr(variables[name])}' for name in args)
+        return f'Arguments: [ {args} ]'
+
+    def _execute(self, kw: 'UserKeyword', result: KeywordResult, context):
+        if kw.error:
+            raise DataError(kw.error)
+        if not kw.body:
+            raise DataError('User keyword cannot be empty.')
+        if not kw.name:
+            raise DataError('User keyword name cannot be empty.')
+        if context.dry_run and kw.tags.robot('no-dry-run'):
+            return None, None
+        error = success = return_value = None
+        if kw.setup:
+            error = self._run_setup_or_teardown(kw.setup, result.setup, context)
+        try:
+            BodyRunner(context, run=not error).run(kw, result)
+        except ReturnFromKeyword as exception:
+            return_value = exception.return_value
+            error = exception.earlier_failures
+        except ExecutionPassed as exception:
+            success = exception
+            error = exception.earlier_failures
+            if error:
+                error.continue_on_failure = False
+        except ExecutionFailed as exception:
+            error = exception
+        if kw.teardown:
+            with context.keyword_teardown(error):
+                td_error = self._run_setup_or_teardown(kw.teardown, result.teardown,
+                                                       context)
+        else:
+            td_error = None
+        if error or td_error:
+            error = UserKeywordExecutionFailed(error, td_error)
+        return error or success, return_value
+
+    def _handle_return_value(self, return_value, variables):
+        if not return_value:
+            return None
+        contains_list_var = any(is_list_variable(item) for item in return_value)
+        try:
+            return_value = variables.replace_list(return_value)
+        except DataError as err:
+            raise VariableError(f'Replacing variables from keyword return '
+                                f'value failed: {err}')
+        if len(return_value) != 1 or contains_list_var:
+            return return_value
+        return return_value[0]
+
+    def _run_setup_or_teardown(self, data: KeywordData, result: KeywordResult,
+                               context):
+        try:
+            name = context.variables.replace_string(data.name)
+        except DataError as err:
+            if context.dry_run:
+                return None
+            return ExecutionFailed(err.message, syntax=True)
+        if name.upper() in ('', 'NONE'):
+            return None
+        try:
+            KeywordRunner(context).run(data, result, name)
+        except PassExecution:
+            return None
+        except ExecutionStatus as err:
+            return err
+        return None
+
+    def dry_run(self, data: KeywordData, result: KeywordResult, context):
+        kw = self.keyword.bind(data)
+        assignment = VariableAssignment(data.assign)
+        self._config_result(result, data, kw, assignment, context.variables)
+        with StatusReporter(data, result, context, implementation=kw):
+            assignment.validate_assignment()
+            self._dry_run(data, kw, result, context)
+
+    def _dry_run(self, data: KeywordData, kw: 'UserKeyword', result: KeywordResult,
+                 context):
+        if self.pre_run_messages:
+            for message in self.pre_run_messages:
+                context.output.message(message)
+        self._resolve_arguments(kw, data.args)
+        with context.user_keyword(kw):
+            if kw.timeout:
+                timeout = KeywordTimeout(kw.timeout, context.variables)
+                result.timeout = str(timeout)
+            error, _ = self._execute(kw, result, context)
+            if error:
+                raise error
+
+
+class EmbeddedArgumentsRunner(UserKeywordRunner):
+
+    def __init__(self, keyword: 'UserKeyword', name: str):
+        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)
+        if variables:
+            embedded = [variables.replace_scalar(e) for e in self.embedded_args]
+            self.embedded_args = kw.embedded.map(embedded)
+        return result
+
+    def _set_arguments(self, kw: 'UserKeyword', positional, named, context):
+        variables = context.variables
+        for name, value in self.embedded_args:
+            variables[f'${{{name}}}'] = value
+        super()._set_arguments(kw, positional, named, context)
+
+    def _trace_log_args_message(self, kw: 'UserKeyword', variables):
+        args = [f'${{{arg}}}' for arg in kw.embedded.args]
+        args += self._format_args_for_trace_logging(kw.args)
+        return self._format_trace_log_args_message(args, variables)
+
+    def _config_result(self, result: KeywordResult, data: KeywordData,
+                       kw: 'UserKeyword', assignment, variables):
+        super()._config_result(result, data, kw, assignment, variables)
+        result.source_name = kw.name

{robotframework-6.1.1 → robotframework-7.0}/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.0}/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,52 @@ 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 9.0.", DeprecationWarning)
+    return safe_str(item)
+
+
+def __getattr__(name):
+    # Deprecated utils mostly related to the old Python 2/3 compatibility layer.
+    # See also 'unic' above and 'PY2' in 'platform.py'.
+    # 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:
+        # TODO: Change DeprecationWarning to more visible UserWarning in RF 8.0.
+        # https://github.com/robotframework/robotframework/issues/4501
+        # Remember also 'unic' above '__getattr__' and 'PY2' in 'platform.py'.
+        warnings.warn(f"'robot.utils.{name}' is deprecated and will be removed in "
+                      f"Robot Framework 9.0.", DeprecationWarning)
+        return deprecated[name]
+
+    raise AttributeError(f"'robot.utils' has no attribute '{name}'.")

{robotframework-6.1.1 → robotframework-7.0}/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.0}/src/robot/utils/dotdict.py

@@ -60,6 +60,9 @@ class DotDict(OrderedDict):
     def __eq__(self, other):
         return dict.__eq__(self, other)
 
+    def __ne__(self, other):
+        return not self == other
+
     def __str__(self):
         return '{%s}' % ', '.join('%r: %r' % (key, self[key]) for key in self)
 

{robotframework-6.1.1 → robotframework-7.0}/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