robotframework 6.1rc1__zip → 7.0__zip

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

@@ -34,22 +34,17 @@ __ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#
 __ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#listener-interface
 """
 
-import sys
 import warnings
 from pathlib import Path
-from typing import Any, Mapping, Sequence, TYPE_CHECKING, Union
-if sys.version_info >= (3, 8):
-    from typing import Literal
+from typing import Literal, Mapping, Sequence, TYPE_CHECKING, TypeVar, Union
 
 from robot import model
 from robot.conf import RobotSettings
-from robot.errors import BreakLoop, ContinueLoop, DataError, ReturnFromKeyword
-from robot.model import (BodyItem, create_fixture, DataDict, Keywords, ModelObject,
-                         TestCases, TestSuites)
+from robot.errors import BreakLoop, ContinueLoop, DataError, ReturnFromKeyword, VariableError
+from robot.model import BodyItem, DataDict, TestSuites
 from robot.output import LOGGER, Output, pyloggingconf
-from robot.result import (Break as BreakResult, Continue as ContinueResult,
-                          Error as ErrorResult, Return as ReturnResult)
 from robot.utils import setter
+from robot.variables import VariableResolver
 
 from .bodyrunner import ForRunner, IfRunner, KeywordRunner, TryRunner, WhileRunner
 from .randomizer import Randomizer
@@ -58,15 +53,22 @@ from .statusreporter import StatusReporter
 if TYPE_CHECKING:
     from robot.parsing import File
     from .builder import TestDefaults
+    from .resourcemodel import ResourceFile, UserKeyword
 
 
+IT = TypeVar('IT', bound='IfBranch|TryBranch')
 BodyItemParent = Union['TestSuite', 'TestCase', 'UserKeyword', 'For', 'If', 'IfBranch',
                        'Try', 'TryBranch', 'While', None]
 
 
-class Body(model.BaseBody['Keyword', 'For', 'While', 'If', 'Try', 'Return', 'Continue',
-                          'Break', 'model.Message', 'Error']):
-    __slots__ = []
+class Body(model.BaseBody['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
+                          'Continue', 'Break', 'model.Message', 'Error']):
+    __slots__ = ()
+
+
+class Branches(model.BaseBranches['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
+                                  'Continue', 'Break', 'model.Message', 'Error', IT]):
+    __slots__ = ()
 
 
 class WithSource:
@@ -90,11 +92,32 @@ class Keyword(model.Keyword, WithSource):
 
     The actual keyword that is executed depends on the context where this model
     is executed.
+
+    Arguments originating from normal Robot Framework data are stored as list of
+    strings in the exact same format as in the data. This means that arguments can
+    have variables and escape characters, and that named arguments are specified
+    using the ``name=value`` syntax.
+
+    If arguments are set programmatically, it is possible to use also other types
+    than strings. To support non-string values with named arguments, it is possible
+    to use two-item tuples like ``('name', 'value')``. To avoid ambiguity if an
+    argument contains a literal ``=`` character, positional arguments can also be
+    given using one-item tuples like ``('value',)``. In all these cases strings
+    can contain variables, and they must follow the escaping rules used in normal
+    data.
+
+    Arguments can also be given directly as a tuple containing list of positional
+    arguments and a dictionary of named arguments. In this case arguments are
+    used as-is without replacing variables or handling escapes. Argument conversion
+    and validation is done even in this case, though.
+
+    Support for specifying arguments using tuples and giving them directly as
+    positional and named arguments are new in Robot Framework 7.0.
     """
     __slots__ = ['lineno']
 
     def __init__(self, name: str = '',
-                 args: Sequence[str] = (),
+                 args: model.Arguments = (),
                  assign: Sequence[str] = (),
                  type: str = BodyItem.KEYWORD,
                  parent: BodyItemParent = None,
@@ -102,14 +125,36 @@ class Keyword(model.Keyword, WithSource):
         super().__init__(name, args, assign, type, parent)
         self.lineno = lineno
 
+    @classmethod
+    def from_json(cls, source) -> 'Keyword':
+        kw = super().from_json(source)
+        # Argument tuples have a special meaning during execution.
+        # Tuples are represented as lists in JSON, so we need to convert them.
+        kw.args = tuple([tuple(a) if isinstance(a, list) else a
+                         for a in kw.args])
+        return kw
+
     def to_dict(self) -> DataDict:
         data = super().to_dict()
         if self.lineno:
             data['lineno'] = self.lineno
         return data
 
-    def run(self, context, run=True, templated=None):
-        return KeywordRunner(context, run).run(self)
+    def run(self, result, context, run=True, templated=None):
+        return KeywordRunner(context, run).run(self, result.body.create_keyword())
+
+
+class ForIteration(model.ForIteration, WithSource):
+    __slots__ = ('lineno', 'error')
+    body_class = Body
+
+    def __init__(self, assign: 'Mapping[str, str]|None' = None,
+                 parent: BodyItemParent = None,
+                 lineno: 'int|None' = None,
+                 error: 'str|None' = None):
+        super().__init__(assign, parent)
+        self.lineno = lineno
+        self.error = error
 
 
 @Body.register
@@ -117,8 +162,8 @@ class For(model.For, WithSource):
     __slots__ = ['lineno', 'error']
     body_class = Body
 
-    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,
@@ -126,10 +171,17 @@ class For(model.For, WithSource):
                  parent: BodyItemParent = None,
                  lineno: 'int|None' = None,
                  error: 'str|None' = None):
