robotframework 6.1rc1__zip → 7.0__zip

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/variables/search.py

@@ -14,59 +14,79 @@
 #  limitations under the License.
 
 import re
+from typing import Iterator, Sequence
 
 from robot.errors import VariableError
 from robot.utils import is_string
 
 
-def search_variable(string, identifiers='$@&%*', ignore_errors=False):
+def search_variable(string: str, identifiers: Sequence[str] = '$@&%*',
+                    ignore_errors: bool = False) -> 'VariableMatch':
     if not (is_string(string) and '{' in string):
         return VariableMatch(string)
     return _search_variable(string, identifiers, ignore_errors)
 
 
-def contains_variable(string, identifiers='$@&'):
+def contains_variable(string: str, identifiers: Sequence[str] = '$@&') -> bool:
     match = search_variable(string, identifiers, ignore_errors=True)
     return bool(match)
 
 
-def is_variable(string, identifiers='$@&'):
+def is_variable(string: str, identifiers: Sequence[str] = '$@&') -> bool:
     match = search_variable(string, identifiers, ignore_errors=True)
     return match.is_variable()
 
 
-def is_scalar_variable(string):
+def is_scalar_variable(string: str) -> bool:
     return is_variable(string, '$')
 
 
-def is_list_variable(string):
+def is_list_variable(string: str) -> bool:
     return is_variable(string, '@')
 
 
-def is_dict_variable(string):
+def is_dict_variable(string: str) -> bool:
     return is_variable(string, '&')
 
 
-def is_assign(string, identifiers='$@&', allow_assign_mark=False, allow_items=False):
+def is_assign(string: str,
+              identifiers: Sequence[str] = '$@&',
+              allow_assign_mark: bool = False,
+              allow_nested: bool = False,
+              allow_items: bool = False) -> bool:
     match = search_variable(string, identifiers, ignore_errors=True)
-    return match.is_assign(allow_assign_mark, allow_items=allow_items)
+    return match.is_assign(allow_assign_mark, allow_nested, allow_items)
 
 
-def is_scalar_assign(string, allow_assign_mark=False, allow_items=False):
-    return is_assign(string, '$', allow_assign_mark, allow_items)
+def is_scalar_assign(string: str,
+                     allow_assign_mark: bool = False,
+                     allow_nested: bool = False,
+                     allow_items: bool = False) -> bool:
+    return is_assign(string, '$', allow_assign_mark, allow_nested, allow_items)
 
 
-def is_list_assign(string, allow_assign_mark=False, allow_items=False):
-    return is_assign(string, '@', allow_assign_mark, allow_items)
+def is_list_assign(string: str,
+                   allow_assign_mark: bool = False,
+                   allow_nested: bool = False,
+                   allow_items: bool = False) -> bool:
+    return is_assign(string, '@', allow_assign_mark, allow_nested, allow_items)
 
 
-def is_dict_assign(string, allow_assign_mark=False, allow_items=False):
-    return is_assign(string, '&', allow_assign_mark, allow_items)
+def is_dict_assign(string: str,
+                   allow_assign_mark: bool = False,
+                   allow_nested: bool = False,
+                   allow_items: bool = False) -> bool:
+    return is_assign(string, '&', allow_assign_mark, allow_nested, allow_items)
 
 
 class VariableMatch:
 
-    def __init__(self, string, identifier=None, base=None, items=(), start=-1, end=-1):
+    def __init__(self, string: str,
+                 identifier: 'str|None' = None,
+                 base: 'str|None' = None,
+                 items: 'tuple[str, ...]' = (),
+                 start: int = -1,
+                 end: int = -1):
         self.string = string
         self.identifier = identifier
         self.base = base
@@ -84,66 +104,70 @@ class VariableMatch:
             )
 
     @property
-    def name(self):
-        return '%s{%s}' % (self.identifier, self.base) if self else None
+    def name(self) -> 'str|None':
+        return f'{self.identifier}{{{self.base}}}' if self.identifier else None
 
     @property
-    def before(self):
+    def before(self) -> str:
         return self.string[:self.start] if self.identifier else self.string
 
     @property
-    def match(self):
+    def match(self) -> 'str|None':
         return self.string[self.start:self.end] if self.identifier else None
 
     @property
-    def after(self):
-        return self.string[self.end:] if self.identifier else None
+    def after(self) -> str:
+        return self.string[self.end:] if self.identifier else ''
 
