robotframework 6.1.1__zip → 7.0__zip

{robotframework-6.1.1 → robotframework-7.0}/src/robot/utils/escaping.py

@@ -15,15 +15,13 @@
 
 import re
 
-from .robottypes import is_string
-
 
 _CONTROL_WORDS = frozenset(('ELSE', 'ELSE IF', 'AND', 'WITH NAME', 'AS'))
 _SEQUENCES_TO_BE_ESCAPED = ('\\', '${', '@{', '%{', '&{', '*{', '=')
 
 
 def escape(item):
-    if not is_string(item):
+    if not isinstance(item, str):
         return item
     if item in _CONTROL_WORDS:
         return '\\' + item
@@ -75,7 +73,7 @@ class Unescaper:
         return chr(ordinal)
 
     def unescape(self, item):
-        if not (is_string(item) and '\\' in item):
+        if not isinstance(item, str) or '\\' not in item:
             return item
         return self._escape_sequences.sub(self._handle_escapes, item)
 
@@ -93,28 +91,30 @@ class Unescaper:
 unescape = Unescaper().unescape
 
 
-def split_from_equals(string):
-    from robot.variables import VariableIterator
-    if not is_string(string) or '=' not in string:
-        return string, None
-    variables = VariableIterator(string, ignore_errors=True)
-    if not variables and '\\' not in string:
-        return tuple(string.split('=', 1))
+def split_from_equals(value):
+    from robot.variables import VariableMatches
+    if not isinstance(value, str) or '=' not in value:
+        return value, None
+    matches = VariableMatches(value, ignore_errors=True)
+    if not matches and '\\' not in value:
+        return tuple(value.split('=', 1))
     try:
-        index = _find_split_index(string, variables)
+        index = _find_split_index(value, matches)
     except ValueError:
-        return string, None
-    return string[:index], string[index+1:]
+        return value, None
+    return value[:index], value[index + 1:]
 
 
-def _find_split_index(string, variables):
+def _find_split_index(string, matches):
+    remaining = string
     relative_index = 0
-    for before, match, string in variables:
+    for match in matches:
         try:
-            return _find_split_index_from_part(before) + relative_index
+            return _find_split_index_from_part(match.before) + relative_index
         except ValueError:
-            relative_index += len(before) + len(match)
-    return _find_split_index_from_part(string) + relative_index
+            remaining = match.after
+            relative_index += match.end
+    return _find_split_index_from_part(remaining) + relative_index
 
 
 def _find_split_index_from_part(string):

{robotframework-6.1.1 → robotframework-7.0}/src/robot/utils/importer.py

@@ -189,7 +189,7 @@ class Importer:
             raise DataError(err.args[0])
         try:
             return imported(*positional, **dict(named))
-        except:
+        except Exception:
             raise DataError('Creating instance failed: %s\n%s' % get_error_details())
 
     def _get_arg_spec(self, imported):
@@ -215,7 +215,7 @@ class _Importer:
         importlib.invalidate_caches()
         try:
             return __import__(name, fromlist=fromlist)
-        except:
+        except Exception:
             message, traceback = get_error_details(full_traceback=False)
             path = '\n'.join(f'  {p}' for p in sys.path)
             raise DataError(f'{message}\n{traceback}\nPYTHONPATH:\n{path}')

{robotframework-6.1.1 → robotframework-7.0}/src/robot/utils/markupwriters.py

@@ -20,7 +20,7 @@ from .robotio import file_writer
 
 class _MarkupWriter:
 
