robotframework 6.1.1__zip → 7.0a1__zip

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework
-Version: 6.1.1
+Version: 7.0a1
 Summary: Generic automation framework for acceptance testing and robotic process automation (RPA)
 Home-page: https://robotframework.org
 Author: Pekka Klärck
@@ -10,9 +10,8 @@ Download-URL: https://pypi.org/project/robotframework
 Project-URL: Source, https://github.com/robotframework/robotframework
 Project-URL: Issue Tracker, https://github.com/robotframework/robotframework/issues
 Project-URL: Documentation, https://robotframework.org/robotframework
-Project-URL: Release Notes, https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-6.1.1.rst
+Project-URL: Release Notes, https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.0a1.rst
 Project-URL: Slack, http://slack.robotframework.org
-Project-URL: Twitter, https://twitter.com/robotframework
 Description: Robot Framework
         ===============
         
@@ -171,8 +170,6 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -184,5 +181,5 @@ Classifier: Topic :: Software Development :: Testing
 Classifier: Topic :: Software Development :: Testing :: Acceptance
 Classifier: Topic :: Software Development :: Testing :: BDD
 Classifier: Framework :: Robot Framework
-Requires-Python: >=3.6
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst

{robotframework-6.1.1 → robotframework-7.0a1}/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 = '6.1.1'
+VERSION = '7.0a1'
 with open(join(dirname(abspath(__file__)), 'README.rst')) as f:
     LONG_DESCRIPTION = f.read()
     base_url = 'https://github.com/robotframework/robotframework/blob/master'
@@ -22,8 +22,6 @@ License :: OSI Approved :: Apache Software License
 Operating System :: OS Independent
 Programming Language :: Python :: 3
 Programming Language :: Python :: 3 :: Only
-Programming Language :: Python :: 3.6
-Programming Language :: Python :: 3.7
 Programming Language :: Python :: 3.8
 Programming Language :: Python :: 3.9
 Programming Language :: Python :: 3.10
@@ -57,7 +55,6 @@ setup(
         'Documentation': 'https://robotframework.org/robotframework',
         'Release Notes': f'https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-{VERSION}.rst',
         'Slack': 'http://slack.robotframework.org',
-        'Twitter': 'https://twitter.com/robotframework',
     },
     download_url = 'https://pypi.org/project/robotframework',
     license      = 'Apache License 2.0',