-    def is_variable(self):
+    def is_variable(self) -> bool:
         return bool(self.identifier
                     and self.base
                     and self.start == 0
                     and self.end == len(self.string))
 
-    def is_scalar_variable(self):
+    def is_scalar_variable(self) -> bool:
         return self.identifier == '$' and self.is_variable()
 
-    def is_list_variable(self):
+    def is_list_variable(self) -> bool:
         return self.identifier == '@' and self.is_variable()
 
-    def is_dict_variable(self):
+    def is_dict_variable(self) -> bool:
         return self.identifier == '&' and self.is_variable()
 
-    def is_assign(self,
-                  allow_assign_mark=False, allow_nested=False, allow_items=False):
+    def is_assign(self, allow_assign_mark: bool = False, allow_nested: bool = False,
+                  allow_items: bool = False) -> bool:
         if allow_assign_mark and self.string.endswith('='):
             match = search_variable(self.string[:-1].rstrip(), ignore_errors=True)
-            return match.is_assign(allow_items=allow_items)
+            return match.is_assign(allow_nested=allow_nested, allow_items=allow_items)
         return (self.is_variable()
                 and self.identifier in '$@&'
                 and (allow_items or not self.items)
                 and (allow_nested or not search_variable(self.base)))
 
-    def is_scalar_assign(self, allow_assign_mark=False, allow_nested=False):
+    def is_scalar_assign(self, allow_assign_mark: bool = False,
+                         allow_nested: bool = False) -> bool:
         return self.identifier == '$' and self.is_assign(allow_assign_mark, allow_nested)
 
-    def is_list_assign(self, allow_assign_mark=False, allow_nested=False):
+    def is_list_assign(self, allow_assign_mark: bool = False,
+                       allow_nested: bool = False) -> bool:
         return self.identifier == '@' and self.is_assign(allow_assign_mark, allow_nested)
 
-    def is_dict_assign(self, allow_assign_mark=False, allow_nested=False):
+    def is_dict_assign(self, allow_assign_mark: bool = False,
+                       allow_nested: bool = False) -> bool:
         return self.identifier == '&' and self.is_assign(allow_assign_mark, allow_nested)
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         return self.identifier is not None
 
-    def __str__(self):
+    def __str__(self) -> str:
         if not self:
             return '<no match>'
         items = ''.join('[%s]' % i for i in self.items) if self.items else ''
         return '%s{%s}%s' % (self.identifier, self.base, items)
 
 
-def _search_variable(string, identifiers, ignore_errors=False):
+def _search_variable(string: str, identifiers: Sequence[str],
+                     ignore_errors: bool = False) -> VariableMatch:
     start = _find_variable_start(string, identifiers)
     if start < 0:
         return VariableMatch(string)
@@ -194,7 +218,7 @@ def _search_variable(string, identifiers, ignore_errors=False):
             raise VariableError(f"Variable '{incomplete}' was not closed properly.")
         raise VariableError(f"Variable item '{incomplete}' was not closed properly.")
 
-    return match if match else VariableMatch(match)
+    return match
 
 
 def _find_variable_start(string, identifiers):
@@ -233,26 +257,27 @@ def unescape_variable_syntax(item):
     return re.sub(r'(\\+)(?=(.+))', handle_escapes, item)
 
 
-class VariableIterator:
+class VariableMatches:
 
-    def __init__(self, string, identifiers='$@&%', ignore_errors=False):
+    def __init__(self, string: str, identifiers: Sequence[str] = '$@&%',
+                 ignore_errors: bool = False):
         self.string = string
         self.identifiers = identifiers
         self.ignore_errors = ignore_errors
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[VariableMatch]:
         remaining = self.string
         while True:
             match = search_variable(remaining, self.identifiers, self.ignore_errors)
             if not match:
                 break
             remaining = match.after
-            yield match.before, match.match, remaining
+            yield match
 
-    def __len__(self):
+    def __len__(self) -> int:
         return sum(1 for _ in self)
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         try:
             next(iter(self))
         except StopIteration:

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/variables/store.py

@@ -14,14 +14,12 @@
 #  limitations under the License.
 
 from robot.errors import DataError, VariableError
-from robot.utils import DotDict, is_dict_like, is_list_like, NormalizedDict, type_name
+from robot.utils import (DotDict, is_dict_like, is_list_like, NormalizedDict, NOT_SET,
+                         type_name)
 
 from .notfound import variable_not_found
 from .resolvable import GlobalVariableValue, Resolvable