-        super().__init__(variables, flavor, values, start, mode, fill, parent)
+        super().__init__(assign, flavor, values, start, mode, fill, parent)
         self.lineno = lineno
         self.error = error
 
+    @classmethod
+    def from_dict(cls, data: DataDict) -> 'For':
+        # RF 6.1 compatibility
+        if 'variables' in data:
+            data['assign'] = data.pop('variables')
+        return super().from_dict(data)
+
     def to_dict(self) -> DataDict:
         data = super().to_dict()
         if self.lineno:
@@ -138,8 +190,27 @@ class For(model.For, WithSource):
             data['error'] = self.error
         return data
 
-    def run(self, context, run=True, templated=False):
-        return ForRunner(context, self.flavor, run, templated).run(self)
+    def run(self, result, context, run=True, templated=False):
+        result = result.body.create_for(self.assign, self.flavor, self.values,
+                                        self.start, self.mode, self.fill)
+        return ForRunner(context, self.flavor, run, templated).run(self, result)
+
+    def get_iteration(self, assign: 'Mapping[str, str]|None' = None) -> ForIteration:
+        iteration = ForIteration(assign, self, self.lineno, self.error)
+        iteration.body = [item.to_dict() for item in self.body]
+        return iteration
+
+
+class WhileIteration(model.WhileIteration, WithSource):
+    __slots__ = ('lineno', 'error')
+    body_class = Body
+
+    def __init__(self, parent: BodyItemParent = None,
+                 lineno: 'int|None' = None,
+                 error: 'str|None' = None):
+        super().__init__(parent)
+        self.lineno = lineno
+        self.error = error
 
 
 @Body.register
@@ -166,13 +237,20 @@ class While(model.While, WithSource):
             data['error'] = self.error
         return data
 
-    def run(self, context, run=True, templated=False):
-        return WhileRunner(context, run, templated).run(self)
+    def run(self, result, context, run=True, templated=False):
+        result = result.body.create_while(self.condition, self.limit, self.on_limit,
+                                          self.on_limit_message)
+        return WhileRunner(context, run, templated).run(self, result)
+
+    def get_iteration(self) -> WhileIteration:
+        iteration = WhileIteration(self, self.lineno, self.error)
+        iteration.body = [item.to_dict() for item in self.body]
+        return iteration
 
 
 class IfBranch(model.IfBranch, WithSource):
-    __slots__ = ['lineno']
     body_class = Body
+    __slots__ = ['lineno']
 
     def __init__(self, type: str = BodyItem.IF,
                  condition: 'str|None' = None,
@@ -190,8 +268,9 @@ class IfBranch(model.IfBranch, WithSource):
 
 @Body.register
 class If(model.If, WithSource):
-    __slots__ = ['lineno', 'error']
     branch_class = IfBranch
+    branches_class = Branches[branch_class]
+    __slots__ = ['lineno', 'error']
 
     def __init__(self, parent: BodyItemParent = None,
                  lineno: 'int|None' = None,
@@ -200,8 +279,8 @@ class If(model.If, WithSource):
         self.lineno = lineno
         self.error = error
 
-    def run(self, context, run=True, templated=False):
-        return IfRunner(context, run, templated).run(self)
+    def run(self, result, context, run=True, templated=False):
+        return IfRunner(context, run, templated).run(self, result.body.create_if())
 
     def to_dict(self) -> DataDict:
         data = super().to_dict()
@@ -213,18 +292,25 @@ class If(model.If, WithSource):
 
 
 class TryBranch(model.TryBranch, WithSource):
-    __slots__ = ['lineno']
     body_class = Body
+    __slots__ = ['lineno']
 
     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,
                  lineno: 'int|None' = None):
-        super().__init__(type, patterns, pattern_type, variable, parent)
+        super().__init__(type, patterns, pattern_type, assign, parent)
         self.lineno = lineno
 
+    @classmethod
+    def from_dict(cls, data: DataDict) -> 'TryBranch':
+        # RF 6.1 compatibility.
+        if 'variable' in data:
+            data['assign'] = data.pop('variable')
+        return super().from_dict(data)
+
     def to_dict(self) -> DataDict:
         data = super().to_dict()
         if self.lineno:
@@ -234,8 +320,9 @@ class TryBranch(model.TryBranch, WithSource):
 
 @Body.register
 class Try(model.Try, WithSource):
-    __slots__ = ['lineno', 'error']
     branch_class = TryBranch
+    branches_class = Branches[branch_class]
+    __slots__ = ['lineno', 'error']
 
     def __init__(self, parent: BodyItemParent = None,
                  lineno: 'int|None' = None,
@@ -244,8 +331,65 @@ class Try(model.Try, WithSource):
         self.lineno = lineno
         self.error = error
 
-    def run(self, context, run=True, templated=False):
-        return TryRunner(context, run, templated).run(self)
+    def run(self, result, context, run=True, templated=False):
+        return TryRunner(context, run, templated).run(self, result.body.create_try())
+
+    def to_dict(self) -> DataDict:
+        data = super().to_dict()
+        if self.lineno:
+            data['lineno'] = self.lineno
+        if self.error:
+            data['error'] = self.error
+        return data
+
+
+@Body.register
+class Var(model.Var, WithSource):
+    __slots__ = ['lineno', 'error']
+
+    def __init__(self, name: str = '',
+                 value: 'str|Sequence[str]' = (),
+                 scope: 'str|None' = None,
+                 separator: 'str|None' = None,
+                 parent: BodyItemParent = None,
+                 lineno: 'int|None' = None,
+                 error: 'str|None' = None):
+        super().__init__(name, value, scope, separator, parent)
+        self.lineno = lineno
+        self.error = error
+
+    def run(self, result, context, run=True, templated=False):
+        result = result.body.create_var(self.name, self.value, self.scope, self.separator)
+        with StatusReporter(self, result, context, run):
+            if run:
+                if self.error:
+                    raise DataError(self.error, syntax=True)
+                if not context.dry_run:
+                    scope = self._get_scope(context.variables)
+                    setter = getattr(context.variables, f'set_{scope}')
+                    try:
+                        resolver = VariableResolver.from_variable(self)
+                        setter(self._resolve_name(self.name, context.variables),
+                               resolver.resolve(context.variables))
+                    except DataError as err:
+                        raise VariableError(f"Setting variable '{self.name}' failed: {err}")
+
+    def _get_scope(self, variables):
+        if not self.scope:
+            return 'local'
+        try:
+            scope = variables.replace_string(self.scope)
+            if scope.upper() == 'TASK':
+                return 'test'
+            if scope.upper() in ('GLOBAL', 'SUITE', 'TEST', 'LOCAL'):
+                return scope.lower()
+            raise DataError(f"Value '{scope}' is not accepted. Valid values are "
+                            f"'GLOBAL', 'SUITE', 'TEST', 'TASK' and 'LOCAL'.")
+        except DataError as err:
+            raise DataError(f"Invalid VAR scope: {err}")
+
+    def _resolve_name(self, name, variables):
+        return name[:2] + variables.replace_string(name[2:-1]) + '}'
 
     def to_dict(self) -> DataDict:
         data = super().to_dict()
@@ -268,8 +412,9 @@ class Return(model.Return, WithSource):
         self.lineno = lineno
         self.error = error
 
-    def run(self, context, run=True, templated=False):
-        with StatusReporter(self, ReturnResult(self.values), context, run):
+    def run(self, result, context, run=True, templated=False):
+        result = result.body.create_return(self.values)
+        with StatusReporter(self, result, context, run):
             if run:
                 if self.error:
                     raise DataError(self.error, syntax=True)
@@ -296,8 +441,9 @@ class Continue(model.Continue, WithSource):
         self.lineno = lineno
         self.error = error
 
-    def run(self, context, run=True, templated=False):
-        with StatusReporter(self, ContinueResult(), context, run):
+    def run(self, result, context, run=True, templated=False):
+        result = result.body.create_continue()
+        with StatusReporter(self, result, context, run):
             if run:
                 if self.error:
                     raise DataError(self.error, syntax=True)
@@ -324,8 +470,9 @@ class Break(model.Break, WithSource):
         self.lineno = lineno
         self.error = error
 
-    def run(self, context, run=True, templated=False):
-        with StatusReporter(self, BreakResult(), context, run):
+    def run(self, result, context, run=True, templated=False):
+        result = result.body.create_break()
+        with StatusReporter(self, result, context, run):
             if run:
                 if self.error:
                     raise DataError(self.error, syntax=True)
@@ -353,8 +500,9 @@ class Error(model.Error, WithSource):
         self.lineno = lineno
         self.error = error
 
-    def run(self, context, run=True, templated=False):
-        with StatusReporter(self, ErrorResult(self.values), context, run):
+    def run(self, result, context, run=True, templated=False):
+        result = result.body.create_error(self.values)
+        with StatusReporter(self, result, context, run):
             if run:
                 raise DataError(self.error)
 
@@ -362,8 +510,7 @@ class Error(model.Error, WithSource):
         data = super().to_dict()
         if self.lineno:
             data['lineno'] = self.lineno
-        if self.error:
-            data['error'] = self.error
+        data['error'] = self.error
         return data
 
 
@@ -417,19 +564,23 @@ class TestSuite(model.TestSuite[Keyword, TestCase]):
                  doc: str = '',
                  metadata: 'Mapping[str, str]|None' = None,
                  source: 'Path|str|None' = None,
-                 rpa: 'bool|None' = None,
+                 rpa: 'bool|None' = False,
                  parent: 'TestSuite|None' = None):
         super().__init__(name, doc, metadata, source, rpa, parent)
         #: :class:`ResourceFile` instance containing imports, variables and
         #: keywords the suite owns. When data is parsed from the file system,
         #: this data comes from the same test case file that creates the suite.
-        self.resource = ResourceFile(parent=self)
+        self.resource = None
 
     @setter
-    def resource(self, resource: 'ResourceFile|dict') -> 'ResourceFile':
+    def resource(self, resource: 'ResourceFile|dict|None') -> 'ResourceFile':
+        from .resourcemodel import ResourceFile
+
+        if resource is None:
+            resource = ResourceFile()
         if isinstance(resource, dict):
             resource = ResourceFile.from_dict(resource)
-            resource.parent = self
+        resource.owner = self
         return resource
 
     @classmethod
@@ -556,7 +707,7 @@ class TestSuite(model.TestSuite[Keyword, TestCase]):
         If such an option is used only once, it can be given also as a single
         string like ``variable='VAR:value'``.
 
-        Additionally listener option allows passing object directly instead of
+        Additionally, listener option allows passing object directly instead of
         listener name, e.g. ``run('tests.robot', listener=Listener())``.
 
         To capture stdout and/or stderr streams, pass open file objects in as
@@ -612,293 +763,3 @@ class TestSuite(model.TestSuite[Keyword, TestCase]):
         data = super().to_dict()
         data['resource'] = self.resource.to_dict()
         return data
-
-
-class Variable(ModelObject):
-    repr_args = ('name', 'value')
-
-    def __init__(self, name: str = '',
-                 value: Sequence[str] = (),
-                 parent: 'ResourceFile|None' = None,
-                 lineno: 'int|None' = None,
-                 error: 'str|None' = None):
-        self.name = name
-        self.value = tuple(value)
-        self.parent = parent
-        self.lineno = lineno
-        self.error = error
-
-    @property
-    def source(self) -> 'Path|None':
-        return self.parent.source if self.parent is not None else None
-
-    def report_invalid_syntax(self, message: str, level: str = 'ERROR'):
-        source = self.source or '<unknown>'
-        line = f' on line {self.lineno}' if self.lineno else ''
-        LOGGER.write(f"Error in file '{source}'{line}: "
-                     f"Setting variable '{self.name}' failed: {message}", level)
-
-    def to_dict(self) -> DataDict:
-        data = {'name': self.name, 'value': self.value}
-        if self.lineno:
-            data['lineno'] = self.lineno
-        if self.error:
-            data['error'] = self.error
-        return data
-
-
-class ResourceFile(ModelObject):
-    repr_args = ('source',)
-    __slots__ = ('_source', 'parent', 'doc')
-
-    def __init__(self, source: 'Path|str|None' = None,
-                 parent: 'TestSuite|None' = None,
-                 doc: str = ''):
-        self.source = source
-        self.parent = parent
-        self.doc = doc
-        self.imports = []
-        self.variables = []
-        self.keywords = []
-
-    @property
-    def source(self) -> 'Path|None':
-        if self._source:
-            return self._source
-        if self.parent:
-            return self.parent.source
-        return None
-
-    @source.setter
-    def source(self, source: 'Path|str|None'):
-        if isinstance(source, str):
-            source = Path(source)
-        self._source = source
-
-    @setter
-    def imports(self, imports: Sequence['Import']) -> 'Imports':
-        return Imports(self, imports)
-
-    @setter
-    def variables(self, variables: Sequence['Variable']) -> 'Variables':
-        return Variables(self, variables)
-
-    @setter
-    def keywords(self, keywords: Sequence['UserKeyword']) -> 'UserKeywords':
-        return UserKeywords(self, keywords)
-
-    def to_dict(self) -> DataDict:
-        data = {}
-        if self._source:
-            data['source'] = str(self._source)
-        if self.doc:
-            data['doc'] = self.doc
-        if self.imports:
-            data['imports'] = self.imports.to_dicts()
-        if self.variables:
-            data['variables'] = self.variables.to_dicts()
-        if self.keywords:
-            data['keywords'] = self.keywords.to_dicts()
-        return data
-
-
-class UserKeyword(ModelObject):
-    repr_args = ('name', 'args')
-    fixture_class = Keyword
-    __slots__ = ['name', 'args', 'doc', 'return_', 'timeout', 'lineno', 'parent',
-                 'error', '_teardown']
-
-    def __init__(self, name: str = '',
-                 args: Sequence[str] = (),
-                 doc: str = '',
-                 tags: Sequence[str] = (),
-                 return_: Sequence[str] = (),
-                 timeout: 'str|None' = None,
-                 lineno: 'int|None' = None,
-                 parent: 'ResourceFile|None' = None,
-                 error: 'str|None' = None):
-        self.name = name
-        self.args = tuple(args)
-        self.doc = doc
-        self.tags = tags
-        self.return_ = tuple(return_)
-        self.timeout = timeout
-        self.lineno = lineno
-        self.parent = parent
-        self.error = error
-        self.body = []
-        self._teardown = None
-
-    @setter
-    def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
-        return Body(self, body)
-
-    @property
-    def keywords(self) -> Keywords:
-        """Deprecated since Robot Framework 4.0.
-
-        Use :attr:`body` or :attr:`teardown` instead.
-        """
-        kws = list(self.body)
-        if self.teardown:
-            kws.append(self.teardown)
-        return Keywords(self, kws)
-
-    @keywords.setter
-    def keywords(self, keywords):
-        Keywords.raise_deprecation_error()
-
-    @property
-    def teardown(self) -> Keyword:
-        if self._teardown is None:
-            self._teardown = create_fixture(self.fixture_class, None, self, Keyword.TEARDOWN)
-        return self._teardown
-
-    @teardown.setter
-    def teardown(self, teardown: 'Keyword|DataDict|None'):
-        self._teardown = create_fixture(self.fixture_class, teardown, self, Keyword.TEARDOWN)
-
-    @property
-    def has_teardown(self) -> bool:
-        """Check does a keyword have a teardown without creating a teardown object.
-
-        A difference between using ``if uk.has_teardown:`` and ``if uk.teardown:``
-        is that accessing the :attr:`teardown` attribute creates a :class:`Keyword`
-        object representing the teardown even when the user keyword actually does
-        not have one. This can have an effect on memory usage.
-
-        New in Robot Framework 6.1.
-        """
-        return bool(self._teardown)
-
-    @setter
-    def tags(self, tags: Sequence[str]) -> model.Tags:
-        return model.Tags(tags)
-
-    @property
-    def source(self) -> 'Path|None':
-        return self.parent.source if self.parent is not None else None
-
-    def to_dict(self) -> DataDict:
-        data: DataDict = {'name': self.name}
-        for name, value in [('args', self.args),
-                            ('doc', self.doc),
-                            ('tags', tuple(self.tags)),
-                            ('return_', self.return_),
-                            ('timeout', self.timeout),
-                            ('lineno', self.lineno),
-                            ('error', self.error)]:
-            if value:
-                data[name] = value
-        data['body'] = self.body.to_dicts()
-        if self.has_teardown:
-            data['teardown'] = self.teardown.to_dict()
-        return data
-
-
-class Import(ModelObject):
-    repr_args = ('type', 'name', 'args', 'alias')
-    LIBRARY = 'LIBRARY'
-    RESOURCE = 'RESOURCE'
-    VARIABLES = 'VARIABLES'
-
-    def __init__(self, type: "Literal['LIBRARY', 'RESOURCE', 'VARIABLES']",
-                 name: str,
-                 args: Sequence[str] = (),
-                 alias: 'str|None' = None,
-                 parent: 'ResourceFile|None' = None,
-                 lineno: 'int|None' = None):
-        if type not in (self.LIBRARY, self.RESOURCE, self.VARIABLES):
-            raise ValueError(f"Invalid import type: Expected '{self.LIBRARY}', "
-                             f"'{self.RESOURCE}' or '{self.VARIABLES}', got '{type}'.")
-        self.type = type
-        self.name = name
-        self.args = tuple(args)
-        self.alias = alias
-        self.parent = parent
-        self.lineno = lineno
-
-    @property
-    def source(self) -> 'Path|None':
-        return self.parent.source if self.parent is not None else None
-
-    @property
-    def directory(self) -> 'Path|None':
-        source = self.source
-        return source.parent if source and not source.is_dir() else source
-
-    @property
-    def setting_name(self) -> str:
-        return self.type.title()
-
-    def select(self, library: Any, resource: Any, variables: Any) -> Any:
-        return {self.LIBRARY: library,
-                self.RESOURCE: resource,
-                self.VARIABLES: variables}[self.type]
-
-    def report_invalid_syntax(self, message: str, level: str = 'ERROR'):
-        source = self.source or '<unknown>'
-        line = f' on line {self.lineno}' if self.lineno else ''
-        LOGGER.write(f"Error in file '{source}'{line}: {message}", level)
-
-    @classmethod
-    def from_dict(cls, data) -> 'Import':
-        return cls(**data)
-
-    def to_dict(self) -> DataDict:
-        data: DataDict = {'type': self.type, 'name': self.name}
-        if self.args:
-            data['args'] = self.args
-        if self.alias:
-            data['alias'] = self.alias
-        if self.lineno:
-            data['lineno'] = self.lineno
-        return data
-
-    def _include_in_repr(self, name: str, value: Any) -> bool:
-        return name in ('type', 'name') or value
-
-
-class Imports(model.ItemList):
-
-    def __init__(self, parent: ResourceFile, imports: Sequence[Import] = ()):
-        super().__init__(Import, {'parent': parent}, items=imports)
-
-    def library(self, name: str, args: Sequence[str] = (), alias: 'str|None' = None,
-                lineno: 'int|None' = None) -> Import:
-        """Create library import."""
-        return self.create(Import.LIBRARY, name, args, alias, lineno=lineno)
-
-    def resource(self, name: str, lineno: 'int|None' = None) -> Import:
-        """Create resource import."""
-        return self.create(Import.RESOURCE, name, lineno=lineno)
-
-    def variables(self, name: str, args: Sequence[str] = (),
-                  lineno: 'int|None' = None) -> Import:
-        """Create variables import."""
-        return self.create(Import.VARIABLES, name, args, lineno=lineno)
-
-    def create(self, *args, **kwargs) -> Import:
-        """Generic method for creating imports.
-
-        Import type specific methods :meth:`library`, :meth:`resource` and
-        :meth:`variables` are recommended over this method.
-        """
-        # RF 6.1 changed types to upper case. Code below adds backwards compatibility.
-        if args:
-            args = (args[0].upper(),) + args[1:]
-        elif 'type' in kwargs:
-            kwargs['type'] = kwargs['type'].upper()
-        return super().create(*args, **kwargs)
-
-
-class Variables(model.ItemList[Variable]):
-
-    def __init__(self, parent: ResourceFile, variables: Sequence[Variable] = ()):
-        super().__init__(Variable, {'parent': parent}, items=variables)
-
-
-class UserKeywords(model.ItemList[UserKeyword]):
-
-    def __init__(self, parent: ResourceFile, keywords: Sequence[UserKeyword] = ()):
-        super().__init__(UserKeyword, {'parent': parent}, items=keywords)