robotframework 6.1.1__zip → 7.0a1__zip

{robotframework-6.1.1 → robotframework-7.0a1}/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.0a1/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.1.1 → robotframework-7.0a1}/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.1.1 → robotframework-7.0a1}/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.1.1'
+VERSION = '7.0a1'
 
 
 def get_version(naked=False):

{robotframework-6.1.1 → robotframework-7.0a1/src/robotframework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework
-Version: 6.1.1
+Version: 7.0a1
 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.1.1.rst
+Project-URL: Release Notes, https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.0a1.rst
 Project-URL: Slack, http://slack.robotframework.org
-Project-URL: Twitter, https://twitter.com/robotframework
 Description: Robot Framework
         ===============
         
@@ -171,8 +170,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 +181,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.1.1 → robotframework-7.0a1}/src/robotframework.egg-info/SOURCES.txt

@@ -86,7 +86,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 +119,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
@@ -187,7 +185,6 @@ src/robot/running/importer.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
@@ -210,6 +207,7 @@ 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/typevalidator.py
 src/robot/running/builder/__init__.py
 src/robot/running/builder/builders.py
@@ -241,6 +239,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.1.1 → robotframework-7.0a1}/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}.
 

robotframework-6.1.1/src/robot/libraries/Reserved.py

@@ -1,48 +0,0 @@
-#  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 robot.running import RUN_KW_REGISTER
-
-
-RESERVED_KEYWORDS = ['for', 'while', 'break', 'continue', 'end',
-                     'if', 'else', 'elif', 'else if', 'return']
-
-
-class Reserved:
-    ROBOT_LIBRARY_SCOPE = 'GLOBAL'
-
-    def __init__(self):
-        for kw in RESERVED_KEYWORDS:
-            self._add_reserved(kw)
-
-    def _add_reserved(self, kw):
-        RUN_KW_REGISTER.register_run_keyword('Reserved', kw,
-                                             args_to_process=0,
-                                             deprecation_warning=False)
-        self.__dict__[kw] = lambda *args, **kwargs: self._run_reserved(kw)
-
-    def _run_reserved(self, kw):
-        error = "'%s' is a reserved keyword." % kw.title()
-        if kw in ('for', 'end', 'if', 'else', 'else if'):
-            error += " It must be an upper case '%s'" % kw.upper()
-            if kw in ('else', 'else if'):
-                error += " and follow an opening 'IF'"
-            if kw == 'end':
-                error += " when used as a marker to close a block."
-            else:
-                error += " when used as a marker."
-        if kw == 'elif':
-            error += " The marker to use with 'IF' is 'ELSE IF'."
-        raise Exception(error)

robotframework-6.1.1/src/robot/model/keyword.py

@@ -1,173 +0,0 @@
-#  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 typing import cast, Sequence, Type, TYPE_CHECKING
-import warnings
-
-from .body import Body, BodyItem, BodyItemParent
-from .itemlist import ItemList
-from .modelobject import DataDict
-
-if TYPE_CHECKING:
-    from .visitor import SuiteVisitor
-
-
-@Body.register
-class Keyword(BodyItem):
-    """Base model for a single keyword.
-
-    Extended by :class:`robot.running.model.Keyword` and
-    :class:`robot.result.model.Keyword`.
-    """
-    repr_args = ('name', 'args', 'assign')
-    __slots__ = ['_name', 'args', 'assign', 'type']
-
-    def __init__(self, name: 'str|None' = '',
-                 args: Sequence[str] = (),
-                 assign: Sequence[str] = (),
-                 type: str = BodyItem.KEYWORD,
-                 parent: BodyItemParent = None):
-        self.name = name
-        self.args = tuple(args)
-        self.assign = tuple(assign)
-        self.type = type
-        self.parent = parent
-
-    @property
-    def name(self) -> 'str|None':
-        return self._name
-
-    @name.setter
-    def name(self, name: 'str|None'):
-        self._name = name
-
-    @property
-    def id(self) -> 'str|None':
-        if not self:
-            return None
-        return super().id
-
-    def visit(self, visitor: 'SuiteVisitor'):
-        """:mod:`Visitor interface <robot.model.visitor>` entry-point."""
-        if self:
-            visitor.visit_keyword(self)
-
-    def __bool__(self) -> bool:
-        return self.name is not None
-
-    def __str__(self) -> str:
-        parts = list(self.assign) + [self.name] + list(self.args)
-        return '    '.join(str(p) for p in parts)
-
-    def to_dict(self) -> DataDict:
-        data: DataDict = {'name': self.name}
-        if self.args:
-            data['args'] = self.args
-        if self.assign:
-            data['assign'] = self.assign
-        return data
-
-
-# FIXME: Remote in RF 7.
-class Keywords(ItemList[BodyItem]):
-    """A list-like object representing keywords in a suite, a test or a keyword.
-
-    Read-only and deprecated since Robot Framework 4.0.
-    """
-    __slots__ = []
-    deprecation_message = (
-        "'keywords' attribute is read-only and deprecated since Robot Framework 4.0. "
-        "Use 'body', 'setup' or 'teardown' instead."
-    )
-
-    def __init__(self, parent: BodyItemParent = None,
-                 keywords: Sequence[BodyItem] = ()):
-        warnings.warn(self.deprecation_message, UserWarning)
-        ItemList.__init__(self, object, {'parent': parent})
-        if keywords:
-            ItemList.extend(self, keywords)
-
-    @property
-    def setup(self) -> 'Keyword|None':
-        if self and self[0].type == 'SETUP':
-            return cast(Keyword, self[0])
-        return None
-
-    @setup.setter
-    def setup(self, kw):
-        self.raise_deprecation_error()
-
-    def create_setup(self, *args, **kwargs):
-        self.raise_deprecation_error()
-
-    @property
-    def teardown(self) -> 'Keyword|None':
-        if self and self[-1].type == 'TEARDOWN':
-            return cast(Keyword, self[-1])
-        return None
-
-    @teardown.setter
-    def teardown(self, kw: Keyword):
-        self.raise_deprecation_error()
-
-    def create_teardown(self, *args, **kwargs):
-        self.raise_deprecation_error()
-
-    @property
-    def all(self) -> 'Keywords':
-        """Iterates over all keywords, including setup and teardown."""
-        return self
-
-    @property
-    def normal(self) -> 'list[BodyItem]':
-        """Iterates over normal keywords, omitting setup and teardown."""
-        return [kw for kw in self if kw.type not in ('SETUP', 'TEARDOWN')]
-
-    def __setitem__(self, index: int, item: Keyword):
-        self.raise_deprecation_error()
-
-    def create(self, *args, **kwargs):
-        self.raise_deprecation_error()
-
-    def append(self, item: Keyword):
-        self.raise_deprecation_error()
-
-    def extend(self, items: Sequence[Keyword]):
-        self.raise_deprecation_error()
-
-    def insert(self, index: int, item: Keyword):
-        self.raise_deprecation_error()
-
-    def pop(self, *index: int):
-        self.raise_deprecation_error()
-
-    def remove(self, item: Keyword):
-        self.raise_deprecation_error()
-
-    def clear(self):
-        self.raise_deprecation_error()
-
-    def __delitem__(self, index: int):
-        self.raise_deprecation_error()
-
-    def sort(self):
-        self.raise_deprecation_error()
-
-    def reverse(self):
-        self.raise_deprecation_error()
-
-    @classmethod
-    def raise_deprecation_error(cls: 'Type[Keywords]'):
-        raise AttributeError(cls.deprecation_message)

