robotframework 7.3.1__tar.gz → 7.3.2__tar.gz

{robotframework-7.3.1 → robotframework-7.3.2}/BUILD.rst

@@ -282,6 +282,6 @@ Announcements
 2. `Forum <https://forum.robotframework.org/>`_.
 
 3. `LinkedIn group <https://www.linkedin.com/groups/3710899/>`_. A personal
-    LinkedIn post is a good idea at least with bigger releases.
+   LinkedIn post is a good idea at least with bigger releases.
 
 4. `robotframework-users <https://groups.google.com/group/robotframework-users>`_

{robotframework-7.3.1 → robotframework-7.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework
-Version: 7.3.1
+Version: 7.3.2
 Summary: Generic automation framework for acceptance testing and robotic process automation (RPA)
 Home-page: https://robotframework.org
 Download-URL: https://pypi.org/project/robotframework
@@ -10,7 +10,7 @@ License: Apache License 2.0
 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-7.3.1.rst
+Project-URL: Release Notes, https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.3.2.rst
 Project-URL: Slack, http://slack.robotframework.org
 Keywords: robotframework automation testautomation rpa testing acceptancetesting atdd bdd
 Platform: any

{robotframework-7.3.1 → robotframework-7.3.2}/setup.py

@@ -6,7 +6,7 @@ from setuptools import find_packages, setup
 
 # Version number typically updated by running `invoke set-version <version>`.
 # Run `invoke --help set-version` or see tasks.py for details.
-VERSION = "7.3.1"
+VERSION = "7.3.2"
 with open(join(dirname(abspath(__file__)), "README.rst")) as f:
     LONG_DESCRIPTION = f.read()
     base_url = "https://github.com/robotframework/robotframework/blob/master"

{robotframework-7.3.1 → robotframework-7.3.2}/src/robot/libraries/BuiltIn.py

@@ -2184,11 +2184,14 @@ class _RunKeyword(_BuiltInBase):
         # to 'Keyword.run', but then it would be better if 'Run Keyword' would support
         # 'NONE' as a special value to not run anything similarly as setup/teardown.
         replaced = ctx.variables.replace_scalar(name, ignore_errors=ctx.in_teardown)
-        runner = ctx.get_runner(replaced, recommend_on_failure=False)
-        if hasattr(runner, "embedded_args"):
+        if self._accepts_embedded(replaced, ctx) and self._accepts_embedded(name, ctx):
             return name, args
         return replaced, args
 
+    def _accepts_embedded(self, name, ctx):
+        runner = ctx.get_runner(name, recommend_on_failure=False)
+        return hasattr(runner, "embedded_args")
+
     def _replace_variables_in_name_with_list_variable(self, name, args, ctx):
         # TODO: This seems to be the only place where `replace_until` is used.
         # That functionality should be removed from `replace_list` and implemented

{robotframework-7.3.1 → robotframework-7.3.2}/src/robot/result/executionresult.py

@@ -15,14 +15,15 @@
 
 from datetime import datetime
 from pathlib import Path
-from typing import overload, TextIO
+from typing import overload, Sequence, TextIO
 
 from robot.errors import DataError
-from robot.model import Statistics
+from robot.model import Statistics, SuiteVisitor
 from robot.utils import JsonDumper, JsonLoader, setter
 from robot.version import get_full_version
 
 from .executionerrors import ExecutionErrors
+from .flattenkeywordmatcher import Flattener
 from .model import TestSuite
 
 
@@ -154,17 +155,27 @@ class Result:
     def from_json(
         cls,
         source: "str|bytes|TextIO|Path",
+        include_keywords: bool = True,
+        flattened_keywords: Sequence[str] = (),
         rpa: "bool|None" = None,
     ) -> "Result":
         """Construct a result object from JSON data.
 
-        The data is given as the ``source`` parameter. It can be:
-
-        - a string (or bytes) containing the data directly,
-        - an open file object where to read the data from, or
-        - a path (``pathlib.Path`` or string) to a UTF-8 encoded file to read.
-
-        Data can contain either:
+        :param source: JSON data as a string or bytes containing the data
+            directly, an open file object where to read the data from, or a path
+            (``pathlib.Path`` or string) to a UTF-8 encoded file to read.
+        :param include_keywords: When ``False``, keyword and control structure
+            information is not parsed. This can save considerable amount of time
+            and memory. New in RF 7.3.2.
+        :param flattened_keywords: List of patterns controlling what keywords
+            and control structures to flatten. See the documentation of
+            the ``--flattenkeywords`` option for more details. New in RF 7.3.2.
+        :param rpa: Setting ``rpa`` either to ``True`` (RPA mode) or ``False``
+            (test automation) sets the execution mode explicitly. By default,
+            the mode is got from the parsed data.
+        :returns: :class:`Result` instance.
+
+        The data can contain either:
 
         - full result data (contains suite information, execution errors, etc.)
           got, for example, from the :meth:`to_json` method, or
@@ -174,13 +185,11 @@ class Result:
         :attr:`statistics` are populated automatically based on suite information
         and thus ignored if they are present in the data.
 
-        The ``rpa`` argument can be used to override the RPA mode. The mode is
-        got from the data by default.
-
         New in Robot Framework 7.2.
         """
+        loader = cls._get_json_loader(include_keywords)
         try:
-            data = JsonLoader().load(source)
+            data = loader.load(source)
         except (TypeError, ValueError) as err:
             raise DataError(f"Loading JSON data failed: {err}")
         if "suite" in data:
@@ -192,8 +201,27 @@ class Result:
             result.source = source
         elif isinstance(source, str) and source[0] != "{" and Path(source).exists():
             result.source = Path(source)
+        result.handle_suite_teardown_failures()
+        if not include_keywords:
+            result.suite.visit(KeywordRemover())
+        if flattened_keywords:
+            result.suite.visit(Flattener(flattened_keywords))
         return result
 
+    @classmethod
+    def _get_json_loader(cls, include_keywords: bool) -> JsonLoader:
+        if include_keywords:
+            return JsonLoader()
+
+        def remove_keywords(obj):
+            obj.pop("body", None)
+            obj.pop("setup", None)
+            # Teardowns cannot be removed yet, because we need to check suite
+            # teardown status. They are removed later using KeywordRemover.
+            return obj
+
+        return JsonLoader(object_hook=remove_keywords)
+
     @classmethod
     def _from_full_json(cls, data) -> "Result":
         return Result(
@@ -355,3 +383,13 @@ class CombinedResult(Result):
         self.set_execution_mode(other)
         self.suite.suites.append(other.suite)
         self.errors.add(other.errors)
+
+
+class KeywordRemover(SuiteVisitor):
+
+    def start_suite(self, suite):
+        suite.setup = suite.teardown = None
+
+    def visit_test(self, test):
+        test.setup = test.teardown = None
+        test.body = []

{robotframework-7.3.1 → robotframework-7.3.2}/src/robot/result/flattenkeywordmatcher.py

@@ -57,7 +57,8 @@ class FlattenByTypeMatcher:
         if "while" in flatten:
             self.types.add("while")
         if "iteration" in flatten or "foritem" in flatten:
-            self.types.add("iter")
+            self.types.add("iter")  # Matches output.xml tag.
+            self.types.add("iteration")  # Matches model object type.
 
     def match(self, tag):
         return tag in self.types
@@ -97,6 +98,34 @@ class FlattenByTagMatcher:
         return bool(self._matcher)
 
 
+class Flattener(SuiteVisitor):
+
+    def __init__(self, flatten):
+        self.name_matcher = FlattenByNameMatcher(flatten)
+        self.tag_matcher = FlattenByTagMatcher(flatten)
+        self.type_matcher = FlattenByTypeMatcher(flatten)
+
+    def start_suite(self, suite):
+        return bool(self)
+
+    def start_keyword(self, kw):
+        if self.name_matcher and self.name_matcher.match(kw.name, kw.owner):
+            self._flatten(kw)
+        if self.tag_matcher and self.tag_matcher.match(kw.tags):
+            self._flatten(kw)
+
+    def start_body_item(self, item):
+        if self.type_matcher and self.type_matcher.match(item.type.lower()):
+            self._flatten(item)
+
+    def _flatten(self, item):
+        item.message = create_flatten_message(item.message)
+        item.body = MessageFinder(item).messages
+
+    def __bool__(self):
+        return bool(self.name_matcher or self.tag_matcher or self.type_matcher)
+
+
 class FlattenByTags(SuiteVisitor):
 
     def __init__(self, flatten):
@@ -122,3 +151,10 @@ class MessageFinder(SuiteVisitor):
 
     def visit_message(self, message):
         self.messages.append(message)
+
+
+# TODO: Refactor this module in RF 7.4.
+# - Currently code working with XML tags and model objects is somewhat messy.
+#   Either separate it better or make it more generic.
+# - MessageFinder API is now that nice.
+# - The module doesn't anymore contain only matchers so it should be renamed.

{robotframework-7.3.1 → robotframework-7.3.2}/src/robot/result/resultbuilder.py

@@ -13,13 +13,13 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from typing import Sequence
 from xml.etree import ElementTree as ET
 
 from robot.errors import DataError
-from robot.model import SuiteVisitor
 from robot.utils import ETSource, get_error_message
 
-from .executionresult import CombinedResult, is_json_source, Result
+from .executionresult import CombinedResult, is_json_source, KeywordRemover, Result
 from .flattenkeywordmatcher import (
     create_flatten_message, FlattenByNameMatcher, FlattenByTags, FlattenByTypeMatcher
 )
@@ -27,20 +27,28 @@ from .merger import Merger
 from .xmlelementhandlers import XmlElementHandler
 
 
-def ExecutionResult(*sources, **options):
+def ExecutionResult(
+    *sources,
+    merge: bool = False,
+    include_keywords: bool = True,
+    flattened_keywords: Sequence[str] = (),
+    rpa: "bool|None" = None,
+):
     """Factory method to constructs :class:`~.executionresult.Result` objects.
 
     :param sources: XML or JSON source(s) containing execution results.
         Can be specified as paths (``pathlib.Path`` or ``str``), opened file
         objects, or strings/bytes containing XML/JSON directly.
-    :param options: Configuration options.
-        Using ``merge=True`` causes multiple results to be combined so that
-        tests in the latter results replace the ones in the original.
-        Setting ``rpa`` either to ``True`` (RPA mode) or ``False`` (test
-        automation) sets execution mode explicitly. By default, it is got
+    :param merge: When ``True`` and multiple sources are given, results are merged
+        instead of combined.
+    :param include_keywords: When ``False``, keyword and control structure information
+        is not parsed. This can save considerable amount of time and memory.
+    :param flattened_keywords: List of patterns controlling what keywords
+        and control structures to flatten. See the documentation of
+        the ``--flattenkeywords`` option for more details.
+    :param rpa: Setting ``rpa`` either to ``True`` (RPA mode) or ``False`` (test
+        automation) sets the execution mode explicitly. By default, the mode is got
         from processed output files and conflicting modes cause an error.
-        Other options are passed directly to the
-        :class:`ExecutionResultBuilder` object used internally.
     :returns: :class:`~.executionresult.Result` instance.
 
     A source is considered to be JSON in these cases:
@@ -53,7 +61,12 @@ def ExecutionResult(*sources, **options):
     """
     if not sources:
         raise DataError("One or more data source needed.")
-    if options.pop("merge", False):
+    options = {
+        "include_keywords": include_keywords,
+        "flattened_keywords": flattened_keywords,
+        "rpa": rpa,
+    }
+    if merge:
         return _merge_results(sources[0], sources[1:], options)
     if len(sources) > 1:
         return _combine_results(sources, options)
@@ -63,8 +76,8 @@ def ExecutionResult(*sources, **options):
 def _merge_results(original, merged, options):
     result = ExecutionResult(original, **options)
     merger = Merger(result, rpa=result.rpa)
-    for path in merged:
-        merged = ExecutionResult(path, **options)
+    for source in merged:
+        merged = ExecutionResult(source, **options)
         merger.merge(merged)
     return result
 
@@ -75,13 +88,13 @@ def _combine_results(sources, options):
 
 def _single_result(source, options):
     if is_json_source(source):
-        return _json_result(source, options)
-    return _xml_result(source, options)
+        return _json_result(source, **options)
+    return _xml_result(source, **options)
 
 
-def _json_result(source, options):
+def _json_result(source, include_keywords, flattened_keywords, rpa):
     try:
-        return Result.from_json(source, rpa=options.get("rpa"))
+        return Result.from_json(source, include_keywords, flattened_keywords, rpa)
     except IOError as err:
         error = err.strerror
     except Exception:
@@ -89,11 +102,12 @@ def _json_result(source, options):
     raise DataError(f"Reading JSON source '{source}' failed: {error}")
 
 
-def _xml_result(source, options):
+def _xml_result(source, include_keywords, flattened_keywords, rpa):
     ets = ETSource(source)
-    result = Result(source, rpa=options.pop("rpa", None))
+    builder = ExecutionResultBuilder(ets, include_keywords, flattened_keywords)
+    result = Result(source, rpa=rpa)
     try:
-        return ExecutionResultBuilder(ets, **options).build(result)
+        return builder.build(result)
     except IOError as err:
         error = err.strerror
     except Exception:
@@ -101,6 +115,9 @@ def _xml_result(source, options):
     raise DataError(f"Reading XML source '{ets}' failed: {error}")
 
 
+# TODO:
+# - Rename e.g. to XmlExecutionResultBuilder. Probably best done in a major release.
+# - Add Result.from_xml as a more convenient API. Could be done in RF 7.4.
 class ExecutionResultBuilder:
     """Builds :class:`~.executionresult.Result` objects based on XML output files.
 
@@ -108,7 +125,7 @@ class ExecutionResultBuilder:
     :func:`ExecutionResult` factory method.
     """
 
-    def __init__(self, source, include_keywords=True, flattened_keywords=None):
+    def __init__(self, source, include_keywords=True, flattened_keywords=()):
         """
         :param source: Path to the XML output file to build
             :class:`~.executionresult.Result` objects from.
@@ -134,7 +151,7 @@ class ExecutionResultBuilder:
             # flatten based on them when parsing output.xml.
             result.suite.visit(FlattenByTags(self._flattened_keywords))
         if not self._include_keywords:
-            result.suite.visit(RemoveKeywords())
+            result.suite.visit(KeywordRemover())
         return result
 
     def _parse(self, source, start, end):
@@ -151,11 +168,11 @@ class ExecutionResultBuilder:
                 elem.clear()
 
     def _omit_keywords(self, context):
-        omitted_elements = {"kw", "for", "while", "if", "try"}
+        omitted_elements = {"kw", "for", "while", "if", "try", "group", "variable"}
         omitted = 0
         for event, elem in context:
-            # Teardowns aren't omitted yet to allow checking suite teardown status.
-            # They'll be removed later when not needed in `build()`.
+            # Teardowns cannot be removed yet, because we need to check suite
+            # teardown status. They are removed later using KeywordRemover.
             omit = elem.tag in omitted_elements and elem.get("type") != "TEARDOWN"
             start = event == "start"
             if omit and start:
@@ -172,44 +189,33 @@ class ExecutionResultBuilder:
         name_match, by_name = self._get_matcher(FlattenByNameMatcher, flattened)
         type_match, by_type = self._get_matcher(FlattenByTypeMatcher, flattened)
         started = -1  # If 0 or more, we are flattening.
-        containers = {"kw", "for", "while", "iter", "if", "try"}
-        inside = 0  # To make sure we don't read tags from a test.
+        include_on_top = {"doc", "tag", "timeout", "status"}
         for event, elem in context:
             tag = elem.tag
             if event == "start":
-                if tag in containers:
-                    inside += 1
-                    if started >= 0:
-                        started += 1
-                    elif by_name and name_match(
+                if started >= 0:
+                    started += 1
+                elif (
+                    by_name
+                    and tag == "kw"
+                    and name_match(
                         elem.get("name", ""),
                         elem.get("owner") or elem.get("library"),
-                    ):
-                        started = 0
-                    elif by_type and type_match(tag):
-                        started = 0
-            else:
-                if tag in containers:
-                    inside -= 1
-                elif started == 0 and tag == "status":
-                    elem.text = create_flatten_message(elem.text)
-            if started <= 0 or tag == "msg":
+                        # 'library' is for RF < 7 compatibility
+                    )
+                ):
+                    started = 0
+                elif by_type and type_match(tag):
+                    started = 0
+            elif started == 1 and tag == "status":
+                elem.text = create_flatten_message(elem.text)
+            if started <= 0 or (started == 1 and tag in include_on_top) or tag == "msg":
                 yield event, elem
             else:
                 elem.clear()
-            if started >= 0 and event == "end" and tag in containers:
+            if started >= 0 and event == "end":
                 started -= 1
 
     def _get_matcher(self, matcher_class, flattened):
         matcher = matcher_class(flattened)
         return matcher.match, bool(matcher)
-
-
-class RemoveKeywords(SuiteVisitor):
-
-    def start_suite(self, suite):
-        suite.setup = None
-        suite.teardown = None
-
-    def visit_test(self, test):
-        test.body = []

{robotframework-7.3.1 → robotframework-7.3.2}/src/robot/result/suiteteardownfailed.py

@@ -19,12 +19,12 @@ from robot.model import SuiteVisitor
 class SuiteTeardownFailureHandler(SuiteVisitor):
 
     def end_suite(self, suite):
-        teardown = suite.teardown
-        # Both 'PASS' and 'NOT RUN' statuses are OK.
-        if teardown and teardown.status == teardown.FAIL:
-            suite.suite_teardown_failed(teardown.message)
-        if teardown and teardown.status == teardown.SKIP:
-            suite.suite_teardown_skipped(teardown.message)
+        if suite.has_teardown:
+            teardown = suite.teardown
+            if teardown.status == teardown.FAIL:
+                suite.suite_teardown_failed(teardown.message)
+            if teardown.status == teardown.SKIP:
+                suite.suite_teardown_skipped(teardown.message)
 
     def visit_test(self, test):
         pass

{robotframework-7.3.1 → robotframework-7.3.2}/src/robot/running/bodyrunner.py

@@ -108,7 +108,9 @@ class KeywordRunner:
         # BuiltIn.run_keyword has the same logic.
         runner = context.get_runner(name, recommend_on_failure=self._run)
         if hasattr(runner, "embedded_args") and name != data.name:
-            runner = context.get_runner(data.name)
+            candidate = context.get_runner(data.name)
+            if hasattr(candidate, "embedded_args"):
+                runner = candidate
         return runner
 
 

{robotframework-7.3.1 → robotframework-7.3.2}/src/robot/running/namespace.py

@@ -17,6 +17,7 @@ import copy
 import os
 from collections import OrderedDict
 
+from robot.conf import Languages
 from robot.errors import DataError, KeywordError
 from robot.libraries import STDLIBS
 from robot.output import LOGGER, Message
@@ -231,7 +232,7 @@ class Namespace:
 
 class KeywordStore:
 
-    def __init__(self, suite_file, languages):
+    def __init__(self, suite_file, languages: Languages):
         self.suite_file = suite_file
         self.libraries = OrderedDict()
         self.resources = ImportCache()
@@ -300,6 +301,9 @@ class KeywordStore:
         runner = None
         if strip_bdd_prefix:
             runner = self._get_bdd_style_runner(name)
+            if runner:
+                runner = copy.copy(runner)
+                runner.name = name
         if not runner:
             runner = self._get_runner_from_suite_file(name)
         if not runner and "." in name:
@@ -309,13 +313,27 @@ class KeywordStore:
         return runner
 
     def _get_bdd_style_runner(self, name):
+        # TODO: Consider using 'startswith' instead of regexps for checking does any
+        # prefix match. That ought to make that check a bit faster (especially if the
+        # tuple of prefixes is pre-built in 'Languages'), but finding the keyword if
+        # there's a match can be a bit slower. It also makes it explicit that prefixes
+        # are constants, not patterns, and allows deprecating 'bdd_prefix_regexp'.
         match = self.languages.bdd_prefix_regexp.match(name)
-        if match:
-            runner = self._get_runner(name[match.end() :], strip_bdd_prefix=False)
-            if runner:
-                runner = copy.copy(runner)
-                runner.name = name
-                return runner
+        if not match:
+            return None
+        runner = self._get_runner(name[match.end() :], strip_bdd_prefix=False)
+        if runner:
+            return runner
+        # Some prefix matched, but there was no matching keyword. Go through all
+        # prefixes individually to see were there possibly multiple matching ones.
+        # https://github.com/robotframework/robotframework/issues/5456
+        name = " ".join(name.split()).title()  # Normalize spaces and case.
+        for prefix in sorted(self.languages.bdd_prefixes, key=len, reverse=True):
+            prefix += " "
+            if name.startswith(prefix):
+                runner = self._get_runner(name[len(prefix) :], strip_bdd_prefix=False)
+                if runner:
+                    return runner
         return None
 
     def _get_implicit_runner(self, name):

{robotframework-7.3.1 → robotframework-7.3.2}/src/robot/utils/json.py

@@ -15,15 +15,48 @@
 
 import json
 from pathlib import Path
-from typing import Any, Dict, overload, TextIO
+from typing import Dict, overload, TextIO
 
 from .error import get_error_message
 from .robottypes import type_name
 
-DataDict = Dict[str, Any]
+DataDict = Dict[str, object]
 
 
 class JsonLoader:
+    """Generic JSON object loader.
+
+    JSON source can be a string or bytes, a path or an open file object.
+    The top level JSON item must always be a dictionary.
+
+    Supports the same configuration parameters as the underlying  `json.load`__
+    except for ``object_pairs_hook``. As a special feature, handles duplicate
+    items so that lists are merged.
+
+    __ https://docs.python.org/3/library/json.html#json.load
+    """
+
+    def __init__(self, **config):
+        self.config = self._add_hook_to_merge_duplicate_lists(config)
+
+    def _add_hook_to_merge_duplicate_lists(self, config):
+        object_hook = config.get("object_hook")
+        object_pairs_hook = config.get("object_pairs_hook")
+        if object_pairs_hook:
+            raise ValueError("'object_pairs_hook' is not supported.")
+
+        def merge_duplicate_lists(items: "list[tuple[str, object]]") -> DataDict:
+            data = {}
+            for name, value in items:
+                if name in data and isinstance(value, list):
+                    data[name].extend(value)
+                else:
+                    data[name] = value
+            return object_hook(data) if object_hook else data
+
+        config["object_pairs_hook"] = merge_duplicate_lists
+        return config
+
     def load(self, source: "str|bytes|TextIO|Path") -> DataDict:
         try:
             data = self._load(source)
@@ -33,21 +66,30 @@ class JsonLoader:
             raise TypeError(f"Expected dictionary, got {type_name(data)}.")
         return data
 
-    def _load(self, source):
+    def _load(self, source: "str|bytes|TextIO|Path") -> object:
         if self._is_path(source):
             with open(source, encoding="UTF-8") as file:
-                return json.load(file)
+                return json.load(file, **self.config)
         if hasattr(source, "read"):
-            return json.load(source)
-        return json.loads(source)
+            return json.load(source, **self.config)
+        return json.loads(source, **self.config)
 
-    def _is_path(self, source):
+    def _is_path(self, source: "str|bytes|TextIO|Path") -> bool:
         if isinstance(source, Path):
             return True
         return isinstance(source, str) and "{" not in source
 
 
 class JsonDumper:
+    """Generic JSON dumper.
+
+    JSON can be written to a file given as a path or as an open file object.
+    If no output is given, JSON is returned as a string.
+
+    Supports the same configuration as the underlying `json.dump`__.
+
+    __ https://docs.python.org/3/library/json.html#json.load
+    """
 
     def __init__(self, **config):
         self.config = config
@@ -64,8 +106,10 @@ class JsonDumper:
         elif isinstance(output, (str, Path)):
             with open(output, "w", encoding="UTF-8") as file:
                 json.dump(data, file, **self.config)
+            return None
         elif hasattr(output, "write"):
             json.dump(data, output, **self.config)
+            return None
         else:
             raise TypeError(
                 f"Output should be None, path or open file, got {type_name(output)}."

{robotframework-7.3.1 → robotframework-7.3.2}/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 = "7.3.1"
+VERSION = "7.3.2"
 
 
 def get_version(naked=False):

{robotframework-7.3.1 → robotframework-7.3.2}/src/robotframework.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework
-Version: 7.3.1
+Version: 7.3.2
 Summary: Generic automation framework for acceptance testing and robotic process automation (RPA)
 Home-page: https://robotframework.org
 Download-URL: https://pypi.org/project/robotframework
@@ -10,7 +10,7 @@ License: Apache License 2.0
 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-7.3.1.rst
+Project-URL: Release Notes, https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.3.2.rst
 Project-URL: Slack, http://slack.robotframework.org
 Keywords: robotframework automation testautomation rpa testing acceptancetesting atdd bdd
 Platform: any