robotframework 6.1rc1__zip → 7.0__zip

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/libraries/DateTime.py

@@ -96,10 +96,10 @@ Examples:
 == Python datetime ==
 
 Python's standard
-[http://docs.python.org/library/datetime.html#datetime-objects|datetime]
-objects can be used both in input and output. In input they are recognized
-automatically, and in output it is possible to get them by giving ``datetime``
-value to ``result_format`` argument.
+[https://docs.python.org/library/datetime.html#datetime.datetime|datetime]
+objects can be used both in input and output. In input, they are recognized
+automatically, and in output it is possible to get them by using the ``datetime``
+value with the ``result_format`` argument.
 
 One nice benefit with datetime objects is that they have different time
 components available as attributes that can be easily accessed using the
@@ -115,6 +115,16 @@ Examples:
 | Should Be Equal As Integers | ${datetime.second}      | 42     |
 | Should Be Equal As Integers | ${datetime.microsecond} | 123000 |
 
+== Python date ==
+
+Python's standard [https://docs.python.org/library/datetime.html#datetime.date|date]
+objects are automatically recognized in input starting from Robot Framework 7.0.
+They are not supported in output, but ``datetime`` objects can be converted
+to ``date`` objects if needed:
+
+| ${datetime} = | Convert Date | 2023-12-18 11:10:42 | datetime |
+| Log | ${datetime.date()} | # The time part is ignored. |
+
 == Epoch time ==
 
 Epoch time is the time in seconds since the
@@ -283,7 +293,7 @@ are available as functions that can be easily imported:
 |     seconds = convert_time(timeout)
 |     # ...
 
-Additionally helper classes ``Date`` and ``Time`` can be used directly:
+Additionally, helper classes ``Date`` and ``Time`` can be used directly:
 
 | from robot.libraries.DateTime import Date, Time
 |
@@ -293,12 +303,13 @@ Additionally helper classes ``Date`` and ``Time`` can be used directly:
 |     # ...
 """
 
-from datetime import datetime, timedelta
+import datetime
+import sys
 import time
 
 from robot.version import get_version
-from robot.utils import (elapsed_time_to_string, is_falsy, is_number, is_string,
-                         secs_to_timestr, timestr_to_secs, type_name)
+from robot.utils import (elapsed_time_to_string, secs_to_timestr, timestr_to_secs,
+                         type_name)
 
 __version__ = get_version()
 __all__ = ['convert_time', 'convert_date', 'subtract_date_from_date',
@@ -306,8 +317,8 @@ __all__ = ['convert_time', 'convert_date', 'subtract_date_from_date',
            'add_time_to_time', 'add_time_to_date', 'get_current_date']
 
 
-def get_current_date(time_zone='local', increment=0,
-                     result_format='timestamp', exclude_millis=False):
+def get_current_date(time_zone='local', increment=0, result_format='timestamp',
+                     exclude_millis=False):
     """Returns current local or UTC time with an optional increment.
 
     Arguments:
@@ -333,20 +344,19 @@ def get_current_date(time_zone='local', increment=0,
     | Should Be Equal | ${date.year}     | ${2014}                 |
     | Should Be Equal | ${date.month}    | ${6}                    |
     """
-    upper = time_zone.upper()
-    if upper == 'LOCAL':
-        dt = datetime.now()
-    # Epoch time is same regardless the timezone. We convert `dt` to epoch time
-    # using `time.mktime()` afterwards, and it expects time in local time.
-    # For details: https://github.com/robotframework/robotframework/issues/3306
-    elif upper == 'UTC' and result_format.upper() == 'EPOCH':
-        dt = datetime.now()
-    elif upper == 'UTC':
-        dt = datetime.utcnow()
+    if time_zone.upper() == 'LOCAL' or result_format.upper() == 'EPOCH':
+        dt = datetime.datetime.now()
+    elif time_zone.upper() == 'UTC':
+        if sys.version_info >= (3, 12):
+            # `utcnow()` was deprecated in Python 3.12. We only support "naive"
+            # datetime objects and thus need to remove timezone information here.
+            dt = datetime.datetime.now(datetime.UTC).replace(tzinfo=None)
+        else:
+            dt = datetime.datetime.utcnow()
     else:
-        raise ValueError("Unsupported timezone '%s'." % time_zone)
+        raise ValueError(f"Unsupported timezone '{time_zone}'.")
     date = Date(dt) + Time(increment)
-    return date.convert(result_format, millis=is_falsy(exclude_millis))
+    return date.convert(result_format, millis=not exclude_millis)
 
 
 def convert_date(date, result_format='timestamp', exclude_millis=False,
@@ -368,8 +378,7 @@ def convert_date(date, result_format='timestamp', exclude_millis=False,
     | ${date} =       | Convert Date | 5.28.2014 12:05         | exclude_millis=yes | date_format=%m.%d.%Y %H:%M |
     | Should Be Equal | ${date}      | 2014-05-28 12:05:00     |
     """
-    return Date(date, date_format).convert(result_format,
-                                           millis=is_falsy(exclude_millis))
+    return Date(date, date_format).convert(result_format, millis=not exclude_millis)
 
 
 def convert_time(time, result_format='number', exclude_millis=False):
@@ -389,7 +398,7 @@ def convert_time(time, result_format='number', exclude_millis=False):
     | ${time} =       | Convert Time  | ${3661.5} | timer | exclude_milles=yes |
     | Should Be Equal | ${time}       | 01:01:02          |
     """
-    return Time(time).convert(result_format, millis=is_falsy(exclude_millis))
+    return Time(time).convert(result_format, millis=not exclude_millis)
 
 
 def subtract_date_from_date(date1, date2, result_format='number',
@@ -415,7 +424,7 @@ def subtract_date_from_date(date1, date2, result_format='number',
     | Should Be Equal | ${time}                 | 1 day 42 seconds        |
     """
     time = Date(date1, date1_format) - Date(date2, date2_format)
-    return time.convert(result_format, millis=is_falsy(exclude_millis))
+    return time.convert(result_format, millis=not exclude_millis)
 
 
 def add_time_to_date(date, time, result_format='timestamp',
@@ -439,7 +448,7 @@ def add_time_to_date(date, time, result_format='timestamp',
     | Should Be Equal | ${date}          | 2014-05-28 13:07:06.115 |
     """
     date = Date(date, date_format) + Time(time)
-    return date.convert(result_format, millis=is_falsy(exclude_millis))
+    return date.convert(result_format, millis=not exclude_millis)
 
 
 def subtract_time_from_date(date, time, result_format='timestamp',
@@ -463,7 +472,7 @@ def subtract_time_from_date(date, time, result_format='timestamp',
     | Should Be Equal | ${date}                 | 2014-05-28 12:05:03.111 |
     """
     date = Date(date, date_format) - Time(time)
-    return date.convert(result_format, millis=is_falsy(exclude_millis))
+    return date.convert(result_format, millis=not exclude_millis)
 
 
 def add_time_to_time(time1, time2, result_format='number',
@@ -484,7 +493,7 @@ def add_time_to_time(time1, time2, result_format='number',
     | Should Be Equal | ${time}          | 04:07:03          |
     """
     time = Time(time1) + Time(time2)
-    return time.convert(result_format, millis=is_falsy(exclude_millis))
+    return time.convert(result_format, millis=not exclude_millis)
 
 
 def subtract_time_from_time(time1, time2, result_format='number',
@@ -506,7 +515,7 @@ def subtract_time_from_time(time1, time2, result_format='number',
     | Should Be Equal | ${time}                 | - 10s    |
     """
     time = Time(time1) - Time(time2)
-    return time.convert(result_format, millis=is_falsy(exclude_millis))
+    return time.convert(result_format, millis=not exclude_millis)
 
 
 class Date:
@@ -520,33 +529,38 @@ class Date:
         return self._convert_to_epoch(self.datetime)
 
     def _convert_to_datetime(self, date, input_format):
-        if isinstance(date, datetime):
+        if isinstance(date, datetime.datetime):
             return date
-        if is_number(date):
-            return datetime.fromtimestamp(date)
-        if is_string(date):
+        if isinstance(date, datetime.date):
+            return datetime.datetime(date.year, date.month, date.day)
+        if isinstance(date, (int, float)):
+            return self._epoch_seconds_to_datetime(date)
+        if isinstance(date, str):
             return self._string_to_datetime(date, input_format)
-        raise ValueError("Unsupported input '%s'." % date)
+        raise ValueError(f"Unsupported input '{date}'.")
+
+    def _epoch_seconds_to_datetime(self, secs):
+        return datetime.datetime.fromtimestamp(secs)
 
     def _string_to_datetime(self, ts, input_format):
         if not input_format:
             ts = self._normalize_timestamp(ts)
             input_format = '%Y-%m-%d %H:%M:%S.%f'
-        return datetime.strptime(ts, input_format)
+        return datetime.datetime.strptime(ts, input_format)
 
-    def _normalize_timestamp(self, date):
-        ts = ''.join(d for d in date if d.isdigit())
-        if not (8 <= len(ts) <= 20):
-            raise ValueError("Invalid timestamp '%s'." % date)
-        ts = ts.ljust(20, '0')
-        return '%s-%s-%s %s:%s:%s.%s' % (ts[:4], ts[4:6], ts[6:8], ts[8:10],
-                                         ts[10:12], ts[12:14], ts[14:])
+    def _normalize_timestamp(self, timestamp):
+        numbers = ''.join(d for d in timestamp if d.isdigit())
+        if not (8 <= len(numbers) <= 20):
+            raise ValueError(f"Invalid timestamp '{timestamp}'.")
+        d = numbers[:8]
+        t = numbers[8:].ljust(12, '0')
+        return f'{d[:4]}-{d[4:6]}-{d[6:8]} {t[:2]}:{t[2:4]}:{t[4:6]}.{t[6:]}'
 
     def convert(self, format, millis=True):
         dt = self.datetime
         if not millis:
             secs = 1 if dt.microsecond >= 5e5 else 0
-            dt = dt.replace(microsecond=0) + timedelta(seconds=secs)
+            dt = dt.replace(microsecond=0) + datetime.timedelta(seconds=secs)
         if '%' in format:
             return self._convert_to_custom_timestamp(dt, format)
         format = format.lower()
@@ -556,7 +570,7 @@ class Date:
             return dt
         if format == 'epoch':
             return self._convert_to_epoch(dt)
-        raise ValueError("Unknown format '%s'." % format)
+        raise ValueError(f"Unknown format '{format}'.")
 
     def _convert_to_custom_timestamp(self, dt, format):
         return dt.strftime(format)
@@ -566,25 +580,25 @@ class Date:
             return dt.strftime('%Y-%m-%d %H:%M:%S')
         ms = round(dt.microsecond / 1000)
         if ms == 1000:
-            dt += timedelta(seconds=1)
+            dt += datetime.timedelta(seconds=1)
             ms = 0
-        return dt.strftime('%Y-%m-%d %H:%M:%S') + '.%03d' % ms
+        return dt.strftime('%Y-%m-%d %H:%M:%S') + f'.{ms:03d}'
 
     def _convert_to_epoch(self, dt):
-        return time.mktime(dt.timetuple()) + dt.microsecond / 1e6
+        return dt.timestamp()
 
     def __add__(self, other):
         if isinstance(other, Time):
             return Date(self.datetime + other.timedelta)
-        raise TypeError('Can only add Time to Date, got %s.' % type_name(other))
+        raise TypeError(f'Can only add Time to Date, got {type_name(other)}.')
 
     def __sub__(self, other):
         if isinstance(other, Date):
             return Time(self.datetime - other.datetime)
         if isinstance(other, Time):
             return Date(self.datetime - other.timedelta)
-        raise TypeError('Can only subtract Date or Time from Date, got %s.'
-                        % type_name(other))
+        raise TypeError(f'Can only subtract Date or Time from Date, '
+                        f'got {type_name(other)}.')
 
 
 class Time:
@@ -593,19 +607,19 @@ class Time:
         self.seconds = float(self._convert_time_to_seconds(time))
 
     def _convert_time_to_seconds(self, time):
-        if isinstance(time, timedelta):
+        if isinstance(time, datetime.timedelta):
             return time.total_seconds()
         return timestr_to_secs(time, round_to=None)
 
     @property
     def timedelta(self):
-        return timedelta(seconds=self.seconds)
+        return datetime.timedelta(seconds=self.seconds)
 
     def convert(self, format, millis=True):
         try:
-            result_converter = getattr(self, '_convert_to_%s' % format.lower())
+            result_converter = getattr(self, f'_convert_to_{format.lower()}')
         except AttributeError:
-            raise ValueError("Unknown format '%s'." % format)
+            raise ValueError(f"Unknown format '{format}'.")
         seconds = self.seconds if millis else float(round(self.seconds))
         return result_converter(seconds, millis)
 
@@ -619,18 +633,17 @@ class Time:
         return secs_to_timestr(seconds, compact=True)
 
     def _convert_to_timer(self, seconds, millis=True):
-        return elapsed_time_to_string(seconds * 1000, include_millis=millis)
+        return elapsed_time_to_string(seconds, include_millis=millis, seconds=True)
 
     def _convert_to_timedelta(self, seconds, millis=True):
-        return timedelta(seconds=seconds)
+        return datetime.timedelta(seconds=seconds)
 
     def __add__(self, other):
         if isinstance(other, Time):
             return Time(self.seconds + other.seconds)
-        raise TypeError('Can only add Time to Time, got %s.' % type_name(other))
+        raise TypeError(f'Can only add Time to Time, got {type_name(other)}.')
 
     def __sub__(self, other):
         if isinstance(other, Time):
             return Time(self.seconds - other.seconds)
-        raise TypeError('Can only subtract Time from Time, got %s.'
-                        % type_name(other))
+        raise TypeError(f'Can only subtract Time from Time, got {type_name(other)}.')

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/libraries/OperatingSystem.py

@@ -21,6 +21,7 @@ import re
 import shutil
 import tempfile
 import time
+from datetime import datetime
 
 from robot.version import get_version
 from robot.api import logger
@@ -28,7 +29,7 @@ from robot.api.deco import keyword
 from robot.utils import (abspath, ConnectionCache, console_decode, del_env_var,
                          get_env_var, get_env_vars, get_time, is_truthy,
                          is_string, normpath, parse_time, plural_or_not,
-                         safe_str, secs_to_timestamp, secs_to_timestr, seq2str,
+                         safe_str, secs_to_timestr, seq2str,
                          set_env_var, timestr_to_secs, CONSOLE_ENCODING, WINDOWS)
 
 __version__ = get_version()
@@ -108,10 +109,10 @@ class OperatingSystem:
     operating system dependent, but typically e.g. ``~/robot`` is expanded to
     ``C:\Users\<user>\robot`` on Windows and ``/home/<user>/robot`` on Unixes.
 
-    = ``pathlib.Path`` support =
+    = pathlib.Path support =
 
     Starting from Robot Framework 6.0, arguments representing paths can be given
-    as [https://docs.python.org/3/library/pathlib.html pathlib.Path] instances
+    as [https://docs.python.org/3/library/pathlib.html|pathlib.Path] instances
     in addition to strings.
 
     All keywords returning paths return them as strings. This may change in
@@ -1297,8 +1298,8 @@ class OperatingSystem:
         if not os.path.isfile(path):
             self._error("Path '%s' is not a regular file." % path)
         os.utime(path, (mtime, mtime))
-        time.sleep(0.1)  # Give os some time to really set these times
-        tstamp = secs_to_timestamp(mtime, seps=('-', ' ', ':'))
+        time.sleep(0.1)    # Give OS some time to really set these times.
+        tstamp = datetime.fromtimestamp(mtime).isoformat(' ', timespec='seconds')
         self._link("Set modified time of '%%s' to %s." % tstamp, path)
 
     def get_file_size(self, path):

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/libraries/Process.py

@@ -75,7 +75,7 @@ class Process:
     optional ``**configuration`` keyword arguments. Configuration arguments
     must be given after other arguments passed to these keywords and must
     use syntax like ``name=value``. Available configuration arguments are
-    listed below and discussed further in sections afterwards.
+    listed below and discussed further in sections afterward.
 
     |  = Name =  |                  = Explanation =                      |
     | shell      | Specifies whether to run the command in shell or not. |
@@ -96,7 +96,7 @@ class Process:
     == Running processes in shell ==
 
     The ``shell`` argument specifies whether to run the process in a shell or
-    not. By default shell is not used, which means that shell specific commands,
+    not. By default, shell is not used, which means that shell specific commands,
     like ``copy`` and ``dir`` on Windows, are not available. You can, however,
     run shell scripts and batch files without using a shell.
 
@@ -129,8 +129,8 @@ class Process:
 
     == Environment variables ==
 
-    By default the child process will get a copy of the parent process's
-    environment variables. The ``env`` argument can be used to give the
+    The child process will get a copy of the parent process's environment
+    variables by default. The ``env`` argument can be used to give the
     child a custom environment as a Python dictionary. If there is a need
     to specify only certain environment variable, it is possible to use the
     ``env:<name>=<value>`` format to set or override only that named variables.
@@ -143,12 +143,12 @@ class Process:
 
     == Standard output and error streams ==
 
-    By default processes are run so that their standard output and standard
+    By default, processes are run so that their standard output and standard
     error streams are kept in the memory. This works fine normally,
     but if there is a lot of output, the output buffers may get full and
     the program can hang.
 
-    To avoid the above mentioned problems, it is possible to use ``stdout``
+    To avoid the above-mentioned problems, it is possible to use ``stdout``
     and ``stderr`` arguments to specify files on the file system where to
     redirect the outputs. This can also be useful if other processes or
     other keywords need to read or manipulate the outputs somehow.
@@ -172,8 +172,6 @@ class Process:
     This way the process will not hang even if there would be a lot of output,
     but naturally output is not available after execution either.
 
-    Support for the special value ``DEVNULL`` is new in Robot Framework 3.2.
-
     Examples:
     | ${result} = | `Run Process` | program | stdout=${TEMPDIR}/stdout.txt | stderr=${TEMPDIR}/stderr.txt |
     | `Log Many`  | stdout: ${result.stdout} | stderr: ${result.stderr} |
@@ -191,25 +189,23 @@ class Process:
     explained in the table below.
 
     | = Value =        | = Explanation = |
-    | String ``PIPE``  | Make stdin a pipe that can be written to. This is the default. |
-    | String ``NONE``  | Inherit stdin from the parent process. This value is case-insensitive. |
+    | String ``NONE``  | Inherit stdin from the parent process. This is the default. |
+    | String ``PIPE``  | Make stdin a pipe that can be written to. |
     | Path to a file   | Open the specified file and use it as the stdin. |
     | Any other string | Create a temporary file with the text as its content and use it as the stdin. |
     | Any non-string value | Used as-is. Could be a file descriptor, stdout of another process, etc. |
 
-    Values ``PIPE`` and ``NONE`` are internally mapped directly to
+    Values ``PIPE`` and ``NONE`` are case-insensitive and internally mapped to
     ``subprocess.PIPE`` and ``None``, respectively, when calling
     [https://docs.python.org/3/library/subprocess.html#subprocess.Popen|subprocess.Popen].
-    The default behavior may change from ``PIPE`` to ``NONE`` in future
-    releases. If you depend on the ``PIPE`` behavior, it is a good idea to use
-    it explicitly.
 
     Examples:
-    | `Run Process` | command | stdin=NONE |
+    | `Run Process` | command | stdin=PIPE |
     | `Run Process` | command | stdin=${CURDIR}/stdin.txt |
     | `Run Process` | command | stdin=Stdin as text. |
 
-    The support to configure ``stdin`` is new in Robot Framework 4.1.2.
+    The support to configure ``stdin`` is new in Robot Framework 4.1.2. Its default
+    value used to be ``PIPE`` until Robot Framework 7.0.
 
     == Output encoding ==
 
@@ -298,8 +294,6 @@ class Process:
     | `Terminate Process` | kill=${EMPTY} | # Empty string is false.       |
     | `Terminate Process` | kill=${FALSE} | # Python ``False`` is false.   |
 
-    Considering ``OFF`` and ``0`` false is new in Robot Framework 3.1.
-
     = Example =
 
     | ***** Settings *****
@@ -337,9 +331,15 @@ class Process:
         configuration` for more details about configuration related to starting
         processes. Configuration related to waiting for processes consists of
         ``timeout`` and ``on_timeout`` arguments that have same semantics as
-        with `Wait For Process` keyword. By default there is no timeout, and
+        with `Wait For Process` keyword. By default, there is no timeout, and
         if timeout is defined the default action on timeout is ``terminate``.
 
+        Process outputs are, by default, written into in-memory buffers.
+        If there is a lot of output, these buffers may get full causing
+        the process to hang. To avoid that, process outputs can be redirected
+        using the ``stdout`` and ``stderr`` configuration parameters. For more
+        information see the `Standard output and error streams` section.
+
         Returns a `result object` containing information about the execution.
 
         Note that possible equal signs in ``*arguments`` must be escaped
@@ -349,7 +349,7 @@ class Process:
         Examples:
         | ${result} = | Run Process | python | -c | print('Hello, world!') |
         | Should Be Equal | ${result.stdout} | Hello, world! |
-        | ${result} = | Run Process | ${command} | stderr=STDOUT | timeout=10s |
+        | ${result} = | Run Process | ${command} | stdout=${CURDIR}/stdout.txt | stderr=STDOUT |
         | ${result} = | Run Process | ${command} | timeout=1min | on_timeout=continue |
         | ${result} = | Run Process | java -Dname\\=value Example | shell=True | cwd=${EXAMPLE} |
 
@@ -369,11 +369,13 @@ class Process:
 
         See `Specifying command and arguments` and `Process configuration`
         for more information about the arguments, and `Run Process` keyword
-        for related examples.
+        for related examples. This includes information about redirecting
+        process outputs to avoid process handing due to output buffers getting
+        full.
 
         Makes the started process new `active process`. Returns the created
         [https://docs.python.org/3/library/subprocess.html#popen-constructor |
-        subprocess.Popen] object which can be be used later to active this
+        subprocess.Popen] object which can be used later to activate this
         process. ``Popen`` attributes like ``pid`` can also be accessed directly.
 
         Processes are started so that they create a new process group. This
@@ -381,7 +383,7 @@ class Process:
 
         Examples:
 
-        Start process and wait for it to end later using alias:
+        Start process and wait for it to end later using an alias:
         | `Start Process` | ${command} | alias=example |
         | # Other keywords |
         | ${result} = | `Wait For Process` | example |
@@ -492,9 +494,6 @@ class Process:
         | ${result} =                 | Wait For Process | timeout=1min 30s | on_timeout=kill |
         | Process Should Be Stopped   |                  |                  |
         | Should Be Equal As Integers | ${result.rc}     | -9               |
-
-        Ignoring timeout if it is string ``NONE``, zero, or negative is new
-        in Robot Framework 3.2.
         """
         process = self._processes[handle]
         logger.info('Waiting for process to complete.')
@@ -882,7 +881,7 @@ class ExecutionResult:
 
 class ProcessConfiguration:
 
-    def __init__(self, cwd=None, shell=False, stdout=None, stderr=None, stdin='PIPE',
+    def __init__(self, cwd=None, shell=False, stdout=None, stderr=None, stdin=None,
                  output_encoding='CONSOLE', alias=None, env=None, **rest):
         self.cwd = os.path.normpath(cwd) if cwd else os.path.abspath('.')
         self.shell = is_truthy(shell)

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/libraries/Remote.py

@@ -20,6 +20,7 @@ import re
 import socket
 import sys
 import xmlrpc.client
+from datetime import date, datetime, timedelta
 from xml.parsers.expat import ExpatError
 
 from robot.errors import RemoteError
@@ -59,8 +60,8 @@ class Remote:
         try:
             return self._client.get_keyword_names()
         except TypeError as error:
-            raise RuntimeError('Connecting remote server at %s failed: %s'
-                               % (self._uri, error))
+            raise RuntimeError(f'Connecting remote server at {self._uri} '
+                               f'failed: {error}')
 
     def _is_lib_info_available(self):
         if not self._lib_info_initialized:
@@ -107,47 +108,53 @@ class Remote:
 
 class ArgumentCoercer:
     binary = re.compile('[\x00-\x08\x0B\x0C\x0E-\x1F]')
-    non_ascii = re.compile('[\x80-\xff]')
 
     def coerce(self, argument):
         for handles, handler in [(is_string, self._handle_string),
-                                 (is_bytes, self._handle_bytes),
-                                 (is_number, self._pass_through),
+                                 (self._no_conversion_needed, self._pass_through),
+                                 (self._is_date, self._handle_date),
+                                 (self._is_timedelta, self._handle_timedelta),
                                  (is_dict_like, self._coerce_dict),
-                                 (is_list_like, self._coerce_list),
-                                 (lambda arg: True, self._to_string)]:
+                                 (is_list_like, self._coerce_list)]:
             if handles(argument):
                 return handler(argument)
+        return self._to_string(argument)
+
+    def _no_conversion_needed(self, arg):
+        return is_number(arg) or is_bytes(arg) or isinstance(arg, datetime)
 
     def _handle_string(self, arg):
-        if self._string_contains_binary(arg):
+        if self.binary.search(arg):
             return self._handle_binary_in_string(arg)
         return arg
 
-    def _string_contains_binary(self, arg):
-        return (self.binary.search(arg) or
-                is_bytes(arg) and self.non_ascii.search(arg))
-
     def _handle_binary_in_string(self, arg):
         try:
-            if not is_bytes(arg):
-                # Map Unicode code points to bytes directly
-                arg = arg.encode('latin-1')
+            # Map Unicode code points to bytes directly
+            return arg.encode('latin-1')
         except UnicodeError:
-            raise ValueError('Cannot represent %r as binary.' % arg)
-        return xmlrpc.client.Binary(arg)
-
-    def _handle_bytes(self, arg):
-        return xmlrpc.client.Binary(arg)
+            raise ValueError(f'Cannot represent {arg!r} as binary.')
 
     def _pass_through(self, arg):
         return arg
 
+    def _is_date(self, arg):
+        return isinstance(arg, date)
+
+    def _handle_date(self, arg):
+        return datetime(arg.year, arg.month, arg.day)
+
+    def _is_timedelta(self, arg):
+        return isinstance(arg, timedelta)
+
+    def _handle_timedelta(self, arg):
+        return arg.total_seconds()
+
     def _coerce_list(self, arg):
         return [self.coerce(item) for item in arg]
 
     def _coerce_dict(self, arg):
-        return dict((self._to_key(key), self.coerce(arg[key])) for key in arg)
+        return {self._to_key(key): self.coerce(arg[key]) for key in arg}
 
     def _to_key(self, item):
         item = self._to_string(item)
@@ -159,15 +166,15 @@ class ArgumentCoercer:
         return self._handle_string(item)
 
     def _validate_key(self, key):
-        if isinstance(key, xmlrpc.client.Binary):
-            raise ValueError('Dictionary keys cannot be binary. Got %r.' % (key.data,))
+        if isinstance(key, bytes):
+            raise ValueError(f'Dictionary keys cannot be binary. Got {key!r}.')
 
 
 class RemoteResult:
 
     def __init__(self, result):
         if not (is_dict_like(result) and 'status' in result):
-            raise RuntimeError('Invalid remote result dictionary: %s' % result)
+            raise RuntimeError(f'Invalid remote result dictionary: {result!r}')
         self.status = result['status']
         self.output = safe_str(self._get(result, 'output'))
         self.return_ = self._get(result, 'return')
@@ -181,8 +188,6 @@ class RemoteResult:
         return self._convert(value)
 
     def _convert(self, value):
-        if isinstance(value, xmlrpc.client.Binary):
-            return bytes(value.data)
         if is_dict_like(value):
             return DotDict((k, self._convert(v)) for k, v in value.items())
         if is_list_like(value):
@@ -204,6 +209,7 @@ class XmlRpcRemoteClient:
         else:
             transport = TimeoutHTTPTransport(timeout=self.timeout)
         server = xmlrpc.client.ServerProxy(self.uri, encoding='UTF-8',
+                                           use_builtin_types=True,
                                            transport=transport)
         try:
             yield server
@@ -244,12 +250,12 @@ class XmlRpcRemoteClient:
             except xmlrpc.client.Fault as err:
                 message = err.faultString
             except socket.error as err:
-                message = 'Connection to remote server broken: %s' % err
+                message = f'Connection to remote server broken: {err}'
             except ExpatError as err:
-                message = ('Processing XML-RPC return value failed. '
-                           'Most often this happens when the return value '
-                           'contains characters that are not valid in XML. '
-                           'Original error was: ExpatError: %s' % err)
+                message = (f'Processing XML-RPC return value failed. '
+                           f'Most often this happens when the return value '
+                           f'contains characters that are not valid in XML. '
+                           f'Original error was: ExpatError: {err}')
             raise RuntimeError(message)
 
 
@@ -259,11 +265,9 @@ class XmlRpcRemoteClient:
 class TimeoutHTTPTransport(xmlrpc.client.Transport):
     _connection_class = http.client.HTTPConnection
 
-    def __init__(self, use_datetime=0, timeout=None):
-        xmlrpc.client.Transport.__init__(self, use_datetime)
-        if not timeout:
-            timeout = socket._GLOBAL_DEFAULT_TIMEOUT
-        self.timeout = timeout
+    def __init__(self, timeout=None):
+        super().__init__(use_builtin_types=True)
+        self.timeout = timeout or socket._GLOBAL_DEFAULT_TIMEOUT
 
     def make_connection(self, host):
         if self._connection and host == self._connection[0]: