robotframework 6.1.1__zip → 7.0__zip

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

@@ -16,7 +16,7 @@
 import re
 import time
 import warnings
-from datetime import timedelta
+from datetime import datetime, timedelta
 
 from .normalizing import normalize
 from .misc import plural_or_not
@@ -40,7 +40,7 @@ def _float_secs_to_secs_and_millis(secs):
     return (isecs, millis) if millis < 1000 else (isecs+1, 0)
 
 
-def timestr_to_secs(timestr, round_to=3, accept_plain_values=True):
+def timestr_to_secs(timestr, round_to=3):
     """Parses time strings like '1h 10s', '01:00:10' and '42' and returns seconds.
 
     Time can also be given as an integer or float or, starting from RF 6.0.1,
@@ -48,23 +48,16 @@ def timestr_to_secs(timestr, round_to=3, accept_plain_values=True):
 
     The result is rounded according to the `round_to` argument.
     Use `round_to=None` to disable rounding altogether.
-
-    `accept_plain_values` is considered deprecated and should not be used.
     """
     if is_string(timestr) or is_number(timestr):
-        if accept_plain_values:
-            converters = [_number_to_secs, _timer_to_secs, _time_string_to_secs]
-        else:
-            # TODO: Remove 'accept_plain_values' in 7.0
-            warnings.warn("'accept_plain_values' is deprecated and will be removed in RF 7.0.")
-            converters = [_timer_to_secs, _time_string_to_secs]
+        converters = [_number_to_secs, _timer_to_secs, _time_string_to_secs]
         for converter in converters:
             secs = converter(timestr)
             if secs is not None:
                 return secs if round_to is None else round(secs, round_to)
     if isinstance(timestr, timedelta):
         return timestr.total_seconds()
-    raise ValueError("Invalid time string '%s'." % timestr)
+    raise ValueError(f"Invalid time string '{timestr}'.")
 
 
 def _number_to_secs(number):
@@ -104,7 +97,7 @@ def _time_string_to_secs(timestr):
         try:
             if   c == 'n': nanos  = float(''.join(temp)); temp = []
             elif c == 'u': micros = float(''.join(temp)); temp = []
-            elif c == 'x': millis = float(''.join(temp)); temp = []
+            elif c == 'M': millis = float(''.join(temp)); temp = []
             elif c == 's': secs   = float(''.join(temp)); temp = []
             elif c == 'm': mins   = float(''.join(temp)); temp = []
             elif c == 'h': hours  = float(''.join(temp)); temp = []
@@ -122,7 +115,7 @@ def _normalize_timestr(timestr):
     timestr = normalize(timestr)
     for specifier, aliases in [('n', ['nanosecond', 'ns']),
                                ('u', ['microsecond', 'us', 'μs']),
-                               ('x', ['millisecond', 'millisec', 'millis',
+                               ('M', ['millisecond', 'millisec', 'millis',
                                       'msec', 'ms']),
                                ('s', ['second', 'sec']),
                                ('m', ['minute', 'min']),
@@ -135,7 +128,7 @@ def _normalize_timestr(timestr):
     return timestr
 
 
-def secs_to_timestr(secs, compact=False):
+def secs_to_timestr(secs: 'int|float|timedelta', compact=False) -> str:
     """Converts time in seconds to a string representation.
 
     Returned string is in format like
@@ -143,12 +136,14 @@ def secs_to_timestr(secs, compact=False):
 
     - Time parts having zero value are not included (e.g. '3 minutes 4 seconds'
       instead of '0 days 0 hours 3 minutes 4 seconds')
-    - Hour part has a maximun of 23 and minutes and seconds both have 59
+    - Hour part has a maximum of 23 and minutes and seconds both have 59
       (e.g. '1 minute 40 seconds' instead of '100 seconds')
 
     If compact has value 'True', short suffixes are used.
     (e.g. 1d 2h 3min 4s 5ms)
     """
+    if isinstance(secs, timedelta):
+        secs = secs.total_seconds()
     return _SecsToTimestrHelper(secs, compact).get_value()
 
 
@@ -157,13 +152,12 @@ class _SecsToTimestrHelper:
     def __init__(self, float_secs, compact):
         self._compact = compact
         self._ret = []
-        self._sign, millis, secs, mins, hours, days \
-                = self._secs_to_components(float_secs)
-        self._add_item(days, 'd', 'day')
-        self._add_item(hours, 'h', 'hour')
-        self._add_item(mins, 'min', 'minute')
-        self._add_item(secs, 's', 'second')
-        self._add_item(millis, 'ms', 'millisecond')
+        self._sign, ms, sec, min, hour, day = self._secs_to_components(float_secs)
+        self._add_item(day, 'd', 'day')
+        self._add_item(hour, 'h', 'hour')
+        self._add_item(min, 'min', 'minute')
+        self._add_item(sec, 's', 'second')
+        self._add_item(ms, 'ms', 'millisecond')
 
     def get_value(self):
         if len(self._ret) > 0:
@@ -195,17 +189,9 @@ class _SecsToTimestrHelper:
 
 def format_time(timetuple_or_epochsecs, daysep='', daytimesep=' ', timesep=':',
                 millissep=None):
-    """Returns a timestamp formatted from given time using separators.
-
-    Time can be given either as a timetuple or seconds after epoch.
-
-    Timetuple is (year, month, day, hour, min, sec[, millis]), where parts must
-    be integers and millis is required only when millissep is not None.
-    Notice that this is not 100% compatible with standard Python timetuples
-    which do not have millis.
-
-    Seconds after epoch can be either an integer or a float.
-    """
+    """Deprecated in Robot Framework 7.0. Will be removed in Robot Framework 8.0."""
+    warnings.warn("'robot.utils.format_time' is deprecated and will be "
+                  "removed in Robot Framework 8.0.")
     if is_number(timetuple_or_epochsecs):
         timetuple = _get_timetuple(timetuple_or_epochsecs)
     else:
@@ -239,14 +225,15 @@ def get_time(format='timestamp', time_=None):
     # 1) Return time in seconds since epoc
     if 'epoch' in format:
         return time_
-    timetuple = time.localtime(time_)
+    dt = datetime.fromtimestamp(time_)
     parts = []
-    for i, match in enumerate('year month day hour min sec'.split()):
-        if match in format:
-            parts.append('%.2d' % timetuple[i])
+    for part, name in [(dt.year, 'year'), (dt.month, 'month'), (dt.day, 'day'),
+                       (dt.hour, 'hour'), (dt.minute, 'min'), (dt.second, 'sec')]:
+        if name in format:
+            parts.append(f'{part:02}')
     # 2) Return time as timestamp
     if not parts:
-        return format_time(timetuple, daysep='-')
+        return dt.isoformat(' ', timespec='seconds')
     # Return requested parts of the time
     elif len(parts) == 1:
         return parts[0]
@@ -254,6 +241,50 @@ def get_time(format='timestamp', time_=None):
         return parts
 
 
+def parse_timestamp(timestamp: 'str|datetime') -> datetime:
+    """Parse timestamp in ISO 8601-like formats into a ``datetime``.
+
+    Months, days, hours, minutes and seconds must use two digits and
+    year must use four. Microseconds can use up to six digits. All time
+    parts can be omitted.
+
+    Separators '-', '_', ' ', 'T', ':' and '.' between date and time components.
+    Separators can also be omitted altogether.
+
+    Examples::
+
+        2023-09-08T14:34:42.123456
+        2023-09-08 14:34:42.123
+        20230908 143442
+        2023_09_08
+
+    This is similar to ``datetime.fromisoformat``, but a little less strict.
+    The standard function is recommended if the input format is known to be
+    accepted.
+
+    If the input is a ``datetime``, it is returned as-is.
+
+    New in Robot Framework 7.0.
+    """
+    if isinstance(timestamp, datetime):
+        return timestamp
+    try:
+        return datetime.fromisoformat(timestamp)
+    except ValueError:
+        pass
+    orig = timestamp
+    for sep in ('-', '_', ' ', 'T', ':', '.'):
+        if sep in timestamp:
+            timestamp = timestamp.replace(sep, '')
+    timestamp = timestamp.ljust(20, '0')
+    try:
+        return datetime(int(timestamp[0:4]), int(timestamp[4:6]), int(timestamp[6:8]),
+                        int(timestamp[8:10]), int(timestamp[10:12]), int(timestamp[12:14]),
+                        int(timestamp[14:20]))
+    except ValueError:
+        raise ValueError(f"Invalid timestamp '{orig}'.")
+
+
 def parse_time(timestr):
     """Parses the time string and returns its value as seconds since epoch.
 
@@ -290,7 +321,7 @@ def _parse_time_epoch(timestr):
 
 def _parse_time_timestamp(timestr):
     try:
-        return timestamp_to_secs(timestr, (' ', ':', '-', '.'))
+        return parse_timestamp(timestr).timestamp()
     except ValueError:
         return None
 
@@ -333,10 +364,23 @@ def _get_dst_difference(time1, time2):
 
 
 def get_timestamp(daysep='', daytimesep=' ', timesep=':', millissep='.'):
-    return TIMESTAMP_CACHE.get_timestamp(daysep, daytimesep, timesep, millissep)
+    """Deprecated in Robot Framework 7.0. Will be removed in Robot Framework 8.0."""
+    warnings.warn("'robot.utils.get_timestamp' is deprecated and will be "
+                  "removed in Robot Framework 8.0.")
+    dt = datetime.now()
+    parts = [str(dt.year), daysep, f'{dt.month:02}', daysep, f'{dt.day:02}', daytimesep,
+             f'{dt.hour:02}', timesep, f'{dt.minute:02}', timesep, f'{dt.second:02}']
+    if millissep:
+        # Make sure milliseconds is < 1000. Good enough for a deprecated function.
+        millis = min(round(dt.microsecond, -3) // 1000, 999)
+        parts.extend([millissep, f'{millis:03}'])
+    return ''.join(parts)
 
 
 def timestamp_to_secs(timestamp, seps=None):
+    """Deprecated in Robot Framework 7.0. Will be removed in Robot Framework 8.0."""
+    warnings.warn("'robot.utils.timestamp_to_secs' is deprecated and will be "
+                  "removed in Robot Framework 8.0. User 'parse_timestamp' instead.")
     try:
         secs = _timestamp_to_millis(timestamp, seps) / 1000.0
     except (ValueError, OverflowError):
@@ -346,6 +390,9 @@ def timestamp_to_secs(timestamp, seps=None):
 
 
 def secs_to_timestamp(secs, seps=None, millis=False):
+    """Deprecated in Robot Framework 7.0. Will be removed in Robot Framework 8.0."""
+    warnings.warn("'robot.utils.secs_to_timestamp' is deprecated and will be "
+                  "removed in Robot Framework 8.0.")
     if not seps:
         seps = ('', ' ', ':', '.' if millis else None)
     ttuple = time.localtime(secs)[:6]
@@ -356,43 +403,67 @@ def secs_to_timestamp(secs, seps=None, millis=False):
 
 
 def get_elapsed_time(start_time, end_time):
-    """Returns the time between given timestamps in milliseconds."""
+    """Deprecated in Robot Framework 7.0. Will be removed in Robot Framework 8.0."""
+    warnings.warn("'robot.utils.get_elapsed_time' is deprecated and will be "
+                  "removed in Robot Framework 8.0.")
     if start_time == end_time or not (start_time and end_time):
         return 0
     if start_time[:-4] == end_time[:-4]:
         return int(end_time[-3:]) - int(start_time[-3:])
     start_millis = _timestamp_to_millis(start_time)
     end_millis = _timestamp_to_millis(end_time)
-    # start/end_millis can be long but we want to return int when possible
-    return int(end_millis - start_millis)
+    return end_millis - start_millis
+
 
+def elapsed_time_to_string(elapsed: 'int|float|timedelta',
+                           include_millis: bool = True,
+                           seconds: bool = False):
+    """Converts elapsed time to format 'hh:mm:ss.mil'.
 
-def elapsed_time_to_string(elapsed, include_millis=True):
-    """Converts elapsed time in milliseconds to format 'hh:mm:ss.mil'.
+    Elapsed time as an integer or as a float is currently considered to be
+    milliseconds, but that will be changed to seconds in Robot Framework 8.0.
+    Use ``seconds=True`` to change the behavior already now and to avoid the
+    deprecation warning. An alternative is giving the elapsed time as
+    a ``timedelta``.
 
     If `include_millis` is True, '.mil' part is omitted.
+
+    Support for giving the elapsed time as a ``timedelta`` and the ``seconds``
+    argument are new in Robot Framework 7.0.
     """
+    # TODO: Change the default input to seconds in RF 8.0.
+    if isinstance(elapsed, timedelta):
+        elapsed = elapsed.total_seconds()
+    elif not seconds:
+        elapsed /= 1000
+        warnings.warn("'robot.utils.elapsed_time_to_string' currently accepts "
+                      "input as milliseconds, but that will be changed to seconds "
+                      "in Robot Framework 8.0. Use 'seconds=True' to change the "
+                      "behavior already now and to avoid this warning. Alternatively "
+                      "pass the elapsed time as a 'timedelta'.")
     prefix = ''
     if elapsed < 0:
         prefix = '-'
         elapsed = abs(elapsed)
     if include_millis:
-        return prefix + _elapsed_time_to_string(elapsed)
+        return prefix + _elapsed_time_to_string_with_millis(elapsed)
     return prefix + _elapsed_time_to_string_without_millis(elapsed)
 
 
-def _elapsed_time_to_string(elapsed):
-    secs, millis = divmod(round(elapsed), 1000)
+def _elapsed_time_to_string_with_millis(elapsed):
+    elapsed = round(elapsed, 3)
+    secs = int(elapsed)
+    millis = round((elapsed - secs) * 1000)
     mins, secs = divmod(secs, 60)
     hours, mins = divmod(mins, 60)
-    return '%02d:%02d:%02d.%03d' % (hours, mins, secs, millis)
+    return f'{hours:02}:{mins:02}:{secs:02}.{millis:03}'
 
 
 def _elapsed_time_to_string_without_millis(elapsed):
-    secs = round(elapsed, ndigits=-3) // 1000
+    secs = round(elapsed)
     mins, secs = divmod(secs, 60)
     hours, mins = divmod(mins, 60)
-    return '%02d:%02d:%02d' % (hours, mins, secs)
+    return f'{hours:02}:{mins:02}:{secs:02}'
 
 
 def _timestamp_to_millis(timestamp, seps=None):
@@ -420,42 +491,3 @@ def _split_timestamp(timestamp):
     secs = int(timestamp[15:17])
     millis = int(timestamp[18:21])
     return years, mons, days, hours, mins, secs, millis
-
-
-class TimestampCache:
-
-    def __init__(self):
-        self._previous_secs = None
-        self._previous_separators = None
-        self._previous_timestamp = None
-
-    def get_timestamp(self, daysep='', daytimesep=' ', timesep=':', millissep='.'):
-        epoch = self._get_epoch()
-        secs, millis = _float_secs_to_secs_and_millis(epoch)
-        if self._use_cache(secs, daysep, daytimesep, timesep):
-            return self._cached_timestamp(millis, millissep)
-        timestamp = format_time(epoch, daysep, daytimesep, timesep, millissep)
-        self._cache_timestamp(secs, timestamp, daysep, daytimesep, timesep, millissep)
-        return timestamp
-
-    # Seam for mocking
-    def _get_epoch(self):
-        return time.time()
-
-    def _use_cache(self, secs, *separators):
-        return self._previous_timestamp \
-            and self._previous_secs == secs \
-            and self._previous_separators == separators
-
-    def _cached_timestamp(self, millis, millissep):
-        if millissep:
-            return self._previous_timestamp + millissep + format(millis, '03d')
-        return self._previous_timestamp
-
-    def _cache_timestamp(self, secs, timestamp, daysep, daytimesep, timesep, millissep):
-        self._previous_secs = secs
-        self._previous_separators = (daysep, daytimesep, timesep)
-        self._previous_timestamp = timestamp[:-4] if millissep else timestamp
-
-
-TIMESTAMP_CACHE = TimestampCache()

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

@@ -17,30 +17,23 @@ from collections.abc import Iterable, Mapping
 from collections import UserString
 from io import IOBase
 from os import PathLike
-from typing import Any, TypeVar
+from typing import Literal, Union, TypedDict, TypeVar
 try:
     from types import UnionType
 except ImportError:    # Python < 3.10
     UnionType = ()
-from typing import Union
-try:
-    from typing import TypedDict
-except ImportError:    # Python < 3.8
-    typeddict_types = ()
-else:
-    typeddict_types = (type(TypedDict('Dummy', {})),)
+
 try:
     from typing_extensions import TypedDict as ExtTypedDict
 except ImportError:
-    pass
-else:
-    typeddict_types += (type(ExtTypedDict('Dummy', {})),)
-
-from .platform import PY_VERSION
+    ExtTypedDict = None
 
 
 TRUE_STRINGS = {'TRUE', 'YES', 'ON', '1'}
 FALSE_STRINGS = {'FALSE', 'NO', 'OFF', '0', 'NONE', ''}
+typeddict_types = (type(TypedDict('Dummy', {})),)
+if ExtTypedDict:
+    typeddict_types += (type(ExtTypedDict('Dummy', {})),)
 
 
 def is_integer(item):
@@ -73,10 +66,9 @@ def is_dict_like(item):
     return isinstance(item, Mapping)
 
 
-def is_union(item, allow_tuple=False):
+def is_union(item):
     return (isinstance(item, UnionType)
-            or getattr(item, '__origin__', None) is Union
-            or (allow_tuple and isinstance(item, tuple)))
+            or getattr(item, '__origin__', None) is Union)
 
 
 def type_name(item, capitalize=False):
@@ -87,8 +79,9 @@ def type_name(item, capitalize=False):
     if getattr(item, '__origin__', None):
         item = item.__origin__
     if hasattr(item, '_name') and item._name:
-        # Union, Any, etc. from typing have real name in _name and __name__ is just
-        # generic `SpecialForm`. Also, pandas.Series has _name but it's None.
+        # Prior to Python 3.10 Union, Any, etc. from typing didn't have `__name__`.
+        # but instead had `_name`. Python 3.10 has both and newer only `__name__`.
+        # Also, pandas.Series has `_name` but it's None.
         name = item._name
     elif is_union(item):
         name = 'Union'
@@ -99,12 +92,6 @@ def type_name(item, capitalize=False):
         named_types = {str: 'string', bool: 'boolean', int: 'integer',
                        type(None): 'None', dict: 'dictionary'}
         name = named_types.get(typ, typ.__name__.strip('_'))
-        # Generics from typing. With newer versions we get "real" type via __origin__.
-        if PY_VERSION < (3, 7):
-            if name in ('List', 'Set', 'Tuple'):
-                name = name.lower()
-            elif name == 'Dict':
-                name = 'dictionary'
     return name.capitalize() if capitalize and name.islower() else name
 
 
@@ -118,10 +105,13 @@ def type_repr(typ, nested=True):
         return 'None'
     if typ is Ellipsis:
         return '...'
-    if typ is Any:  # Needed with Python 3.6, with newer `Any._name` exists.
-        return 'Any'
     if is_union(typ):
         return ' | '.join(type_repr(a) for a in typ.__args__) if nested else 'Union'
+    if getattr(typ, '__origin__', None) is Literal:
+        if nested:
+            args = ', '.join(repr(a) for a in typ.__args__)
+            return f'Literal[{args}]'
+        return 'Literal'
     name = _get_type_name(typ)
     if nested and has_args(typ):
         args = ', '.join(type_repr(a) for a in typ.__args__)
@@ -130,6 +120,7 @@ def type_repr(typ, nested=True):
 
 
 def _get_type_name(typ):
+    # See comment in `type_name` for explanation about `_name`.
     for attr in '__name__', '_name':
         name = getattr(typ, attr, None)
         if name:
@@ -140,16 +131,15 @@ def _get_type_name(typ):
 def has_args(type):
     """Helper to check has type valid ``__args__``.
 
-    ``__args__`` contains TypeVars when accessed directly from ``typing.List`` and
-    other such types with Python 3.7-3.8. With Python 3.6 ``__args__`` is None
-    in that case and with Python 3.9+ it doesn't exist at all. When using like
-    ``List[int].__args__``, everything works the same way regardless the version.
+   ``__args__`` contains TypeVars when accessed directly from ``typing.List`` and
+   other such types with Python 3.8. Python 3.9+ don't have ``__args__`` at all.
+   Parameterize usages like ``List[int].__args__`` always work the same way.
 
     This helper can be removed in favor of using ``hasattr(type, '__args__')``
     when we support only Python 3.9 and newer.
     """
     args = getattr(type, '__args__', None)
-    return args and not all(isinstance(a, TypeVar) for a in args)
+    return bool(args and not all(isinstance(a, TypeVar) for a in args))
 
 
 def is_truthy(item):

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

@@ -13,7 +13,6 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import sys
 from typing import Callable, Generic, overload, TypeVar, Type, Union
 
 
@@ -93,7 +92,3 @@ class SetterAwareType(type):
                     slots.append(item.attr_name)
             dct['__slots__'] = slots
         return type.__new__(cls, name, bases, dct)
-
-    if sys.version_info < (3, 7):
-        def __getitem__(self, item):
-            return self

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

@@ -36,13 +36,14 @@ def cut_long_message(msg):
     if MAX_ERROR_LINES is None:
         return msg
     lines = msg.splitlines()
-    lengths = _count_line_lengths(lines)
+    lengths = [_get_virtual_line_length(line) for line in lines]
     if sum(lengths) <= MAX_ERROR_LINES:
         return msg
     start = _prune_excess_lines(lines, lengths)
     end = _prune_excess_lines(lines, lengths, from_end=True)
     return '\n'.join(start + [_ERROR_CUT_EXPLN] + end)
 
+
 def _prune_excess_lines(lines, lengths, from_end=False):
     if from_end:
         lines.reverse()
@@ -60,6 +61,7 @@ def _prune_excess_lines(lines, lengths, from_end=False):
         ret.reverse()
     return ret
 
+
 def _cut_long_line(line, used, from_end):
     available_lines = MAX_ERROR_LINES // 2 - used
     available_chars = available_lines * _MAX_ERROR_LINE_LENGTH - 3
@@ -70,10 +72,8 @@ def _cut_long_line(line, used, from_end):
             line = '...' + line[-available_chars:]
     return line
 
-def _count_line_lengths(lines):
-    return [ _count_virtual_line_length(line) for line in lines ]
 
-def _count_virtual_line_length(line):
+def _get_virtual_line_length(line):
     if not line:
         return 1
     lines, remainder = divmod(len(line), _MAX_ERROR_LINE_LENGTH)
@@ -88,6 +88,7 @@ def format_assign_message(variable, value, items=None, cut_long=True):
     decorated_items = ''.join(f'[{item}]' for item in items) if items else ''
     return f'{variable}{decorated_items} = {value}'
 
+
 def _dict_to_str(d):
     if not d:
         return '{ }'
@@ -114,10 +115,12 @@ def pad_console_length(text, width):
         text = _lose_width(text, diff+3) + '...'
     return _pad_width(text, width)
 
+
 def _pad_width(text, width):
     more = width - get_console_length(text)
     return text + ' ' * more
 
+
 def _lose_width(text, diff):
     lost = 0
     while lost < diff:

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

@@ -36,8 +36,8 @@ def _safe_str(item):
         return _unrepresentable_object(item)
 
 
-def prepr(item, width=80):
-    return safe_str(PrettyRepr(width=width).pformat(item))
+def prepr(item, width=80, sort_dicts=False):
+    return safe_str(PrettyRepr(width=width, sort_dicts=sort_dicts).pformat(item))
 
 
 class PrettyRepr(PrettyPrinter):

{robotframework-6.1.1 → robotframework-7.0}/src/robot/variables/__init__.py

@@ -28,6 +28,6 @@ from .search import (search_variable, contains_variable,
                      is_scalar_variable, is_scalar_assign,
                      is_dict_variable, is_dict_assign,
                      is_list_variable, is_list_assign,
-                     VariableIterator)
-from .tablesetter import VariableTableValue, DictVariableTableValue
+                     VariableMatches)
+from .tablesetter import VariableResolver, DictVariableResolver
 from .variables import Variables