robotframework 6.1.1__zip → 7.0__zip

{robotframework-6.1.1 → robotframework-7.0}/src/robot/running/bodyrunner.py

@@ -13,21 +13,19 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+import re
+import time
 from collections import OrderedDict
 from contextlib import contextmanager
+from datetime import datetime
 from itertools import zip_longest
-import re
-import time
 
 from robot.errors import (BreakLoop, ContinueLoop, DataError, ExecutionFailed,
                           ExecutionFailures, ExecutionPassed, ExecutionStatus)
-from robot.result import (For as ForResult, While as WhileResult, If as IfResult,
-                          IfBranch as IfBranchResult, Try as TryResult,
-                          TryBranch as TryBranchResult)
 from robot.output import librarylogger as logger
-from robot.utils import (cut_assign_value, frange, get_error_message, get_timestamp,
-                         is_list_like, is_number, plural_or_not as s, secs_to_timestr,
-                         seq2str, split_from_equals, type_name, Matcher, timestr_to_secs)
+from robot.utils import (cut_assign_value, frange, get_error_message, is_list_like,
+                         is_number, normalize, plural_or_not as s, secs_to_timestr, seq2str,
+                         split_from_equals, type_name, Matcher, timestr_to_secs)
 from robot.variables import is_dict_variable, evaluate_expression
 
 from .statusreporter import StatusReporter
@@ -43,12 +41,12 @@ class BodyRunner:
         self._run = run
         self._templated = templated
 
-    def run(self, body):
+    def run(self, data, result):
         errors = []
         passed = None
-        for step in body:
+        for item in data.body:
             try:
-                step.run(self._context, self._run, self._templated)
+                item.run(result, self._context, self._run, self._templated)
             except ExecutionPassed as exception:
                 exception.set_earlier_failures(errors)
                 passed = exception
@@ -68,12 +66,12 @@ class KeywordRunner:
         self._context = context
         self._run = run
 
-    def run(self, step, name=None):
+    def run(self, data, result, name=None):
         context = self._context
-        runner = context.get_runner(name or step.name)
+        runner = context.get_runner(name or data.name)
         if context.dry_run:
-            return runner.dry_run(step, context)
-        return runner.run(step, context, self._run)
+            return runner.dry_run(data, result, context)
+        return runner.run(data, result, context, self._run)
 
 
 def ForRunner(context, flavor='IN', run=True, templated=False):
@@ -93,7 +91,7 @@ class ForInRunner:
         self._run = run
         self._templated = templated
 
-    def run(self, data):
+    def run(self, data, result):
         error = None
         run = False
         if self._run:
@@ -101,8 +99,6 @@ class ForInRunner:
                 error = DataError(data.error, syntax=True)
             else:
                 run = True
-        result = ForResult(data.variables, data.flavor, data.values, data.start,
-                           data.mode, data.fill)
         with StatusReporter(data, result, self._context, run) as status:
             if run:
                 try:
@@ -143,7 +139,7 @@ class ForInRunner:
     def _get_values_for_rounds(self, data):
         if self._context.dry_run:
             return [None]
-        values_per_round = len(data.variables)
+        values_per_round = len(data.assign)
         if self._is_dict_iteration(data.values):
             values = self._resolve_dict_values(data.values)
             values = self._map_dict_values_to_rounds(values, values_per_round)
@@ -213,18 +209,20 @@ class ForInRunner:
                         f'value{s(values)}.')
 
     def _run_one_round(self, data, result, values=None, run=True):
-        result = result.body.create_iteration()
+        iter_data = data.get_iteration()
+        iter_result = result.body.create_iteration()
         if values is not None:
             variables = self._context.variables
-        else:    # Not really run (earlier failure, unexecuted IF branch, dry-run)
+        else:    # Not really run (earlier failure, un-executed IF branch, dry-run)
             variables = {}