-    def __init__(self, output, write_empty=True, usage=None):
+    def __init__(self, output, write_empty=True, usage=None, preamble=True):
         """
         :param output: Either an opened, file like object, or a path to the
             desired output file. In the latter case, the file is created
@@ -31,22 +31,24 @@ class _MarkupWriter:
             output = file_writer(output, usage=usage)
         self.output = output
         self._write_empty = write_empty
-        self._preamble()
+        if preamble:
+            self._preamble()
 
     def _preamble(self):
         pass
 
-    def start(self, name, attrs=None, newline=True):
-        attrs = self._format_attrs(attrs)
+    def start(self, name, attrs=None, newline=True, write_empty=None):
+        attrs = self._format_attrs(attrs, write_empty)
         self._start(name, attrs, newline)
 
     def _start(self, name, attrs, newline):
         self._write(f'<{name} {attrs}>' if attrs else f'<{name}>', newline)
 
-    def _format_attrs(self, attrs):
+    def _format_attrs(self, attrs, write_empty):
         if not attrs:
             return ''
-        write_empty = self._write_empty
+        if write_empty is None:
+            write_empty = self._write_empty
         return ' '.join(f"{name}=\"{attribute_escape(value or '')}\""
                         for name, value in self._order_attrs(attrs)
                         if write_empty or value)
@@ -64,9 +66,12 @@ class _MarkupWriter:
     def end(self, name, newline=True):
         self._write(f'</{name}>', newline)
 
-    def element(self, name, content=None, attrs=None, escape=True, newline=True):
-        attrs = self._format_attrs(attrs)
-        if self._write_empty or content or attrs:
+    def element(self, name, content=None, attrs=None, escape=True, newline=True,
+                write_empty=None):
+        attrs = self._format_attrs(attrs, write_empty)
+        if write_empty is None:
+            write_empty = self._write_empty
+        if write_empty or content or attrs:
             self._start(name, attrs, newline=False)
             self.content(content, escape)
             self.end(name, newline)
@@ -98,15 +103,18 @@ class XmlWriter(_MarkupWriter):
     def _escape(self, text):
         return xml_escape(text)
 
-    def element(self, name, content=None, attrs=None, escape=True, newline=True):
+    def element(self, name, content=None, attrs=None, escape=True, newline=True,
+                write_empty=None):
         if content:
-            super().element(name, content, attrs, escape, newline)
+            super().element(name, content, attrs, escape, newline, write_empty)
         else:
-            self._self_closing_element(name, attrs, newline)
+            self._self_closing_element(name, attrs, newline, write_empty)
 
-    def _self_closing_element(self, name, attrs, newline):
-        attrs = self._format_attrs(attrs)
-        if self._write_empty or attrs:
+    def _self_closing_element(self, name, attrs, newline, write_empty):
+        attrs = self._format_attrs(attrs, write_empty)
+        if write_empty is None:
+            write_empty = self._write_empty
+        if write_empty or attrs:
             self._write(f'<{name} {attrs}/>' if attrs else f'<{name}/>', newline)
 
 

{robotframework-6.1.1 → robotframework-7.0}/src/robot/utils/misc.py

@@ -15,7 +15,6 @@
 
 import re
 
-from .robottypes import is_integer
 from .unic import safe_str
 
 
@@ -71,7 +70,7 @@ def _is_camel_case_boundary(prev, char, next):
 
 
 def plural_or_not(item):
-    count = item if is_integer(item) else len(item)
+    count = item if isinstance(item, int) else len(item)
     return '' if count in (1, -1) else 's'
 
 

{robotframework-6.1.1 → robotframework-7.0}/src/robot/utils/normalizing.py

@@ -14,47 +14,32 @@
 #  limitations under the License.
 
 import re
-from collections.abc import Iterable, Iterator, Mapping, Sequence
-from typing import Any, MutableMapping, overload, TypeVar
+from collections.abc import Iterator, Mapping, Sequence
+from typing import Any, MutableMapping, TypeVar
 
 
 V = TypeVar('V')
 Self = TypeVar('Self', bound='NormalizedDict')
 
 
-@overload
 def normalize(string: str, ignore: 'Sequence[str]' = (), caseless: bool = True,
               spaceless: bool = True) -> str:
-    ...
-
-
-@overload
-def normalize(string: bytes, ignore: 'Sequence[bytes]' = (), caseless: bool = True,
-              spaceless: bool = True) -> bytes:
-    ...
-
-
-# TODO: Remove bytes support in RF 7.0. There shouldn't be needs for that with Python 3.
-def normalize(string, ignore=(), caseless=True, spaceless=True):
     """Normalize the ``string`` according to the given spec.
 