@@ -66,7 +63,7 @@ setup(
     long_description_content_type = 'text/x-rst',
     keywords     = KEYWORDS,
     platforms    = 'any',
-    python_requires='>=3.6',
+    python_requires='>=3.8',
     classifiers  = CLASSIFIERS,
     package_dir  = {'': 'src'},
     package_data = {'robot': PACKAGE_DATA},

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/api/interfaces.py

@@ -34,9 +34,6 @@ base class.
 .. note:: These classes are not exposed via the top level :mod:`robot.api`
           package and need to imported via :mod:`robot.api.interfaces`.
 
-.. note:: Using this module requires having the typing_extensions__ module
-          installed when using Python 3.6 or 3.7.
-
 This module is new in Robot Framework 6.1.
 
 __ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#dynamic-library-api
@@ -44,22 +41,12 @@ __ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#
 __ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#listener-version-2
 __ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#listener-version-3
 __ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#parser-interface
-__ https://pypi.org/project/typing-extensions/
 """
 
 import sys
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
-# Need to use version check and not try/except to support Mypy's stubgen.
-if sys.version_info >= (3, 8):
-    from typing import TypedDict
-else:
-    try:
-        from typing_extensions import TypedDict
-    except ImportError:
-        raise ImportError("Using the 'robot.api.interfaces' module requires having "
-                          "the 'typing_extensions' module installed with Python < 3.8.")
+from typing import Any, Optional, Mapping, Sequence, TypedDict, Union
 if sys.version_info >= (3, 10):
     from types import UnionType
 else:
@@ -72,32 +59,32 @@ from robot.running import TestDefaults, TestSuite
 
 # Type aliases used by DynamicLibrary and HybridLibrary.
 Name = str
-PositArgs = List[Any]
-NamedArgs = Dict[str, Any]
+PositArgs = Sequence[Any]
+NamedArgs = Mapping[str, Any]
 Documentation = str
-Arguments = List[
+Arguments = Sequence[
     Union[
-        str,               # Name with possible default like `arg` or `arg=1`.
-        Tuple[str],        # Name without a default like `('arg',)`.
-        Tuple[str, Any]    # Name and default like `('arg', 1)`.
+        str,                   # Name with possible default like `arg` or `arg=1`.
+        'tuple[str]',          # Name without a default like `('arg',)`.
+        'tuple[str, Any]'      # Name and default like `('arg', 1)`.
     ]
 ]
-Type = Union[
-    type,                           # Actual type.
-    str,                            # Type name or alias.
-    UnionType,                      # Union syntax (e.g. `int | float`).
-    Tuple[Union[type, str], ...]    # Tuple of types. Behaves like union.
+TypeHint = Union[
+    type,                      # Actual type.
+    str,                       # Type name or alias.
+    UnionType,                 # Union syntax (e.g. `int | float`).
+    'tuple[TypeHint, ...]'     # Tuple of type hints. Behaves like a union.
 ]
-Types = Union[
-    Dict[str, Type],       # Types by name.
-    List[                  # Types by position.
+TypeHints = Union[
+    Mapping[str, TypeHint],    # Types by name.
+    Sequence[                  # Types by position.
         Union[
-            Type,          # Type info.
-            None           # No type info.
+            TypeHint,          # Type hint.
+            None               # No type hint.
         ]
     ]
 ]
-Tags = List[str]
+Tags = Sequence[str]
 Source = str
 
 
@@ -112,7 +99,7 @@ class DynamicLibrary(ABC):
     """
 
     @abstractmethod
-    def get_keyword_names(self) -> List[Name]:
+    def get_keyword_names(self) -> Sequence[Name]:
         """Return names of the keywords this library implements.
 
         :return: Keyword names as a list of strings.
@@ -198,7 +185,7 @@ class DynamicLibrary(ABC):
         """
         return None
 
-    def get_keyword_types(self, name: Name) -> Optional[Types]:
+    def get_keyword_types(self, name: Name) -> Optional[TypeHints]:
         """Optional method to return keyword's type specification.
 
         Type information is used for automatic argument conversion during
@@ -281,7 +268,7 @@ class HybridLibrary(ABC):
     """
 
     @abstractmethod
-    def get_keyword_names(self) -> List[Name]:
+    def get_keyword_names(self) -> Sequence[Name]:
         """Return names of the implemented keyword methods as a list or strings.
 
         Returned names must match names of the implemented keyword methods.
@@ -301,8 +288,8 @@ class StartSuiteAttributes(TypedDict):
     doc: str
     metadata: dict
     source: str
-    suites: List[str]
-    tests: List[str]
+    suites: 'list[str]'
+    tests: 'list[str]'
     totaltests: int
     starttime: str
 
@@ -328,7 +315,7 @@ class StartTestAttributes(TypedDict):
     longname: str
     originalname: str
     doc: str
-    tags: List[str]
+    tags: 'list[str]'
     template: str
     source: str
     lineno: int
@@ -353,21 +340,21 @@ class OptionalKeywordAttributes(TypedDict, total=False):
     IF structures attributes include ``condition``.
     """
     # FOR
-    variables: List[str]
+    variables: 'list[str]'
     flavor: str
-    values: List[str]
+    values: 'list[str]'
     # ITERATION with FOR
-    variables: Dict[str, str]
+    variables: 'dict[str, str]'
     # WHILE and IF
     condition: str
     # WHILE
     limit: str
     # EXCEPT
-    patterns: List[str]
+    patterns: 'list[str]'
     pattern_type: str
     variable: str
     # RETURN
-    values: List[str]
+    values: 'list[str]'
 
 
 class StartKeywordAttributes(OptionalKeywordAttributes):
@@ -379,9 +366,9 @@ class StartKeywordAttributes(OptionalKeywordAttributes):
     kwname: str
     libname: str
     doc: str
-    args: List[str]
-    assign: List[str]
-    tags: List[str]
+    args: 'list[str]'
+    assign: 'list[str]'
+    tags: 'list[str]'
     source: str
     lineno: int
     status: str
@@ -413,7 +400,7 @@ class LibraryAttributes(TypedDict):
 
     See the User Guide for more information.
     """
-    args: List[str]
+    args: 'list[str]'
     originalname: str
     source: str
     importer: Union[str, None]
@@ -433,7 +420,7 @@ class VariablesAttributes(TypedDict):
 
     See the User Guide for more information.
     """
-    args: List[str]
+    args: 'list[str]'
     source: str
     importer: Union[str, None]
 
@@ -531,7 +518,7 @@ class ListenerV3:
         """Called when a test or task starts."""
 
     def end_test(self, data: running.TestCase, result: result.TestCase):
-        """Called when a test or ends starts."""
+        """Called when a test or tasks ends."""
 
     def log_message(self, message: Message):
         """Called when a normal log message are emitted.

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/api/parsing.py

@@ -223,7 +223,7 @@ Statements:
 - :class:`~robot.parsing.model.statements.Template`
 - :class:`~robot.parsing.model.statements.Timeout`
 - :class:`~robot.parsing.model.statements.Arguments`
-- :class:`~robot.parsing.model.statements.Return` (deprecated, will mean ``ReturnStatement`` in RF 7.0)
+- :class:`~robot.parsing.model.statements.Return` (deprecated, will mean ``ReturnStatement`` in RF 8.0)
 - :class:`~robot.parsing.model.statements.ReturnSetting` (alias for ``Return``, new in RF 6.1)
 - :class:`~robot.parsing.model.statements.KeywordCall`
 - :class:`~robot.parsing.model.statements.TemplateArguments`
@@ -236,6 +236,7 @@ Statements:
 - :class:`~robot.parsing.model.statements.FinallyHeader`
 - :class:`~robot.parsing.model.statements.ForHeader`
 - :class:`~robot.parsing.model.statements.WhileHeader`
+- :class:`~robot.parsing.model.statements.Var` (new in RF 7.0)
 - :class:`~robot.parsing.model.statements.End`
 - :class:`~robot.parsing.model.statements.ReturnStatement`
 - :class:`~robot.parsing.model.statements.Break`
@@ -519,7 +520,7 @@ from robot.parsing.model.statements import (
     TestTeardown,
     TestTemplate,
     TestTimeout,
-    ForceTags,
+    TestTags,
     DefaultTags,
     KeywordTags,
     Variable,
@@ -545,6 +546,7 @@ from robot.parsing.model.statements import (
     ForHeader,
     WhileHeader,
     End,
+    Var,
     ReturnStatement,
     Continue,
     Break,

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/conf/gatherfailed.py

@@ -26,7 +26,7 @@ class GatherFailedTests(SuiteVisitor):
 
     def visit_test(self, test):
         if test.failed:
-            self.tests.append(glob_escape(test.longname))
+            self.tests.append(glob_escape(test.full_name))
 
     def visit_keyword(self, kw):
         pass
@@ -39,7 +39,7 @@ class GatherFailedSuites(SuiteVisitor):
 
     def start_suite(self, suite):
         if any(test.failed for test in suite.tests):
-            self.suites.append(glob_escape(suite.longname))
+            self.suites.append(glob_escape(suite.full_name))
 
     def visit_test(self, test):
         pass

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/conf/languages.py

@@ -130,15 +130,6 @@ class Languages:
             languages = [languages]
         if add_english:
             languages.append(En())
-            # The English singular forms are added for backwards compatibility
-            self.headers = {
-                'Setting': 'Settings',
-                'Variable': 'Variables',
-                'Test Case': 'Test Cases',
-                'Task': 'Tasks',
-                'Keyword': 'Keywords',
-                'Comment': 'Comments'
-            }
         return languages
 
     def _get_available_languages(self) -> 'dict[str, type[Language]]':

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/conf/settings.py

@@ -20,13 +20,14 @@ import string
 import sys
 import time
 import warnings
+from datetime import datetime
 from pathlib import Path
 
 from robot.errors import DataError, FrameworkError
 from robot.output import LOGGER, loggerhelper
 from robot.result.keywordremover import KeywordRemover
 from robot.result.flattenkeywordmatcher import validate_flatten_keyword
-from robot.utils import (abspath, create_destination_directory, escape, format_time,
+from robot.utils import (abspath, create_destination_directory, escape,
                          get_link_path, html_escape, is_list_like, plural_or_not as s,
                          seq2str, split_args_from_name_or_path)
 
@@ -73,7 +74,7 @@ class _BaseSettings:
     _output_opts = ['Output', 'Log', 'Report', 'XUnit', 'DebugFile']
 
     def __init__(self, options=None, **extra_options):
-        self.start_timestamp = format_time(time.time(), '', '-', '')
+        self.start_time = datetime.now()
         self._opts = {}
         self._cli_opts = self._cli_opts.copy()
         self._cli_opts.update(self._extra_cli_opts)
@@ -230,7 +231,9 @@ class _BaseSettings:
     def _process_output_name(self, option, name):
         base, ext = os.path.splitext(name)
         if self['TimestampOutputs']:
-            base = f'{base}-{self.start_timestamp}'
+            s = self.start_time
+            base = (f'{base}-{s.year}{s.month:02}{s.day:02}-'
+                    f'{s.hour:02}{s.minute:02}{s.second:02}')
         ext = self._get_output_extension(ext, option)
         return base + ext
 
@@ -336,7 +339,7 @@ class _BaseSettings:
     def _validate_remove_keywords(self, values):
         for value in values:
             try:
-                KeywordRemover(value)
+                KeywordRemover.from_config(value)
             except DataError as err:
                 self._raise_invalid('RemoveKeywords', err)
 
@@ -488,7 +491,7 @@ class RobotSettings(_BaseSettings):
 
     def get_rebot_settings(self):
         settings = RebotSettings()
-        settings.start_timestamp = self.start_timestamp
+        settings.start_time = self.start_time
         not_copied = {'Include', 'Exclude', 'TestNames', 'SuiteNames', 'ParseInclude',
                       'Name', 'Doc', 'Metadata', 'SetTag', 'Output', 'LogLevel',
                       'TimestampOutputs'}

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/htmldata/rebot/log.css

@@ -73,6 +73,10 @@
 }
 .name {
     font-weight: bold;
+    white-space: pre-wrap;
+}
+.arg, .assign {
+    white-space: pre-wrap;
 }
 .elapsed {
     float: right;

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/htmldata/rebot/log.html

@@ -322,8 +322,9 @@ function addExecutionLog(main) {
       <div class="element-header-left" title="${type}  {{if name}}{{html fullName}}  {{/if}}[${status}]">
         <span class="elapsed" title="Elapsed time">${times.elapsedTime}</span>
         <span class="label ${status.toLowerCase()}">${type}</span>
-        <span>{{html assign}}</span>
+        <span class="assign">{{html assign}}</span>
         <span class="name"><span class="parent-name">{{html libname}}{{if libname}} . {{/if}}</span>{{html name}}</span>
+        &nbsp;
         <span class="arg">{{html arguments}}</span>
       </div>
       <div class="element-header-right" onclick="stopPropagation(event)">
@@ -357,6 +358,12 @@ function addExecutionLog(main) {
           <th>Start / End / Elapsed:</th>
           <td>${times.startTime} / ${times.endTime} / ${times.elapsedTime}</td>
         </tr>
+        {{if message()}}
+        <tr>
+          <th>Message:</th>
+          <td class="message">{{html message()}}</td>
+        </tr>
+        {{/if}}
       </table>
     </div>
   </div>
@@ -379,6 +386,7 @@ function addExecutionLog(main) {
   <div id="log-level-selector">
   Log level:
     <select onchange="logLevelSelected(this.options[selectedIndex].value)">
+      <option value="3">WARN</option>
       <option value="2">INFO</option>
       <option value="1">DEBUG</option>
       {{if showTrace()}}<option value="0">TRACE</option>{{/if}}

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/htmldata/rebot/model.js

@@ -14,7 +14,6 @@ window.model = (function () {
         suite.populateSuites = createIterablePopulator('Suite');
         suite.childrenNames = ['keyword', 'suite', 'test'];
         suite.callWhenChildrenReady = function (callable) { callable(); };
-        suite.message = data.message;
         suite.children = function () {
             return suite.keywords().concat(suite.tests()).concat(suite.suites());
         };
@@ -110,6 +109,7 @@ window.model = (function () {
             name: data.name,
             doc: data.doc,
             status: data.status,
+            message: data.message,
             times: data.times,
             id: data.parent ? data.parent.id + '-' + data.id : data.id
         };
@@ -131,7 +131,6 @@ window.model = (function () {
                 return test.keywords();
         };
         test.tags = data.tags;
-        test.message = data.message;
         test.matchesTagPattern = function (pattern) {
             return containsTagPattern(test.tags, pattern);
         };
@@ -143,13 +142,12 @@ window.model = (function () {
 
     function Keyword(data) {
         var kw = createModelObject(data);
-        var flatTypes = ['RETURN', 'BREAK', 'CONTINUE'];
         kw.libname = data.libname;
         kw.fullName = (kw.libname ? kw.libname + '.' : '') + kw.name;
         kw.type = data.type;
         kw.template = 'keywordTemplate';
         kw.arguments = data.args;
-        kw.assign = data.assign + (data.assign ? ' =' : '');
+        kw.assign = data.assign + (data.assign ? ' =  ' : '');
         kw.tags = data.tags;
         kw.timeout = data.timeout;
         kw.populateKeywords = createIterablePopulator('Keyword');

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/htmldata/rebot/testdata.js

@@ -5,8 +5,9 @@ window.testdata = function () {
     var _statistics = null;
     var LEVELS = ['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR', 'FAIL', 'SKIP'];
     var STATUSES = ['FAIL', 'PASS', 'SKIP', 'NOT RUN'];
-    var KEYWORD_TYPES = ['KEYWORD', 'SETUP', 'TEARDOWN', 'FOR', 'ITERATION', 'IF', 'ELSE IF', 'ELSE', 'RETURN',
-                         'TRY', 'EXCEPT', 'FINALLY', 'WHILE', 'CONTINUE', 'BREAK', 'ERROR'];
+    var KEYWORD_TYPES = ['KEYWORD', 'SETUP', 'TEARDOWN', 'FOR', 'ITERATION', 'IF',
+                         'ELSE IF', 'ELSE', 'RETURN', 'VAR', 'TRY', 'EXCEPT', 'FINALLY',
+                         'WHILE', 'CONTINUE', 'BREAK', 'ERROR'];
 
     function addElement(elem) {
         if (!elem.id)
@@ -57,6 +58,7 @@ window.testdata = function () {
     }
 
     function createKeyword(parent, element, strings, index) {
+        var status = element[8];
         var kw = model.Keyword({
             parent: parent,
             type: KEYWORD_TYPES[element[0]],
@@ -72,7 +74,12 @@ window.testdata = function () {
                 this.doc = function () { return doc; };
                 return doc;
             },
-            status: parseStatus(element[8], strings),
+            status: parseStatus(status),
+            message: function () {
+                var msg = status.length == 4 ? strings.get(status[3]) : '';
+                this.message = function () { return msg; };
+                return msg;
+            },
             times: model.Times(times(element[8])),
             isChildrenLoaded: typeof(element[9]) !== 'number'
         });

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/htmldata/template.py

@@ -27,13 +27,13 @@ if sys.version_info < (3, 9) and not Path(__file__).exists():    # zipsafe
     except ImportError:
         raise ImportError(
             "'importlib_resources' backport module needs to be installed with "
-            "Python 3.8 and older when Robot Framework is distributed as a zip "
-            "package or '__file__' does not exist for other reasons."
+            "Python 3.8 when Robot Framework is distributed as a zip package "
+            "or '__file__' does not exist for other reasons."
         )
 else:
     try:
         from importlib.resources import files
-    except ImportError:    # Python 3.8 or older
+    except ImportError:    # Python 3.8
         BASE_DIR = Path(__file__).absolute().parent.parent.parent    # zipsafe
 
         def files(module):

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/libdocpkg/builder.py

@@ -71,14 +71,6 @@ class DocumentationBuilder:
     instead.
     """
 
-    def __init__(self, library_or_resource=None):
-        """`library_or_resource` is accepted for backwards compatibility reasons.
-
-        It is not used for anything internally and passing it to the builder is
-        considered deprecated starting from RF 6.0.1.
-        """
-        pass
-
     def build(self, source):
         # Source can contain arguments separated with `::` so we cannot convert
         # it to Path and instead need to make sure it's a string. It would be

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/libdocpkg/datatypes.py

@@ -47,12 +47,12 @@ class TypeDoc(Sortable):
         return self.name.lower()
 
     @classmethod
-    def for_type(cls, type_hint, converters):
-        if isinstance(type_hint, EnumType):
-            return cls.for_enum(type_hint)
-        if isinstance(type_hint, typeddict_types):
-            return cls.for_typed_dict(type_hint)
-        converter = TypeConverter.converter_for(type_hint, converters)
+    def for_type(cls, type_info, converters):
+        if isinstance(type_info.type, EnumType):
+            return cls.for_enum(type_info.type)
+        if isinstance(type_info.type, typeddict_types):
+            return cls.for_typed_dict(type_info.type)
+        converter = TypeConverter.converter_for(type_info, converters)
         if not converter:
             return None
         elif not converter.type:
@@ -83,15 +83,14 @@ class TypeDoc(Sortable):
         return cls(cls.TYPED_DICT, typed_dict.__name__, getdoc(typed_dict),
                    accepts=(str, 'Mapping'), items=items)
 
-    def to_dictionary(self, legacy=False):
+    def to_dictionary(self):
         data = {
             'type': self.type,
             'name': self.name,
             'doc': self.doc,
+            'usages': self.usages,
+            'accepts': self.accepts
         }
-        if not legacy:
-            data['usages'] = self.usages
-            data['accepts'] = self.accepts
         if self.members is not None:
             data['members'] = [m.to_dictionary() for m in self.members]
         if self.items is not None:

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/libdocpkg/htmlutils.py

@@ -14,10 +14,7 @@
 #  limitations under the License.
 
 import re
-try:
-    from urllib import quote
-except ImportError:
-    from urllib.parse import quote
+from urllib.parse import quote
 
 from robot.errors import DataError
 from robot.utils import html_escape, html_format, NormalizedDict
@@ -97,10 +94,10 @@ class DocToHtml:
                     'HTML': lambda doc: doc,
                     'REST': self._format_rest}[doc_format]
         except KeyError:
-            raise DataError("Invalid documentation format '%s'." % doc_format)
+            raise DataError(f"Invalid documentation format '{doc_format}'.")
 
     def _format_text(self, doc):
-        return '<p style="white-space: pre-wrap">%s</p>' % html_escape(doc)
+        return f'<p style="white-space: pre-wrap">{html_escape(doc)}</p>'
 
     def _format_rest(self, doc):
         try:
@@ -133,7 +130,7 @@ class HtmlToText:
         '&apos;': "'"
     }
 
-    def get_shortdoc_from_html(self, doc):
+    def get_short_doc_from_html(self, doc):
         match = re.search(r'<p.*?>(.*?)</?p>', doc, re.DOTALL)
         if match:
             doc = match.group(1)