robotframework 6.1.1__zip → 7.0a1__zip

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

@@ -13,15 +13,12 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import sys
-from typing import Any, cast, Sequence, TypeVar, TYPE_CHECKING
-if sys.version_info >= (3, 8):
-    from typing import Literal
+import warnings
+from typing import Any, cast, Literal, Sequence, TypeVar, TYPE_CHECKING
 
 from robot.utils import setter
 
 from .body import Body, BodyItem, BodyItemParent, BaseBranches
-from .keyword import Keywords
 from .modelobject import DataDict
 from .visitor import SuiteVisitor
 
@@ -31,31 +28,27 @@ if TYPE_CHECKING:
 IT = TypeVar('IT', bound='IfBranch|TryBranch')
 
 
-class Branches(BaseBranches['Keyword', 'For', 'While', 'If', 'Try', 'Return', 'Continue',
-                            'Break', 'Message', 'Error', IT]):
+class Branches(BaseBranches['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
+                            'Continue', 'Break', 'Message', 'Error', IT]):
     pass
 
 
 @Body.register
 class For(BodyItem):
-    """Represents ``FOR`` loops.
-
-    :attr:`flavor` specifies the flavor, and it can be ``IN``, ``IN RANGE``,
-    ``IN ENUMERATE`` or ``IN ZIP``.
-    """
+    """Represents ``FOR`` loops."""
     type = BodyItem.FOR
     body_class = Body
-    repr_args = ('variables', 'flavor', 'values', 'start', 'mode', 'fill')
-    __slots__ = ['variables', 'flavor', 'values', 'start', 'mode', 'fill']
+    repr_args = ('assign', 'flavor', 'values', 'start', 'mode', 'fill')
+    __slots__ = ['assign', 'flavor', 'values', 'start', 'mode', 'fill']
 
-    def __init__(self, variables: Sequence[str] = (),
-                 flavor: "Literal['IN', 'IN RANGE', 'IN ENUMERATE', 'IN ZIP']" = 'IN',
+    def __init__(self, assign: Sequence[str] = (),
+                 flavor: Literal['IN', 'IN RANGE', 'IN ENUMERATE', 'IN ZIP'] = 'IN',
                  values: Sequence[str] = (),
                  start: 'str|None' = None,
                  mode: 'str|None' = None,
                  fill: 'str|None' = None,
                  parent: BodyItemParent = None):
-        self.variables = tuple(variables)
+        self.assign = tuple(assign)
         self.flavor = flavor
         self.values = tuple(values)
         self.start = start
@@ -64,37 +57,29 @@ class For(BodyItem):
         self.parent = parent
         self.body = ()
 
+    @property
+    def variables(self) -> 'tuple[str, ...]':    # TODO: Remove in RF 8.0.
+        """Deprecated since Robot Framework 7.0. Use :attr:`assign` instead."""
+        warnings.warn("'For.variables' is deprecated and will be removed in "
+                      "Robot Framework 8.0. Use 'For.assign' instead.")
+        return self.assign
+
+    @variables.setter
+    def variables(self, assign: 'tuple[str, ...]'):
+        warnings.warn("'For.variables' is deprecated and will be removed in "
+                      "Robot Framework 8.0. Use 'For.assign' instead.")
+        self.assign = assign
+
     @setter
     def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
         return self.body_class(self, body)
 
-    @property
-    def keywords(self):
-        """Deprecated since Robot Framework 4.0. Use :attr:`body` instead."""
-        return Keywords(self, self.body)
-
-    @keywords.setter
-    def keywords(self, keywords):
-        Keywords.raise_deprecation_error()
-
     def visit(self, visitor: SuiteVisitor):
         visitor.visit_for(self)
 
-    def __str__(self):
-        parts = ['FOR', *self.variables, self.flavor, *self.values]
-        for name, value in [('start', self.start),
-                            ('mode', self.mode),
-                            ('fill', self.fill)]:
-            if value is not None:
-                parts.append(f'{name}={value}')
-        return '    '.join(parts)
-
-    def _include_in_repr(self, name: str, value: Any) -> bool:
-        return name not in ('start', 'mode', 'fill') or value is not None
-
     def to_dict(self) -> DataDict:
         data = {'type': self.type,
-                'variables': self.variables,
+                'assign': self.assign,
                 'flavor': self.flavor,
                 'values': self.values}
         for name, value in [('start', self.start),
@@ -105,6 +90,18 @@ class For(BodyItem):
         data['body'] = self.body.to_dicts()
         return data
 
+    def __str__(self):
+        parts = ['FOR', *self.assign, self.flavor, *self.values]
+        for name, value in [('start', self.start),
+                            ('mode', self.mode),
+                            ('fill', self.fill)]:
+            if value is not None:
+                parts.append(f'{name}={value}')
+        return '    '.join(parts)
+
+    def _include_in_repr(self, name: str, value: Any) -> bool:
+        return value is not None or name in ('assign', 'flavor', 'values')
+
 
 @Body.register
 class While(BodyItem):
@@ -133,18 +130,6 @@ class While(BodyItem):
     def visit(self, visitor: SuiteVisitor):
         visitor.visit_while(self)
 
-    def __str__(self) -> str:
-        parts = ['WHILE']
-        if self.condition is not None:
-            parts.append(self.condition)
-        if self.limit is not None:
-            parts.append(f'limit={self.limit}')
-        if self.on_limit is not None:
-            parts.append(f'limit={self.on_limit}')
-        if self.on_limit_message is not None:
-            parts.append(f'on_limit_message={self.on_limit_message}')
-        return '    '.join(parts)
-
     def _include_in_repr(self, name: str, value: Any) -> bool:
         return name == 'condition' or value is not None
 
@@ -159,6 +144,18 @@ class While(BodyItem):
         data['body'] = self.body.to_dicts()
         return data
 
+    def __str__(self) -> str:
+        parts = ['WHILE']
+        if self.condition is not None:
+            parts.append(self.condition)
+        if self.limit is not None:
+            parts.append(f'limit={self.limit}')
+        if self.on_limit is not None:
+            parts.append(f'on_limit={self.on_limit}')
+        if self.on_limit_message is not None:
+            parts.append(f'on_limit_message={self.on_limit_message}')
+        return '    '.join(parts)
+
 
 class IfBranch(BodyItem):
     """Represents individual ``IF``, ``ELSE IF`` or ``ELSE`` branch."""
@@ -187,13 +184,6 @@ class IfBranch(BodyItem):
             return self._get_id(self.parent)
         return self._get_id(self.parent.parent)
 
-    def __str__(self) -> str:
-        if self.type == self.IF:
-            return f'IF    {self.condition}'
-        if self.type == self.ELSE_IF:
-            return f'ELSE IF    {self.condition}'
-        return 'ELSE'
-
     def visit(self, visitor: SuiteVisitor):
         visitor.visit_if_branch(self)
 
@@ -204,6 +194,13 @@ class IfBranch(BodyItem):
         data['body'] = self.body.to_dicts()
         return data
 
+    def __str__(self) -> str:
+        if self.type == self.IF:
+            return f'IF    {self.condition}'
+        if self.type == self.ELSE_IF:
+            return f'ELSE IF    {self.condition}'
+        return 'ELSE'
+
 
 @Body.register
 class If(BodyItem):
@@ -237,23 +234,36 @@ class If(BodyItem):
 class TryBranch(BodyItem):
     """Represents individual ``TRY``, ``EXCEPT``, ``ELSE`` or ``FINALLY`` branch."""
     body_class = Body
-    repr_args = ('type', 'patterns', 'pattern_type', 'variable')
-    __slots__ = ['type', 'patterns', 'pattern_type', 'variable']
+    repr_args = ('type', 'patterns', 'pattern_type', 'assign')
+    __slots__ = ['type', 'patterns', 'pattern_type', 'assign']
 
     def __init__(self, type: str = BodyItem.TRY,
                  patterns: Sequence[str] = (),
                  pattern_type: 'str|None' = None,
-                 variable: 'str|None' = None,
+                 assign: 'str|None' = None,
                  parent: BodyItemParent = None):
-        if (patterns or pattern_type or variable) and type != BodyItem.EXCEPT:
-            raise TypeError(f"'{type}' branches do not accept patterns or variables.")
+        if (patterns or pattern_type or assign) and type != BodyItem.EXCEPT:
+            raise TypeError(f"'{type}' branches do not accept patterns or assignment.")
         self.type = type
         self.patterns = tuple(patterns)
         self.pattern_type = pattern_type
-        self.variable = variable
+        self.assign = assign
         self.parent = parent
         self.body = ()
 
+    @property
+    def variable(self) -> 'str|None':    # TODO: Remove in RF 8.0.
+        """Deprecated since Robot Framework 7.0. Use :attr:`assign` instead."""
+        warnings.warn("'TryBranch.variable' is deprecated and will be removed in "
+                      "Robot Framework 8.0. Use 'TryBranch.assign' instead.")
+        return self.assign
+
+    @variable.setter
+    def variable(self, assign: 'str|None'):
+        warnings.warn("'TryBranch.variable' is deprecated and will be removed in "
+                      "Robot Framework 8.0. Use 'TryBranch.assign' instead.")
+        self.assign = assign
+
     @setter
     def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
         return self.body_class(self, body)
@@ -267,19 +277,6 @@ class TryBranch(BodyItem):
             return self._get_id(self.parent)
         return self._get_id(self.parent.parent)
 
-    def __str__(self) -> str:
-        if self.type != BodyItem.EXCEPT:
-            return self.type
-        parts = ['EXCEPT', *self.patterns]
-        if self.pattern_type:
-            parts.append(f'type={self.pattern_type}')
-        if self.variable:
-            parts.extend(['AS', self.variable])
-        return '    '.join(parts)
-
-    def _include_in_repr(self, name: str, value: Any) -> bool:
-        return bool(value)
-
     def visit(self, visitor: SuiteVisitor):
         visitor.visit_try_branch(self)
 
@@ -289,11 +286,24 @@ class TryBranch(BodyItem):
             data['patterns'] = self.patterns
             if self.pattern_type:
                 data['pattern_type'] = self.pattern_type
-            if self.variable:
-                data['variable'] = self.variable
+            if self.assign:
+                data['assign'] = self.assign
         data['body'] = self.body.to_dicts()
         return data
 
+    def __str__(self) -> str:
+        if self.type != BodyItem.EXCEPT:
+            return self.type
+        parts = ['EXCEPT', *self.patterns]
+        if self.pattern_type:
+            parts.append(f'type={self.pattern_type}')
+        if self.assign:
+            parts.extend(['AS', self.assign])
+        return '    '.join(parts)
+
+    def _include_in_repr(self, name: str, value: Any) -> bool:
+        return bool(value)
+
 
 @Body.register
 class Try(BodyItem):
@@ -348,6 +358,49 @@ class Try(BodyItem):
                 'body': self.body.to_dicts()}
 
 
+@Body.register
+class Var(BodyItem):
+    """Represents ``VAR``."""
+    type = BodyItem.VAR
+    repr_args = ('name', 'value', 'scope', 'separator')
+    __slots__ = ['name', 'value', 'scope', 'separator']
+
+    def __init__(self, name: str = '',
+                 value: 'str|Sequence[str]' = (),
+                 scope: 'str|None' = None,
+                 separator: 'str|None' = None,
+                 parent: BodyItemParent = None):
+        self.name = name
+        self.value = (value,) if isinstance(value, str) else tuple(value)
+        self.scope = scope
+        self.separator = separator
+        self.parent = parent
+
+    def visit(self, visitor: SuiteVisitor):
+        visitor.visit_var(self)
+
+    def to_dict(self) -> DataDict:
+        data = {'type': self.type,
+                'name': self.name,
+                'value': self.value}
+        if self.scope is not None:
+            data['scope'] = self.scope
+        if self.separator is not None:
+            data['separator'] = self.separator
+        return data
+
+    def __str__(self):
+        parts = ['VAR', self.name, *self.value]
+        if self.separator is not None:
+            parts.append(f'separator={self.separator}')
+        if self.scope is not None:
+            parts.append(f'scope={self.scope}')
+        return '    '.join(parts)
+
+    def _include_in_repr(self, name: str, value: Any) -> bool:
+        return value is not None or name in ('name', 'value')
+
+
 @Body.register
 class Return(BodyItem):
     """Represents ``RETURN``."""
@@ -364,8 +417,16 @@ class Return(BodyItem):
         visitor.visit_return(self)
 
     def to_dict(self) -> DataDict:
-        return {'type': self.type,
-                'values': self.values}
+        data = {'type': self.type}
+        if self.values:
+            data['values'] = self.values
+        return data
+
+    def __str__(self):
+        return '    '.join(['RETURN', *self.values])
+
+    def _include_in_repr(self, name: str, value: Any) -> bool:
+        return bool(value)
 
 
 @Body.register
@@ -383,6 +444,9 @@ class Continue(BodyItem):
     def to_dict(self) -> DataDict:
         return {'type': self.type}
 
+    def __str__(self):
+        return 'CONTINUE'
+
 
 @Body.register
 class Break(BodyItem):
@@ -399,6 +463,9 @@ class Break(BodyItem):
     def to_dict(self) -> DataDict:
         return {'type': self.type}
 
+    def __str__(self):
+        return 'BREAK'
+
 
 @Body.register
 class Error(BodyItem):
@@ -421,3 +488,6 @@ class Error(BodyItem):
     def to_dict(self) -> DataDict:
         return {'type': self.type,
                 'values': self.values}
+
+    def __str__(self):
+        return '    '.join(['ERROR', *self.values])

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

@@ -18,7 +18,7 @@ from typing import Sequence, TYPE_CHECKING
 from robot.utils import setter
 
 from .tags import TagPatterns
-from .namepatterns import SuiteNamePatterns, TestNamePatterns
+from .namepatterns import NamePatterns
 from .visitor import SuiteVisitor
 
 if TYPE_CHECKING:
@@ -46,8 +46,8 @@ class EmptySuiteRemover(SuiteVisitor):
 class Filter(EmptySuiteRemover):
 
     def __init__(self,
-                 include_suites: 'SuiteNamePatterns|Sequence[str]|None' = None,
-                 include_tests: 'TestNamePatterns|Sequence[str]|None' = None,
+                 include_suites: 'NamePatterns|Sequence[str]|None' = None,
+                 include_tests: 'NamePatterns|Sequence[str]|None' = None,
                  include_tags: 'TagPatterns|Sequence[str]|None' = None,
                  exclude_tags: 'TagPatterns|Sequence[str]|None' = None):
         super().__init__()
@@ -57,12 +57,12 @@ class Filter(EmptySuiteRemover):
         self.exclude_tags = exclude_tags
 
     @setter
-    def include_suites(self, suites) -> 'SuiteNamePatterns|None':
-        return self._patterns_or_none(suites, SuiteNamePatterns)
+    def include_suites(self, suites) -> 'NamePatterns|None':
+        return self._patterns_or_none(suites, NamePatterns)
 
     @setter
-    def include_tests(self, tests) -> 'TestNamePatterns|None':
-        return self._patterns_or_none(tests, TestNamePatterns)
+    def include_tests(self, tests) -> 'NamePatterns|None':
+        return self._patterns_or_none(tests, NamePatterns)
 
     @setter
     def include_tags(self, tags) -> 'TagPatterns|None':
@@ -80,27 +80,33 @@ class Filter(EmptySuiteRemover):
     def start_suite(self, suite: 'TestSuite'):
         if not self:
             return False
-        if hasattr(suite, 'starttime'):
-            suite.starttime = suite.endtime = None
+        if hasattr(suite, 'start_time'):
+            suite.start_time = suite.end_time = suite.elapsed_time = None
         if self.include_suites is not None:
-            if self.include_suites.match(suite.name, suite.longname):
-                suite.visit(Filter(include_tests=self.include_tests,
-                                   include_tags=self.include_tags,
-                                   exclude_tags=self.exclude_tags))
-                return False
-            suite.tests = []
-            return True
-        if self.include_tests is not None:
-            suite.tests = [t for t in suite.tests
-                           if self.include_tests.match(t.name, t.longname)]
-        if self.include_tags is not None:
-            suite.tests = [t for t in suite.tests
-                           if self.include_tags.match(t.tags)]
-        if self.exclude_tags is not None:
-            suite.tests = [t for t in suite.tests
-                           if not self.exclude_tags.match(t.tags)]
+            return self._filter_based_on_suite_name(suite)
+        suite.tests = [t for t in suite.tests if self._test_included(t)]
         return bool(suite.suites)
 
+    def _filter_based_on_suite_name(self, suite: 'TestSuite') -> bool:
+        if self.include_suites.match(suite.name, suite.full_name):
+            suite.visit(Filter(include_tests=self.include_tests,
+                               include_tags=self.include_tags,
+                               exclude_tags=self.exclude_tags))
+            return False
+        suite.tests = []
+        return True
+
+    def _test_included(self, test: 'TestCase') -> bool:
+        tests, include, exclude \
+                = self.include_tests, self.include_tags, self.exclude_tags
+        if exclude is not None and exclude.match(test.tags):
+            return False
+        if include is not None and include.match(test.tags):
+            return True
+        if tests is not None and tests.match(test.name, test.full_name):
+            return True
+        return include is None and tests is None
+
     def __bool__(self) -> bool:
         return bool(self.include_suites is not None or
                     self.include_tests is not None or

robotframework-7.0a1/src/robot/model/keyword.py

@@ -0,0 +1,70 @@
+#  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 Sequence, TYPE_CHECKING
+
+from .body import Body, BodyItem, BodyItemParent
+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 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

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

@@ -13,12 +13,18 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from robot.utils import html_escape
+from datetime import datetime
+from typing import Literal
+
+from robot.utils import html_escape, setter
 
 from .body import BodyItem
 from .itemlist import ItemList
 
 
+MessageLevel = Literal['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR', 'FAIL', 'SKIP']
+
+
 class Message(BodyItem):
     """A message created during the test execution.
 
@@ -27,22 +33,25 @@ class Message(BodyItem):
     """
     type = BodyItem.MESSAGE
     repr_args = ('message', 'level')
-    __slots__ = ['message', 'level', 'html', 'timestamp']
+    __slots__ = ['message', 'level', 'html', '_timestamp']
 
-    def __init__(self, message='', level='INFO', html=False, timestamp=None, parent=None):
-        #: The message content as a string.
+    def __init__(self, message: str = '',
+                 level: MessageLevel = 'INFO',
+                 html: bool = False,
+                 timestamp: 'datetime|str|None' = None,
+                 parent: 'BodyItem|None' = None):
         self.message = message
-        #: Severity of the message. Either ``TRACE``, ``DEBUG``, ``INFO``,
-        #: ``WARN``, ``ERROR``, ``FAIL`` or ``SKIP`. The last two are only used
-        #: with keyword failure messages.
         self.level = level
-        #: ``True`` if the content is in HTML, ``False`` otherwise.
         self.html = html
-        #: Timestamp in format ``%Y%m%d %H:%M:%S.%f``.
         self.timestamp = timestamp
-        #: The object this message was triggered by.
         self.parent = parent
 
+    @setter
+    def timestamp(self, timestamp: 'datetime|str|None') -> 'datetime|None':
+        if isinstance(timestamp, str):
+            return datetime.fromisoformat(timestamp)
+        return timestamp
+
     @property
     def html_message(self):
         """Returns the message content as HTML."""

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

@@ -23,15 +23,9 @@ class NamePatterns(Iterable[str]):
     def __init__(self, patterns: Sequence[str] = (), ignore: Sequence[str] = '_'):
         self.matcher = MultiMatcher(patterns, ignore)
 
-    def match(self, name: str, longname: 'str|None' = None) -> bool:
-        return bool(self._match(name) or
-                    longname and self._match_longname(longname))
-
-    def _match(self, name: str) -> bool:
-        return self.matcher.match(name)
-
-    def _match_longname(self, name: str) -> bool:
-        raise NotImplementedError
+    def match(self, name: str, full_name: 'str|None' = None) -> bool:
+        match = self.matcher.match
+        return bool(match(name) or full_name and match(full_name))
 
     def __bool__(self) -> bool:
         return bool(self.matcher)
@@ -39,19 +33,3 @@ class NamePatterns(Iterable[str]):
     def __iter__(self) -> Iterator[str]:
         for matcher in self.matcher:
             yield matcher.pattern
-
-
-class SuiteNamePatterns(NamePatterns):
-
-    def _match_longname(self, name):
-        while '.' in name:
-            if self._match(name):
-                return True
-            name = name.split('.', 1)[1]
-        return False
-
-
-class TestNamePatterns(NamePatterns):
-
-    def _match_longname(self, name):
-        return self._match(name)