-    By default, string is turned to lower case and all whitespace is removed.
-    Additional characters can be removed by giving them in ``ignore`` list.
+    By default, string is turned to lower case (actually case-folded) and all
+    whitespace is removed. Additional characters can be removed by giving them
+    in ``ignore`` list.
     """
-    empty = '' if isinstance(string, str) else b''
-    if isinstance(ignore, bytes):
-        # Iterating bytes in Python3 yields integers.
-        ignore = [bytes([i]) for i in ignore]
     if spaceless:
-        string = empty.join(string.split())
+        string = ''.join(string.split())
     if caseless:
-        string = string.lower()
-        ignore = [i.lower() for i in ignore]
+        string = string.casefold()
+        ignore = [i.casefold() for i in ignore]
     # both if statements below enhance performance a little
     if ignore:
         for ign in ignore:
             if ign in string:
-                string = string.replace(ign, empty)
+                string = string.replace(ign, '')
     return string
 
 

robotframework-7.0/src/robot/utils/notset.py

@@ -0,0 +1,33 @@
+#  Copyright 2008-2015 Nokia Networks
+#  Copyright 2016-     Robot Framework Foundation
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+class NotSet:
+    """Represents value that is not set.
+
+    Can be used instead of the standard ``None`` in cases where ``None``
+    itself is a valid value.
+
+    Use the constant ``robot.utils.NOT_SET`` instead of creating new instances
+    of the class.
+
+    New in Robot Framework 7.0.
+    """
+
+    def __repr__(self):
+        return ''
+
+
+NOT_SET = NotSet()
+

{robotframework-6.1.1 → robotframework-7.0}/src/robot/utils/platform.py

@@ -23,11 +23,6 @@ UNIXY = os.sep == '/'
 WINDOWS = not UNIXY
 RERAISED_EXCEPTIONS = (KeyboardInterrupt, SystemExit, MemoryError)
 
-# Part of the deprecated Python 2/3 compatibility layer. For more details see
-# the comment in `utils/__init__.py`. This constant was added to support
-# SSHLibrary: https://github.com/robotframework/SSHLibrary/issues/401
-PY2 = False
-
 
 def isatty(stream):
     # first check if buffer was detached
@@ -39,3 +34,18 @@ def isatty(stream):
         return stream.isatty()
     except ValueError:  # Occurs if file is closed.
         return False
+
+
+def __getattr__(name):
+    # Part of the deprecated Python 2/3 compatibility layer. For more details see
+    # the comment in `utils/__init__.py`. The 'PY2' constant exists here to support
+    # SSHLibrary: https://github.com/robotframework/SSHLibrary/issues/401
+
+    import warnings
+
+    if name == 'PY2':
+        warnings.warn("'robot.utils.platform.PY2' is deprecated and will be removed "
+                      "in Robot Framework 9.0.", DeprecationWarning)
+        return False
+
+    raise AttributeError(f"'robot.utils.platform' has no attribute '{name}'.")

{robotframework-6.1.1 → robotframework-7.0}/src/robot/utils/robotio.py

@@ -15,6 +15,7 @@
 
 import io
 import os.path
+from pathlib import Path
 
 from robot.errors import DataError
 
@@ -47,14 +48,13 @@ def binary_file_writer(path=None):
     return f
 
 
-def create_destination_directory(path, usage=None):
-    if is_pathlike(path):
-        path = str(path)
-    directory = os.path.dirname(path)
-    if directory and not os.path.exists(directory):
+def create_destination_directory(path: 'Path|str', usage=None):
+    if not is_pathlike(path):
+        path = Path(path)
+    if not path.parent.exists():
         try:
-            os.makedirs(directory, exist_ok=True)
+            os.makedirs(path.parent, exist_ok=True)
         except EnvironmentError:
-            usage = '%s directory' % usage if usage else 'directory'
-            raise DataError("Creating %s '%s' failed: %s"
-                            % (usage, directory, get_error_message()))
+            usage = f'{usage} directory' if usage else 'directory'
+            raise DataError(f"Creating {usage} '{path.parent}' failed: "
+                            f"{get_error_message()}")

{robotframework-6.1.1 → robotframework-7.0}/src/robot/utils/robotpath.py

@@ -44,6 +44,7 @@ def normpath(path, case_normalize=False):
        That includes Windows and also OSX in default configuration.
     4. Turn ``c:`` into ``c:\\`` on Windows instead of keeping it as ``c:``.
     """
+    # FIXME: Support pathlib.Path
     if not is_string(path):
         path = system_decode(path)
     path = safe_str(path)  # Handles NFC normalization on OSX