-from .search import is_assign
-
-
-NOT_SET = object()
+from .search import is_assign, unescape_variable_syntax
 
 
 class VariableStore:
@@ -48,7 +46,7 @@ class VariableStore:
             # Recursive resolving may have already removed variable.
             if name in self.data:
                 self.data.pop(name)
-                value.report_error(err)
+                value.report_error(str(err))
             variable_not_found('${%s}' % name, self.data)
         return self.data[name]
 
@@ -68,7 +66,7 @@ class VariableStore:
             if decorated:
                 name = self._undecorate(name)
             return self[name]
-        except VariableError:
+        except DataError:
             if default is NOT_SET:
                 raise
             return default
@@ -88,26 +86,26 @@ class VariableStore:
             self.data[name] = value
 
     def _undecorate(self, name):
-        if not is_assign(name):
-            raise VariableError("Invalid variable name '%s'." % name)
-        return name[2:-1]
+        if not is_assign(name, allow_nested=True):
+            raise DataError(f"Invalid variable name '{name}'.")
+        return self._variables.replace_string(
+            name[2:-1], custom_unescaper=unescape_variable_syntax
+        )
 
     def _undecorate_and_validate(self, name, value):
         undecorated = self._undecorate(name)
+        if isinstance(value, Resolvable):
+            return undecorated, value
         if name[0] == '@':
             if not is_list_like(value):
-                self._raise_cannot_set_type(name, value, 'list')
+                raise DataError(f'Expected list-like value, got {type_name(value)}.')
             value = list(value)
         if name[0] == '&':
             if not is_dict_like(value):
-                self._raise_cannot_set_type(name, value, 'dictionary')
+                raise DataError(f'Expected dictionary-like value, got {type_name(value)}.')
             value = DotDict(value)
         return undecorated, value
 
-    def _raise_cannot_set_type(self, name, value, expected):
-        raise VariableError("Cannot set variable '%s': Expected %s-like value, got %s."
-                            % (name, expected, type_name(value)))
-
     def __len__(self):
         return len(self.data)
 

robotframework-7.0/src/robot/variables/tablesetter.py

@@ -0,0 +1,164 @@
+#  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 contextlib import contextmanager
+from typing import Sequence, TYPE_CHECKING
+
+from robot.errors import DataError
+from robot.utils import DotDict, split_from_equals
+
+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 .store import VariableStore
+
+
+class VariableTableSetter:
+
+    def __init__(self, store: 'VariableStore'):
+        self.store = store
+
+    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)
+            except DataError as err:
+                var.report_error(str(err))
+
+
+class VariableResolver(Resolvable):
+
+    def __init__(self, value: Sequence[str], error_reporter=None):
+        self.value = tuple(value)
+        self.error_reporter = error_reporter
+        self._resolving = False
+
+    @classmethod
+    def from_name_and_value(cls, name: str, value: 'str|Sequence[str]',
+                            separator: 'str|None' = None,
+                            error_reporter=None) -> 'VariableResolver':
+        if not is_assign(name, allow_nested=True):
+            raise DataError(f"Invalid variable name '{name}'.")
+        if name[0] == '$':
+            return ScalarVariableResolver(value, separator, error_reporter)
+        if separator is not None:
+            raise DataError('Only scalar variables support separators.')
+        klass = {'@': ListVariableResolver,
+                 '&': DictVariableResolver}[name[0]]
+        return klass(value, error_reporter)
+
+    @classmethod
+    def from_variable(cls, var: 'Var|Variable') -> 'VariableResolver':
+        if var.error:
+            raise DataError(var.error)
+        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:
+            raise DataError('Recursive variable definition.')
+        self._resolving = True
+        try:
+            yield
+        finally:
+            self._resolving = False
+
+    def _replace_variables(self, variables):
+        raise NotImplementedError
+
+    def report_error(self, error):
+        if self.error_reporter:
+            self.error_reporter(error)
+        else:
+            raise DataError(f'Error reporter not set. Reported error was: {error}')
+
+
+class ScalarVariableResolver(VariableResolver):
+
+    def __init__(self, value: 'str|Sequence[str]', separator: 'str|None' = None,
+                 error_reporter=None):
+        value, separator = self._get_value_and_separator(value, separator)
+        super().__init__(value, error_reporter)
+        self.separator = separator
+
+    def _get_value_and_separator(self, value, separator):
+        if isinstance(value, str):
+            value = [value]
+        elif separator is None and value and value[0].startswith('SEPARATOR='):
+            separator = value[0][10:]
+            value = value[1:]
+        return value, separator
+
+    def _replace_variables(self, variables):
+        value, separator = self.value, self.separator
+        if self._is_single_value(value, separator):
+            return variables.replace_scalar(value[0])
+        if separator is None:
+            separator = ' '
+        else:
+            separator = variables.replace_string(separator)
+        value = variables.replace_list(value)
+        return separator.join(str(item) for item in value)
+
+    def _is_single_value(self, value, separator):
+        return separator is None and len(value) == 1 and not is_list_variable(value[0])
+
+
+class ListVariableResolver(VariableResolver):
+
+    def _replace_variables(self, variables):
+        return variables.replace_list(self.value)
+
+
+class DictVariableResolver(VariableResolver):
+
+    def __init__(self, value: Sequence[str], error_reporter=None):
+        super().__init__(tuple(self._yield_formatted(value)), error_reporter)
+
+    def _yield_formatted(self, values):
+        for item in values:
+            if is_dict_variable(item):
+                yield item
+            else:
+                name, value = split_from_equals(item)
+                if value is None:
+                    raise DataError(
+                        f"Invalid dictionary variable item '{item}'. Items must use "
+                        f"'name=value' syntax or be dictionary variables themselves."
+                    )
+                yield name, value
+
+    def _replace_variables(self, variables):
+        try:
+            return DotDict(self._yield_replaced(self.value, variables.replace_scalar))
+        except TypeError as err:
+            raise DataError(f'Creating dictionary variable failed: {err}')
+
+    def _yield_replaced(self, values, replace_scalar):
+        for item in values:
+            if isinstance(item, tuple):
+                key, values = item
+                yield replace_scalar(key), replace_scalar(values)
+            else:
+                yield from replace_scalar(item).items()

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/variables/variables.py

@@ -61,7 +61,7 @@ class Variables:
         setter = VariableFileSetter(self.store)
         return setter.set(path_or_variables, args, overwrite)
 
-    def set_from_variable_table(self, variables, overwrite=False):
+    def set_from_variable_section(self, variables, overwrite=False):
         setter = VariableTableSetter(self.store)
         setter.set(variables, overwrite)
 

{robotframework-6.1rc1 → robotframework-7.0}/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 = '6.1rc1'
+VERSION = '7.0'
 
 
 def get_version(naked=False):

{robotframework-6.1rc1 → robotframework-7.0}/src/robotframework.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework
-Version: 6.1rc1
+Version: 7.0
 Summary: Generic automation framework for acceptance testing and robotic process automation (RPA)
 Home-page: https://robotframework.org
 Author: Pekka Klärck
@@ -10,9 +10,8 @@ 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-6.1rc1.rst
+Project-URL: Release Notes, https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.0.rst
 Project-URL: Slack, http://slack.robotframework.org
-Project-URL: Twitter, https://twitter.com/robotframework
 Description: Robot Framework
         ===============
         
@@ -64,10 +63,12 @@ Description: Robot Framework
         For more detailed installation instructions, including installing Python, see
         `INSTALL.rst <https://github.com/robotframework/robotframework/blob/master/INSTALL.rst>`__.
         
-        Robot Framework requires Python 3.6 or newer and runs also on `PyPy <http://pypy.org>`_.
+        Robot Framework requires Python 3.8 or newer and runs also on `PyPy <http://pypy.org>`_.
+        The latest version that supports Python 3.6 and 3.7 is `Robot Framework 6.1.1`__.
         If you need to use Python 2, `Jython <http://jython.org>`_ or
         `IronPython <http://ironpython.net>`_, you can use `Robot Framework 4.1.3`__.
         
+        __ https://github.com/robotframework/robotframework/tree/v6.1.1#readme
         __ https://github.com/robotframework/robotframework/tree/v4.1.3#readme
         
         Example
@@ -132,7 +133,6 @@ Description: Robot Framework
         - `Forum <https://forum.robotframework.org/>`_
         - `robotframework-users
           <https://groups.google.com/group/robotframework-users/>`_ mailing list
-        - `@robotframework <https://twitter.com/robotframework>`_ on Twitter
         
         Contributing
         ------------
@@ -171,8 +171,6 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -184,5 +182,5 @@ Classifier: Topic :: Software Development :: Testing
 Classifier: Topic :: Software Development :: Testing :: Acceptance
 Classifier: Topic :: Software Development :: Testing :: BDD
 Classifier: Framework :: Robot Framework
-Requires-Python: >=3.6
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst

{robotframework-6.1rc1 → robotframework-7.0}/src/robotframework.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ src/robot/api/exceptions.py
 src/robot/api/interfaces.py
 src/robot/api/logger.py
 src/robot/api/parsing.py
+src/robot/api/py.typed
 src/robot/conf/__init__.py
 src/robot/conf/gatherfailed.py
 src/robot/conf/languages.py
@@ -86,7 +87,6 @@ src/robot/libraries/Easter.py
 src/robot/libraries/OperatingSystem.py
 src/robot/libraries/Process.py
 src/robot/libraries/Remote.py
-src/robot/libraries/Reserved.py
 src/robot/libraries/Screenshot.py
 src/robot/libraries/String.py
 src/robot/libraries/Telnet.py
@@ -120,10 +120,9 @@ src/robot/output/__init__.py
 src/robot/output/debugfile.py
 src/robot/output/filelogger.py
 src/robot/output/librarylogger.py
-src/robot/output/listenerarguments.py
-src/robot/output/listenermethods.py
 src/robot/output/listeners.py
 src/robot/output/logger.py
+src/robot/output/loggerapi.py
 src/robot/output/loggerhelper.py
 src/robot/output/output.py
 src/robot/output/pyloggingconf.py
@@ -181,24 +180,24 @@ src/robot/running/__init__.py
 src/robot/running/bodyrunner.py
 src/robot/running/context.py
 src/robot/running/dynamicmethods.py
-src/robot/running/handlers.py
-src/robot/running/handlerstore.py
 src/robot/running/importer.py
+src/robot/running/invalidkeyword.py
+src/robot/running/keywordfinder.py
+src/robot/running/keywordimplementation.py
+src/robot/running/librarykeyword.py
 src/robot/running/librarykeywordrunner.py
 src/robot/running/libraryscopes.py
 src/robot/running/model.py
-src/robot/running/modelcombiner.py
 src/robot/running/namespace.py
 src/robot/running/outputcapture.py
 src/robot/running/randomizer.py
+src/robot/running/resourcemodel.py
 src/robot/running/runkwregister.py
 src/robot/running/signalhandler.py
 src/robot/running/status.py
 src/robot/running/statusreporter.py
 src/robot/running/suiterunner.py
 src/robot/running/testlibraries.py
-src/robot/running/usererrorhandler.py
-src/robot/running/userkeyword.py
 src/robot/running/userkeywordrunner.py
 src/robot/running/arguments/__init__.py
 src/robot/running/arguments/argumentconverter.py
@@ -210,6 +209,8 @@ src/robot/running/arguments/argumentvalidator.py
 src/robot/running/arguments/customconverters.py
 src/robot/running/arguments/embedded.py
 src/robot/running/arguments/typeconverters.py
+src/robot/running/arguments/typeinfo.py
+src/robot/running/arguments/typeinfoparser.py
 src/robot/running/arguments/typevalidator.py
 src/robot/running/builder/__init__.py
 src/robot/running/builder/builders.py
@@ -241,6 +242,7 @@ src/robot/utils/markupwriters.py
 src/robot/utils/match.py
 src/robot/utils/misc.py
 src/robot/utils/normalizing.py
+src/robot/utils/notset.py
 src/robot/utils/platform.py
 src/robot/utils/recommendations.py
 src/robot/utils/restreader.py

{robotframework-6.1rc1 → robotframework-7.0}/tasks.py

@@ -33,9 +33,9 @@ and bug fixes. **MORE intro stuff...**
 All issues targeted for Robot Framework {version.milestone} can be found
 from the `issue tracker milestone`_.
 
-Questions and comments related to the release can be sent to the
-`robotframework-users`_ mailing list or to `Robot Framework Slack`_,
-and possible bugs submitted to the `issue tracker`_.
+Questions and comments related to the release can be sent to the `#devel`
+channel on `Robot Framework Slack`_ and possible bugs submitted to
+the `issue tracker`_.
 
 **REMOVE ``--pre`` from the next command with final releases.**
 If you have pip_ installed, just run
@@ -50,9 +50,9 @@ to install the latest available release or use
 
    pip install robotframework=={version}
 
-to install exactly this version. Alternatively you can download the source
-distribution from PyPI_ and install it manually. For more details and other
-installation approaches, see the `installation instructions`_.
+to install exactly this version. Alternatively you can download the package
+from PyPI_ and install it manually. For more details and other installation
+approaches, see the `installation instructions`_.
 
 Robot Framework {version} was released on {date}.