robotframework-6.1.1/src/robot/output/console/dotted.py

@@ -1,90 +0,0 @@
-#  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.
-
-import sys
-
-from robot.model import SuiteVisitor
-from robot.utils import plural_or_not, secs_to_timestr
-
-from .highlighting import HighlightingStream
-
-
-class DottedOutput:
-
-    def __init__(self, width=78, colors='AUTO', stdout=None, stderr=None):
-        self._width = width
-        self._stdout = HighlightingStream(stdout or sys.__stdout__, colors)
-        self._stderr = HighlightingStream(stderr or sys.__stderr__, colors)
-        self._markers_on_row = 0
-
-    def start_suite(self, suite):
-        if not suite.parent:
-            self._stdout.write("Running suite '%s' with %d %s%s.\n"
-                               % (suite.name, suite.test_count,
-                                  'test' if not suite.rpa else 'task',
-                                  plural_or_not(suite.test_count)))
-            self._stdout.write('=' * self._width + '\n')
-
-    def end_test(self, test):
-        if self._markers_on_row == self._width:
-            self._stdout.write('\n')
-            self._markers_on_row = 0
-        self._markers_on_row += 1
-        if test.passed:
-            self._stdout.write('.')
-        elif test.skipped:
-            self._stdout.highlight('s', 'SKIP')
-        elif test.tags.robot('exit'):
-            self._stdout.write('x')
-        else:
-            self._stdout.highlight('F', 'FAIL')
-
-    def end_suite(self, suite):
-        if not suite.parent:
-            self._stdout.write('\n')
-            StatusReporter(self._stdout, self._width).report(suite)
-            self._stdout.write('\n')
-
-    def message(self, msg):
-        if msg.level in ('WARN', 'ERROR'):
-            self._stderr.error(msg.message, msg.level)
-
-    def output_file(self, name, path):
-        self._stdout.write('%-8s %s\n' % (name+':', path))
-
-
-class StatusReporter(SuiteVisitor):
-
-    def __init__(self, stream, width):
-        self._stream = stream
-        self._width = width
-
-    def report(self, suite):
-        suite.visit(self)
-        stats = suite.statistics
-        self._stream.write("%s\nRun suite '%s' with %d %s%s in %s.\n\n"
-                           % ('=' * self._width, suite.name, stats.total,
-                              'test' if not suite.rpa else 'task',
-                              plural_or_not(stats.total),
-                              secs_to_timestr(suite.elapsedtime/1000.0)))
-        self._stream.highlight(suite.status + ('PED' if suite.status == 'SKIP' else 'ED'), suite.status)
-        self._stream.write('\n%s\n' % stats.message)
-
-    def visit_test(self, test):
-        if test.failed and not test.tags.robot('exit'):
-            self._stream.write('-' * self._width + '\n')
-            self._stream.highlight('FAIL')
-            self._stream.write(': %s\n%s\n' % (test.longname,
-                                               test.message.strip()))