-            values = [''] * len(data.variables)
-        for name, value in self._map_variables_and_values(data.variables, values):
+            values = [''] * len(data.assign)
+        for name, value in self._map_variables_and_values(data.assign, values):
             variables[name] = value
-            result.variables[name] = cut_assign_value(value)
+            iter_data.assign[name] = value
+            iter_result.assign[name] = cut_assign_value(value)
         runner = BodyRunner(self._context, run, self._templated)
-        with StatusReporter(data, result, self._context, run):
-            runner.run(data.body)
+        with StatusReporter(iter_data, iter_result, self._context, run):
+            runner.run(iter_data, iter_result)
 
     def _map_variables_and_values(self, variables, values):
         if len(variables) == 1 and len(values) != 1:
@@ -274,13 +272,13 @@ class ForInZipRunner(ForInRunner):
         if not mode or self._context.dry_run:
             return None
         try:
-            mode = self._context.variables.replace_string(mode).upper()
-            if mode in ('STRICT', 'SHORTEST', 'LONGEST'):
-                return mode
-            raise DataError(f"Mode must be 'STRICT', 'SHORTEST' or 'LONGEST', "
-                            f"got '{mode}'.")
+            mode = self._context.variables.replace_string(mode)
+            if mode.upper() in ('STRICT', 'SHORTEST', 'LONGEST'):
+                return mode.upper()
+            raise DataError(f"Value '{mode}' is not accepted. Valid values "
+                            f"are 'STRICT', 'SHORTEST' and 'LONGEST'.")
         except DataError as err:
-            raise DataError(f'Invalid mode: {err}')
+            raise DataError(f'Invalid FOR IN ZIP mode: {err}')
 
     def _resolve_fill(self, fill):
         if not fill or self._context.dry_run:
@@ -288,7 +286,7 @@ class ForInZipRunner(ForInRunner):
         try:
             return self._context.variables.replace_scalar(fill)
         except DataError as err:
-            raise DataError(f'Invalid fill value: {err}')
+            raise DataError(f'Invalid FOR IN ZIP fill value: {err}')
 
     def _resolve_dict_values(self, values):
         raise DataError('FOR IN ZIP loops do not support iterating over dictionaries.',
@@ -302,6 +300,8 @@ class ForInZipRunner(ForInRunner):
             return zip_longest(*values, fillvalue=self._fill)
         if self._mode == 'STRICT':
             self._validate_strict_lengths(values)
+        if self._mode is None:
+            self._deprecate_different_lengths(values)
         return zip(*values)
 
     def _validate_types(self, values):
@@ -316,12 +316,21 @@ class ForInZipRunner(ForInRunner):
             try:
                 lengths.append(len(item))
             except TypeError:
-                raise DataError(f"FOR IN ZIP items should have length in STRICT mode, "
-                                f"but item {index} does not.")
+                raise DataError(f"FOR IN ZIP items must have length in the STRICT "
+                                f"mode, but item {index} does not.")
         if len(set(lengths)) > 1:
-            raise DataError(f"FOR IN ZIP items should have equal lengths in STRICT "
+            raise DataError(f"FOR IN ZIP items must have equal lengths in the STRICT "
                             f"mode, but lengths are {seq2str(lengths, quote='')}.")
 
+    def _deprecate_different_lengths(self, values):
+        try:
+            self._validate_strict_lengths(values)
+        except DataError as err:
+            logger.warn(f"FOR IN ZIP default mode will be changed from SHORTEST to "
+                        f"STRICT in Robot Framework 8.0. Use 'mode=SHORTEST' to keep "
+                        f"using the SHORTEST mode. If the mode is not changed, "
+                        f"execution will fail like this in the future: {err}")
+
 
 class ForInEnumerateRunner(ForInRunner):
     flavor = 'IN ENUMERATE'
@@ -339,9 +348,9 @@ class ForInEnumerateRunner(ForInRunner):
             try:
                 return int(start)
             except ValueError:
-                raise DataError(f"Start value must be an integer, got '{start}'.")
+                raise DataError(f"Value must be an integer, got '{start}'.")
         except DataError as err:
-            raise DataError(f'Invalid start value: {err}')
+            raise DataError(f'Invalid FOR IN ENUMERATE start value: {err}')
 
     def _map_dict_values_to_rounds(self, values, per_round):
         if per_round > 3:
@@ -370,15 +379,13 @@ class WhileRunner:
         self._run = run
         self._templated = templated
 
-    def run(self, data):
+    def run(self, data, result):
         ctx = self._context
         error = None
         run = False
         limit = None
-        loop_result = WhileResult(data.condition, data.limit,
-                                  data.on_limit, data.on_limit_message,
-                                  starttime=get_timestamp())
-        iter_result = loop_result.body.create_iteration(starttime=get_timestamp())
+        result.start_time = datetime.now()
+        iter_result = result.body.create_iteration(start_time=datetime.now())
         if self._run:
             if data.error:
                 error = DataError(data.error, syntax=True)
@@ -391,9 +398,10 @@ class WhileRunner:
                     run = self._should_run(data.condition, ctx.variables)
                 except DataError as err:
                     error = err
-        with StatusReporter(data, loop_result, self._context, run):
+        with StatusReporter(data, result, self._context, run):
+            iter_data = data.get_iteration()
             if ctx.dry_run or not run:
-                self._run_iteration(data, iter_result, run)
+                self._run_iteration(iter_data, iter_result, run)
                 if error:
                     raise error
                 return
@@ -401,7 +409,7 @@ class WhileRunner:
             while True:
                 try:
                     with limit:
-                        self._run_iteration(data, iter_result)
+                        self._run_iteration(iter_data, iter_result)
                 except (BreakLoop, ContinueLoop) as ctrl:
                     if ctrl.earlier_failures:
                         errors.extend(ctrl.earlier_failures.get_errors())
@@ -420,7 +428,8 @@ class WhileRunner:
                     errors.extend(failed.get_errors())
                     if not failed.can_continue(ctx, self._templated):
                         break
-                iter_result = loop_result.body.create_iteration(starttime=get_timestamp())
+                iter_result = result.body.create_iteration(start_time=datetime.now())
+                iter_data = data.get_iteration()
                 if not self._should_run(data.condition, ctx.variables):
                     break
             if errors:
@@ -429,7 +438,7 @@ class WhileRunner:
     def _run_iteration(self, data, result, run=True):
         runner = BodyRunner(self._context, run, self._templated)
         with StatusReporter(data, result, self._context, run):
-            runner.run(data.body)
+            runner.run(data, result)
 
     def _should_run(self, condition, variables):
         if not condition:
@@ -450,13 +459,13 @@ class IfRunner:
         self._run = run
         self._templated = templated
 
-    def run(self, data):
+    def run(self, data, result):
         with self._dry_run_recursion_detection(data) as recursive_dry_run:
             error = None
-            with StatusReporter(data, IfResult(), self._context, self._run):
+            with StatusReporter(data, result, self._context, self._run):
                 for branch in data.body:
                     try:
-                        if self._run_if_branch(branch, recursive_dry_run, data.error):
+                        if self._run_if_branch(branch, result, recursive_dry_run, data.error):
                             self._run = False
                     except ExecutionStatus as err:
                         error = err
@@ -466,54 +475,52 @@ class IfRunner:
 
     @contextmanager
     def _dry_run_recursion_detection(self, data):
-        dry_run = self._context.dry_run
-        if dry_run:
-            recursive_dry_run = data in self._dry_run_stack
-            self._dry_run_stack.append(data)
+        if not self._context.dry_run:
+            yield False
         else:
-            recursive_dry_run = False
-        try:
-            yield recursive_dry_run
-        finally:
-            if dry_run:
+            data = data.to_dict()
+            recursive = data in self._dry_run_stack
+            self._dry_run_stack.append(data)
+            try:
+                yield recursive
+            finally:
                 self._dry_run_stack.pop()
 
-    def _run_if_branch(self, branch, recursive_dry_run=False, syntax_error=None):
+    def _run_if_branch(self, data, result, recursive_dry_run=False, syntax_error=None):
         context = self._context
-        result = IfBranchResult(branch.type, branch.condition, starttime=get_timestamp())
+        result = result.body.create_branch(data.type, data.condition,
+                                           start_time=datetime.now())
         error = None
         if syntax_error:
             run_branch = False
             error = DataError(syntax_error, syntax=True)
         else:
             try:
-                run_branch = self._should_run_branch(branch, context, recursive_dry_run)
+                run_branch = self._should_run_branch(data, context, recursive_dry_run)
             except DataError as err:
                 error = err
                 run_branch = False
-        with StatusReporter(branch, result, context, run_branch):
+        with StatusReporter(data, result, context, run_branch):
             runner = BodyRunner(context, run_branch, self._templated)
             if not recursive_dry_run:
-                runner.run(branch.body)
+                runner.run(data, result)
             if error and self._run:
                 raise error
         return run_branch
 
-    def _should_run_branch(self, branch, context, recursive_dry_run=False):
-        condition = branch.condition
-        variables = context.variables
+    def _should_run_branch(self, data, context, recursive_dry_run=False):
         if context.dry_run:
             return not recursive_dry_run
         if not self._run:
             return False
-        if condition is None:
+        if data.condition is None:
             return True
         try:
-            return evaluate_expression(condition, variables.current,
+            return evaluate_expression(data.condition, context.variables.current,
                                        resolve_variables=True)
         except Exception:
             msg = get_error_message()
-            raise DataError(f'Invalid {branch.type} condition: {msg}')
+            raise DataError(f'Invalid {data.type} condition: {msg}')
 
 
 class TryRunner:
@@ -523,39 +530,39 @@ class TryRunner:
         self._run = run
         self._templated = templated
 
-    def run(self, data):
+    def run(self, data, result):
         run = self._run
-        with StatusReporter(data, TryResult(), self._context, run):
+        with StatusReporter(data, result, self._context, run):
             if data.error:
-                self._run_invalid(data)
+                self._run_invalid(data, result)
                 return
-            error = self._run_try(data, run)
+            error = self._run_try(data, result, run)
             run_excepts_or_else = self._should_run_excepts_or_else(error, run)
             if error:
-                error = self._run_excepts(data, error, run=run_excepts_or_else)
-                self._run_else(data, run=False)
+                error = self._run_excepts(data, result, error, run=run_excepts_or_else)
+                self._run_else(data, result, run=False)
             else:
-                self._run_excepts(data, error, run=False)
-                error = self._run_else(data, run=run_excepts_or_else)
-            error = self._run_finally(data, run) or error
+                self._run_excepts(data, result, error, run=False)
+                error = self._run_else(data, result, run=run_excepts_or_else)
+            error = self._run_finally(data, result, run) or error
             if error:
                 raise error
 
-    def _run_invalid(self, data):
+    def _run_invalid(self, data, result):
         error_reported = False
         for branch in data.body:
-            result = TryBranchResult(branch.type, branch.patterns, branch.pattern_type,
-                                     branch.variable)
-            with StatusReporter(branch, result, self._context, run=False, suppress=True):
+            branch_result = result.body.create_branch(branch.type, branch.patterns,
+                                                      branch.pattern_type, branch.assign)
+            with StatusReporter(branch, branch_result, self._context, run=False, suppress=True):
                 runner = BodyRunner(self._context, run=False, templated=self._templated)
-                runner.run(branch.body)
+                runner.run(branch, branch_result)
                 if not error_reported:
                     error_reported = True
                     raise DataError(data.error, syntax=True)
         raise ExecutionFailed(data.error, syntax=True)
 
-    def _run_try(self, data, run):
-        result = TryBranchResult(data.TRY)
+    def _run_try(self, data, result, run):
+        result = result.body.create_branch(data.TRY)
         return self._run_branch(data.try_branch, result, run)
 
     def _should_run_excepts_or_else(self, error, run):
@@ -565,19 +572,19 @@ class TryRunner:
             return True
         return not (error.skip or error.syntax or isinstance(error, ExecutionPassed))
 
-    def _run_branch(self, branch, result, run=True, error=None):
+    def _run_branch(self, data, result, run=True, error=None):
         try:
-            with StatusReporter(branch, result, self._context, run):
+            with StatusReporter(data, result, self._context, run):
                 if error:
                     raise error
                 runner = BodyRunner(self._context, run, self._templated)
-                runner.run(branch.body)
+                runner.run(data, result)
         except ExecutionStatus as err:
             return err
         else:
             return None
 
-    def _run_excepts(self, data, error, run):
+    def _run_excepts(self, data, result, error, run):
         for branch in data.except_branches:
             try:
                 run_branch = run and self._should_run_except(branch, error)
@@ -586,15 +593,15 @@ class TryRunner:
                 pattern_error = err
             else:
                 pattern_error = None
-            result = TryBranchResult(branch.type, branch.patterns,
-                                     branch.pattern_type, branch.variable)
+            branch_result = result.body.create_branch(branch.type, branch.patterns,
+                                                      branch.pattern_type, branch.assign)
             if run_branch:
-                if branch.variable:
-                    self._context.variables[branch.variable] = str(error)
-                error = self._run_branch(branch, result, error=pattern_error)
+                if branch.assign:
+                    self._context.variables[branch.assign] = str(error)
+                error = self._run_branch(branch, branch_result, error=pattern_error)
                 run = False
             else:
-                self._run_branch(branch, result, run=False)
+                self._run_branch(branch, branch_result, run=False)
         return error
 
     def _should_run_except(self, branch, error):
@@ -602,9 +609,9 @@ class TryRunner:
             return True
         matchers = {
             'GLOB': lambda m, p: Matcher(p, spaceless=False, caseless=False).match(m),
+            'REGEXP': lambda m, p: re.fullmatch(p, m) is not None,
+            'START': lambda m, p: m.startswith(p),
             'LITERAL': lambda m, p: m == p,
-            'REGEXP': lambda m, p: re.match(rf'{p}\Z', m) is not None,
-            'START': lambda m, p: m.startswith(p)
         }
         if branch.pattern_type:
             pattern_type = self._context.variables.replace_string(branch.pattern_type)
@@ -612,25 +619,25 @@ class TryRunner:
             pattern_type = 'LITERAL'
         matcher = matchers.get(pattern_type.upper())
         if not matcher:
-            raise DataError(f"Invalid EXCEPT pattern type '{pattern_type}', "
-                            f"expected {seq2str(matchers, lastsep=' or ')}.")
+            raise DataError(f"Invalid EXCEPT pattern type '{pattern_type}'. "
+                            f"Valid values are {seq2str(matchers)}.")
         for pattern in branch.patterns:
             if matcher(error.message, self._context.variables.replace_string(pattern)):
                 return True
         return False
 
-    def _run_else(self, data, run):
+    def _run_else(self, data, result, run):
         if data.else_branch:
-            result = TryBranchResult(data.ELSE)
+            result = result.body.create_branch(data.ELSE)
             return self._run_branch(data.else_branch, result, run)
 
-    def _run_finally(self, data, run):
+    def _run_finally(self, data, result, run):
         if data.finally_branch:
-            result = TryBranchResult(data.FINALLY)
+            result = result.body.create_branch(data.FINALLY)
             try:
                 with StatusReporter(data.finally_branch, result, self._context, run):
                     runner = BodyRunner(self._context, run, self._templated)
-                    runner.run(data.finally_branch.body)
+                    runner.run(data.finally_branch, result)
             except ExecutionStatus as err:
                 return err
             else:
@@ -650,44 +657,55 @@ class WhileLimit:
                 on_limit_message = variables.replace_string(on_limit_message)
             except DataError as err:
                 raise DataError(f"Invalid WHILE loop 'on_limit_message': '{err}")
-        on_limit = cls.parse_on_limit(variables, on_limit)
+        on_limit = cls._parse_on_limit(variables, on_limit)
         if not limit:
-            return IterationCountLimit(DEFAULT_WHILE_LIMIT,
-                                       on_limit, on_limit_message)
-        value = variables.replace_string(limit)
-        if value.upper() == 'NONE':
+            return IterationCountLimit(DEFAULT_WHILE_LIMIT, on_limit, on_limit_message)
+        limit = variables.replace_string(limit)
+        if limit.upper() == 'NONE':
             return NoLimit()
         try:
-            count = int(value.replace(' ', ''))
+            count = cls._parse_limit_as_count(limit)
         except ValueError:
-            pass
+            seconds = cls._parse_limit_as_timestr(limit)
+            return DurationLimit(seconds, on_limit, on_limit_message)
         else:
-            if count <= 0:
-                raise DataError(f"Invalid WHILE loop limit: Iteration count must be "
-                                f"a positive integer, got '{count}'.")
             return IterationCountLimit(count, on_limit, on_limit_message)
-        try:
-            secs = timestr_to_secs(value)
-        except ValueError as err:
-            raise DataError(f'Invalid WHILE loop limit: {err.args[0]}')
-        else:
-            return DurationLimit(secs, on_limit, on_limit_message)
 
     @classmethod
-    def parse_on_limit(cls, variables, on_limit):
+    def _parse_on_limit(cls, variables, on_limit):
         if on_limit is None:
             return None
         try:
             on_limit = variables.replace_string(on_limit)
-            if on_limit.upper() not in ['PASS', 'FAIL']:
-                raise DataError("Value must be 'PASS' or 'FAIL'.")
+            if on_limit.upper() in ('PASS', 'FAIL'):
+                return on_limit.upper()
+            raise DataError(f"Value '{on_limit}' is not accepted. Valid values "
+                            f"are 'PASS' and 'FAIL'.")
         except DataError as err:
-            raise DataError(f"Invalid WHILE loop 'on_limit' value '{on_limit}': {err}")
-        else:
-            return on_limit.lower()
+            raise DataError(f"Invalid WHILE loop 'on_limit' value: {err}")
+
+    @classmethod
+    def _parse_limit_as_count(cls, limit):
+        limit = normalize(limit)
+        if limit.endswith('times'):
+            limit = limit[:-5]
+        elif limit.endswith('x'):
+            limit = limit[:-1]
+        count = int(limit)
+        if count <= 0:
+            raise DataError(f"Invalid WHILE loop limit: Iteration count must be "
+                            f"a positive integer, got '{count}'.")
+        return count
+
+    @classmethod
+    def _parse_limit_as_timestr(cls, limit):
+        try:
+            return timestr_to_secs(limit)
+        except ValueError as err:
+            raise DataError(f'Invalid WHILE loop limit: {err.args[0]}')
 
     def limit_exceeded(self):
-        on_limit_pass = self.on_limit == 'pass'
+        on_limit_pass = self.on_limit == 'PASS'
         if self.on_limit_message:
             raise LimitExceeded(on_limit_pass, self.on_limit_message)
         else:

{robotframework-6.1.1 → robotframework-7.0}/src/robot/running/builder/builders.py

@@ -26,7 +26,8 @@ from robot.parsing import (SuiteFile, SuiteDirectory, SuiteStructure,
                            SuiteStructureBuilder, SuiteStructureVisitor)
 from robot.utils import Importer, seq2str, split_args_from_name_or_path, type_name
 
-from ..model import ResourceFile, TestSuite
+from ..model import TestSuite
+from ..resourcemodel import ResourceFile
 from .parsers import (CustomParser, JsonParser, NoInitFileDirectoryParser, Parser,
                       RestParser, RobotParser)
 from .settings import TestDefaults

{robotframework-6.1.1 → robotframework-7.0}/src/robot/running/builder/parsers.py

@@ -22,9 +22,10 @@ from robot.errors import DataError
 from robot.parsing import File, get_init_model, get_model, get_resource_model
 from robot.utils import FileReader, get_error_message, read_rest_data, type_name
 
+from ..model import TestSuite
+from ..resourcemodel import ResourceFile
 from .settings import FileSettings, InitFileSettings, TestDefaults
 from .transformers import ResourceBuilder, SuiteBuilder
-from ..model import ResourceFile, TestSuite
 
 
 class Parser(ABC):
@@ -53,23 +54,21 @@ class RobotParser(Parser):
     def parse_suite_file(self, source: Path, defaults: TestDefaults) -> TestSuite:
         model = get_model(self._get_source(source), data_only=True,
                           curdir=self._get_curdir(source), lang=self.lang)
-        suite = TestSuite(name=TestSuite.name_from_source(source, self.extensions),
-                          source=source)
-        SuiteBuilder(suite, FileSettings(defaults)).build(model)
-        return suite
+        model.source = source
+        return self.parse_model(model, defaults)
 
     def parse_init_file(self, source: Path, defaults: TestDefaults) -> TestSuite:
         model = get_init_model(self._get_source(source), data_only=True,
                                curdir=self._get_curdir(source), lang=self.lang)
-        directory = source.parent
-        suite = TestSuite(name=TestSuite.name_from_source(directory),
-                          source=directory, rpa=None)
+        model.source = source
+        suite = TestSuite(name=TestSuite.name_from_source(source.parent),
+                          source=source.parent, rpa=None)
         SuiteBuilder(suite, InitFileSettings(defaults)).build(model)
         return suite
 
     def parse_model(self, model: File, defaults: 'TestDefaults|None' = None) -> TestSuite:
-        source = model.source
-        suite = TestSuite(name=TestSuite.name_from_source(source), source=source)
+        name = TestSuite.name_from_source(model.source, self.extensions)
+        suite = TestSuite(name=name, source=model.source)
         SuiteBuilder(suite, FileSettings(defaults)).build(model)
         return suite
 
@@ -82,8 +81,8 @@ class RobotParser(Parser):
     def parse_resource_file(self, source: Path) -> ResourceFile:
         model = get_resource_model(self._get_source(source), data_only=True,
                                    curdir=self._get_curdir(source), lang=self.lang)
+        model.source = source
         resource = self.parse_resource_model(model)
-        resource.source = source
         return resource
 
     def parse_resource_model(self, model: File) -> ResourceFile:

{robotframework-6.1.1 → robotframework-7.0}/src/robot/running/builder/settings.py

@@ -13,31 +13,23 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import sys
 from collections.abc import Sequence
+from typing import TypedDict
 
 from ..model import TestCase
 
 
-if sys.version_info >= (3, 8):
-    from typing import TypedDict
+class OptionalItems(TypedDict, total=False):
+    args: 'Sequence[str]'
+    lineno: int
 
 
-    class OptionalItems(TypedDict, total=False):
-        args: 'Sequence[str]'
-        lineno: int
+class FixtureDict(OptionalItems):
+    """Dictionary containing setup or teardown info.
 
-
-    class FixtureDict(OptionalItems):
-        """Dictionary containing setup or teardown info.
-
-        :attr:`args` and :attr:`lineno` are optional.
-        """
-        name: str
-
-else:
-    class FixtureDict(dict):
-        pass
+    :attr:`args` and :attr:`lineno` are optional.
+    """
+    name: str
 
 
 class TestDefaults: