parsl 2023.10.23__py3-none-any.whl → 2023.11.20__py3-none-any.whl

parsl/executors/radical/rpex_resources.py

@@ -0,0 +1,165 @@
+import sys
+import json
+
+from typing import List
+
+_setup_paths: List[str]
+try:
+    import radical.pilot as rp
+    import radical.utils as ru
+except ImportError:
+    _setup_paths = []
+else:
+    _setup_paths = [rp.sdist_path,
+                    ru.sdist_path]
+
+
+MPI = "mpi"
+RP_ENV = "rp"
+CLIENT = "client"
+RPEX_ENV = "ve_rpex"
+MPI_WORKER = "MPIWorker"
+DEFAULT_WORKER = "DefaultWorker"
+
+
+class ResourceConfig:
+    """
+    This ResourceConfig class is an abstraction of the resource
+    configuration of the RAPTOR layer in the RADICAL-Pilot runtime system.
+
+    This class sets up the default configuration values for the executor and
+    allows the user to specify different resource requirements flexibly.
+
+    For more information:
+    https://radicalpilot.readthedocs.io/en/stable/tutorials/raptor.html
+
+    Parameters
+    ----------
+    masters : int
+        The number of masters to be deployed by RAPTOR.
+        Default is 1.
+
+    workers : int
+        The number of workers to be deployed by RAPTOR.
+        Default is 1.
+
+    worker_gpus_per_node : int
+        The number of GPUs a worker will operate on per node.
+        Default is 0.
+
+    worker_cores_per_node : int
+        The number of CPU cores a worker will operate on per node.
+        Default is 4.
+
+    cores_per_master : int
+        The number of cores a master will operate on per node.
+        Default is 1.
+
+    nodes_per_worker : int
+        The number of nodes to be occupied by every worker.
+        Default is 1.
+
+    pilot_env_path : str
+        The path to an exisitng pilot environment.
+        Default is an empty string (RADICAL-Pilot will create one).
+
+    pilot_env_name : str
+        The name of the pilot environment.
+        Default is "ve_rpex".
+
+    pilot_env_pre_exec : list
+        List of commands to be executed before starting the pilot environment.
+        Default is an empty list.
+
+    pilot_env_type : str
+        The type of the pilot environment (e.g., 'venv', 'conda').
+        Default is "venv".
+
+    pilot_env_setup : list
+        List of setup commands/packages for the pilot environment.
+        Default setup includes "parsl", rp.sdist_path, and ru.sdist_path.
+
+    python_v : str
+        The Python version to be used in the pilot environment.
+        Default is determined by the system's Python version.
+
+    worker_type : str
+        The type of worker(s) to be deployed by RAPTOR on the compute
+        resources.
+        Default is "DefaultWorker".
+    """
+
+    masters: int = 1
+    workers: int = 1
+
+    worker_gpus_per_node: int = 0
+    worker_cores_per_node: int = 4
+
+    cores_per_master: int = 1
+    nodes_per_worker: int = 1
+
+    pilot_env_mode: str = CLIENT
+    pilot_env_path: str = ""
+    pilot_env_type: str = "venv"
+    pilot_env_name: str = RP_ENV
+    pilot_env_pre_exec: List[str] = []
+    pilot_env_setup: List[str] = _setup_paths
+
+    python_v: str = f'{sys.version_info[0]}.{sys.version_info[1]}'
+    worker_type: str = DEFAULT_WORKER
+
+    def _get_cfg_file(cls, path=None):
+
+        # Default ENV mode for RP is to reuse
+        # the client side. If this is not the case,
+        # then RP will create a new env named ve_rpex
+        # The user need to make sure that under:
+        # $HOME/.radical/pilot/configs/*_resource.json
+        # that virtenv_mode = local
+        if cls.pilot_env_mode != CLIENT:
+            cls.pilot_env_name = RPEX_ENV
+
+        if MPI in cls.worker_type.lower() and \
+           "mpi4py" not in cls.pilot_env_setup:
+            cls.pilot_env_setup.append("mpi4py")
+
+        cfg = {
+            'n_masters': cls.masters,
+            'n_workers': cls.workers,
+            'gpus_per_node': cls.worker_gpus_per_node,
+            'cores_per_node': cls.worker_cores_per_node,
+            'cores_per_master': cls.cores_per_master,
+            'nodes_per_worker': cls.nodes_per_worker,
+
+            'pilot_env': {
+                "version": cls.python_v,
+                "name": cls.pilot_env_name,
+                "path": cls.pilot_env_path,
+                "type": cls.pilot_env_type,
+                "setup": cls.pilot_env_setup,
+                "pre_exec": cls.pilot_env_pre_exec
+            },
+
+            'pilot_env_mode': cls.pilot_env_mode,
+
+            'master_descr': {
+                "mode": rp.RAPTOR_MASTER,
+                "named_env": cls.pilot_env_name,
+                "executable": "python3 rpex_master.py",
+            },
+
+            'worker_descr': {
+                "mode": rp.RAPTOR_WORKER,
+                "named_env": cls.pilot_env_name,
+                "raptor_file": "./rpex_worker.py",
+                "raptor_class": cls.worker_type if
+                cls.worker_type.lower() != MPI else MPI_WORKER,
+            }}
+
+        # Convert the class instance to a cfg file.
+        config_path = 'rpex.cfg'
+        if path:
+            config_path = path + '/' + config_path
+        with open(config_path, 'w') as f:
+            json.dump(cfg, f, indent=4)
+        return config_path

parsl/executors/radical/rpex_worker.py

@@ -0,0 +1,61 @@
+import sys
+import radical.pilot as rp
+
+import parsl.app.errors as pe
+from parsl.app.bash import remote_side_bash_executor
+from parsl.serialize import unpack_apply_message, serialize
+from parsl.executors.high_throughput.process_worker_pool import execute_task
+
+
+class ParslWorker:
+
+    def _dispatch_func(self, task):
+
+        try:
+            buffer = rp.utils.deserialize_bson(task['description']['function'])
+            result = execute_task(buffer)
+            val = str(serialize(result, buffer_threshold=1000000))
+            exc = (None, None)
+            ret = 0
+            out = None
+            err = None
+        except Exception:
+            val = None
+            exc = (rp.utils.serialize_bson(pe.RemoteExceptionWrapper(*sys.exc_info())), None)
+            ret = 1
+            out = None
+            err = None
+
+        return out, err, ret, val, exc
+
+    def _dispatch_proc(self, task):
+
+        try:
+            buffer = rp.utils.deserialize_bson(task['description']['executable'])
+            func, args, kwargs = unpack_apply_message(buffer, {}, copy=False)
+            ret = remote_side_bash_executor(func, *args, **kwargs)
+            exc = (None, None)
+            val = None
+            out = None
+            err = None
+        except Exception:
+            val = None
+            exc = (rp.utils.serialize_bson(pe.RemoteExceptionWrapper(*sys.exc_info())), None)
+            ret = 1
+            out = None
+            err = None
+
+        return out, err, ret, val, exc
+
+
+class MPIWorker(rp.raptor.MPIWorker):
+    def _dispatch_func(self, task):
+        return super()._dispatch_func(task)
+
+
+class DefaultWorker(rp.raptor.DefaultWorker):
+    def _dispatch_func(self, task):
+        return ParslWorker()._dispatch_func(task)
+
+    def _dispatch_proc(self, task):
+        return ParslWorker()._dispatch_proc(task)

parsl/executors/status_handling.py

@@ -6,7 +6,6 @@ from abc import abstractmethod, abstractproperty
 from concurrent.futures import Future
 from typing import List, Any, Dict, Optional, Tuple, Union, Callable
 
-import parsl  # noqa F401
 from parsl.executors.base import ParslExecutor
 from parsl.executors.errors import BadStateException, ScalingFailed
 from parsl.jobs.states import JobStatus, JobState
@@ -193,7 +192,7 @@ class BlockProviderExecutor(ParslExecutor):
             raise ScalingFailed(self, "No execution provider available")
         block_ids = []
         logger.info(f"Scaling out by {blocks} blocks")
-        for i in range(blocks):
+        for _ in range(blocks):
             block_id = str(self._block_id_counter.get_id())
             logger.info(f"Allocated block ID {block_id}")
             try:

parsl/executors/taskvine/exec_parsl_function.py

@@ -1,11 +1,10 @@
 import traceback
 import sys
 
-import pickle
 from parsl.app.errors import RemoteExceptionWrapper
 from parsl.data_provider.files import File
 from parsl.utils import get_std_fname_mode
-from parsl.serialize import deserialize
+from parsl.serialize import deserialize, serialize
 
 # This scripts executes a parsl function which is pickled in 4 files:
 #
@@ -30,10 +29,10 @@ from parsl.serialize import deserialize
 #
 
 
-def dump_result_to_file(result_file: str, result_package):
+def dump_result_to_file(result_file: str, result):
     """ Dump a result to the given result file."""
     with open(result_file, "wb") as f_out:
-        pickle.dump(result_package, f_out)
+        f_out.write(serialize(result))
 
 
 def remap_location(mapping, parsl_file):

parsl/executors/taskvine/executor.py

@@ -22,7 +22,7 @@ from typing import List, Optional, Union, Literal
 # Import Parsl constructs
 import parsl.utils as putils
 from parsl.data_provider.staging import Staging
-from parsl.serialize import serialize
+from parsl.serialize import serialize, deserialize
 from parsl.data_provider.files import File
 from parsl.errors import OptionalModuleMissing
 from parsl.providers.base import ExecutionProvider
@@ -614,7 +614,6 @@ class TaskVineExecutor(BlockProviderExecutor, putils.RepresentationMixin):
             self._factory_process.join()
 
         logger.debug("TaskVine shutdown completed")
-        return True
 
     @wrap_with_logs
     def _collect_taskvine_results(self):
@@ -639,11 +638,26 @@ class TaskVineExecutor(BlockProviderExecutor, putils.RepresentationMixin):
                 logger.debug(f'Updating Future for Parsl Task: {task_report.executor_id}. \
                                Task {task_report.executor_id} has result_received set to {task_report.result_received}')
                 if task_report.result_received:
-                    future.set_result(task_report.result)
+                    try:
+                        with open(task_report.result_file, 'rb') as f_in:
+                            result = deserialize(f_in.read())
+                    except Exception as e:
+                        logger.error(f'Cannot load result from result file {task_report.result_file}. Exception: {e}')
+                        ex = TaskVineTaskFailure('Cannot load result from result file', None)
+                        ex.__cause__ = e
+                        future.set_exception(ex)
+                    else:
+                        if isinstance(result, Exception):
+                            ex = TaskVineTaskFailure('Task execution raises an exception', result)
+                            ex.__cause__ = result
+                            future.set_exception(ex)
+                        else:
+                            future.set_result(result)
                 else:
                     # If there are no results, then the task failed according to one of
                     # taskvine modes, such as resource exhaustion.
-                    future.set_exception(TaskVineTaskFailure(task_report.reason, task_report.result))
+                    ex = TaskVineTaskFailure(task_report.reason, None)
+                    future.set_exception(ex)
 
                 # decrement outstanding task counter
                 with self._outstanding_tasks_lock:

parsl/executors/taskvine/factory.py

@@ -30,7 +30,7 @@ def _taskvine_factory(should_stop, factory_config):
         else:
             factory = Factory(batch_type=factory_config.batch_type,
                               manager_host_port=f"{factory_config._project_address}:{factory_config._project_port}",
-                             )
+                              )
     except Exception as e:
         raise TaskVineFactoryFailure(f'Cannot create factory with exception {e}')
 

parsl/executors/taskvine/manager.py

@@ -2,7 +2,6 @@ import logging
 import hashlib
 import subprocess
 import os
-import pickle
 import queue
 import shutil
 import uuid
@@ -229,7 +228,7 @@ def _taskvine_submit_wait(ready_task_queue=None,
                     logger.error("Unable to create executor task (mode:regular): {}".format(e))
                     finished_task_queue.put_nowait(VineTaskToParsl(executor_id=task.executor_id,
                                                                    result_received=False,
-                                                                   result=None,
+                                                                   result_file=None,
                                                                    reason="task could not be created by taskvine",
                                                                    status=-1))
                     continue
@@ -268,7 +267,7 @@ def _taskvine_submit_wait(ready_task_queue=None,
                     logger.error("Unable to create executor task (mode:serverless): {}".format(e))
                     finished_task_queue.put_nowait(VineTaskToParsl(executor_id=task.executor_id,
                                                                    result_received=False,
-                                                                   result=None,
+                                                                   result_file=None,
                                                                    reason="task could not be created by taskvine",
                                                                    status=-1))
             else:
@@ -369,7 +368,7 @@ def _taskvine_submit_wait(ready_task_queue=None,
                 logger.error("Unable to submit task to taskvine: {}".format(e))
                 finished_task_queue.put_nowait(VineTaskToParsl(executor_id=task.executor_id,
                                                                result_received=False,
-                                                               result=None,
+                                                               result_file=None,
                                                                reason="task could not be submited to taskvine",
                                                                status=-1))
                 continue
@@ -394,24 +393,21 @@ def _taskvine_submit_wait(ready_task_queue=None,
 
                 logger.debug(f"completed executor task info: {executor_task_id}, {t.category}, {t.command}, {t.std_output}")
 
-                # A tasks completes 'succesfully' if it has result file,
-                # and it can be loaded. This may mean that the 'success' is
-                # an exception.
+                # A tasks completes 'succesfully' if it has result file.
+                # A check whether the Python object represented using this file can be
+                # deserialized happens later in the collector thread of the executor
+                # process.
                 logger.debug("Looking for result in {}".format(result_file))
-                try:
-                    with open(result_file, "rb") as f_in:
-                        result = pickle.load(f_in)
+                if os.path.exists(result_file):
                     logger.debug("Found result in {}".format(result_file))
                     finished_task_queue.put_nowait(VineTaskToParsl(executor_id=executor_task_id,
                                                                    result_received=True,
-                                                                   result=result,
+                                                                   result_file=result_file,
                                                                    reason=None,
                                                                    status=t.exit_code))
                 # If a result file could not be generated, explain the
-                # failure according to taskvine error codes. We generate
-                # an exception and wrap it with RemoteExceptionWrapper, to
-                # match the positive case.
-                except Exception as e:
+                # failure according to taskvine error codes.
+                else:
                     reason = _explain_taskvine_result(t)
                     logger.debug("Did not find result in {}".format(result_file))
                     logger.debug("Wrapper Script status: {}\nTaskVine Status: {}"
@@ -420,7 +416,7 @@ def _taskvine_submit_wait(ready_task_queue=None,
                                  .format(executor_task_id, t.id, reason))
                     finished_task_queue.put_nowait(VineTaskToParsl(executor_id=executor_task_id,
                                                                    result_received=False,
-                                                                   result=e,
+                                                                   result_file=None,
                                                                    reason=reason,
                                                                    status=t.exit_code))
 

parsl/executors/taskvine/utils.py

@@ -42,20 +42,20 @@ class ParslTaskToVine:
 
 class VineTaskToParsl:
     """
-    Support structure to communicate final status of TaskVine tasks to Parsl
-    result is only valid if result_received is True
-    reason and status are only valid if result_received is False
+    Support structure to communicate final status of TaskVine tasks to Parsl.
+    result_file is only valid if result_received is True.
+    Reason and status are only valid if result_received is False.
     """
     def __init__(self,
                  executor_id: int,          # executor id of task
                  result_received: bool,     # whether result is received or not
-                 result,                    # result object if available
+                 result_file: Optional[str],    # path to file that contains the serialized result object
                  reason: Optional[str],     # string describing why execution fails
                  status: Optional[int]      # exit code of execution of task
                  ):
         self.executor_id = executor_id
         self.result_received = result_received
-        self.result = result
+        self.result_file = result_file
         self.reason = reason
         self.status = status
 

parsl/executors/threads.py

@@ -72,9 +72,8 @@ class ThreadPoolExecutor(ParslExecutor, RepresentationMixin):
 
         """
         logger.debug("Shutting down executor, which involves waiting for running tasks to complete")
-        x = self.executor.shutdown(wait=block)
+        self.executor.shutdown(wait=block)
         logger.debug("Done with executor shutdown")
-        return x
 
     def monitor_resources(self):
         """Resource monitoring sometimes deadlocks when using threads, so this function

parsl/executors/workqueue/exec_parsl_function.py

@@ -4,6 +4,7 @@ from parsl.utils import get_std_fname_mode
 import traceback
 import sys
 import pickle
+from parsl.serialize import serialize
 
 # This scripts executes a parsl function which is pickled in a file:
 #
@@ -32,7 +33,7 @@ def load_pickled_file(filename):
 
 def dump_result_to_file(result_file, result_package):
     with open(result_file, "wb") as f_out:
-        pickle.dump(result_package, f_out)
+        f_out.write(serialize(result_package))
 
 
 def remap_location(mapping, parsl_file):

parsl/executors/workqueue/executor.py

@@ -21,7 +21,7 @@ import inspect
 import shutil
 import itertools
 
-from parsl.serialize import pack_apply_message
+from parsl.serialize import pack_apply_message, deserialize
 import parsl.utils as putils
 from parsl.executors.errors import ExecutorError
 from parsl.data_provider.files import File
@@ -66,11 +66,11 @@ ParslTaskToWq = namedtuple('ParslTaskToWq',
 
 # Support structure to communicate final status of work queue tasks to parsl
 # if result_received is True:
-#   result is the result
+#   result_file is the path to the file containing the result.
 # if result_received is False:
 #   reason and status are only valid if result_received is False
-#   result is either None or an exception raised while looking for a result
-WqTaskToParsl = namedtuple('WqTaskToParsl', 'id result_received result reason status')
+#   result_file is None
+WqTaskToParsl = namedtuple('WqTaskToParsl', 'id result_received result_file reason status')
 
 # Support structure to report parsl filenames to work queue.
 # parsl_name is the local_name or filepath attribute of a parsl file object.
@@ -449,7 +449,7 @@ class WorkQueueExecutor(BlockProviderExecutor, putils.RepresentationMixin):
         input_files = []
         output_files = []
 
-        # Determine the input and output files that will exist at the workes:
+        # Determine the input and output files that will exist at the workers:
         input_files += [self._register_file(f) for f in kwargs.get("inputs", []) if isinstance(f, File)]
         output_files += [self._register_file(f) for f in kwargs.get("outputs", []) if isinstance(f, File)]
 
@@ -707,7 +707,6 @@ class WorkQueueExecutor(BlockProviderExecutor, putils.RepresentationMixin):
         self.collector_thread.join()
 
         logger.debug("Work Queue shutdown completed")
-        return True
 
     @wrap_with_logs
     def _collect_work_queue_results(self):
@@ -729,14 +728,29 @@ class WorkQueueExecutor(BlockProviderExecutor, putils.RepresentationMixin):
                 with self.tasks_lock:
                     future = self.tasks.pop(task_report.id)
                 logger.debug("Updating Future for executor task {}".format(task_report.id))
+                # If result_received, then there's a result file. The object inside the file
+                # may be a valid result or an exception caused within the function invocation.
+                # Otherwise there's no result file, implying errors from WorkQueue.
                 if task_report.result_received:
-                    future.set_result(task_report.result)
+                    try:
+                        with open(task_report.result_file, 'rb') as f_in:
+                            result = deserialize(f_in.read())
+                    except Exception as e:
+                        logger.error(f'Cannot load result from result file {task_report.result_file}. Exception: {e}')
+                        ex = WorkQueueTaskFailure('Cannot load result from result file', None)
+                        ex.__cause__ = e
+                        future.set_exception(ex)
+                    else:
+                        if isinstance(result, Exception):
+                            ex = WorkQueueTaskFailure('Task execution raises an exception', result)
+                            ex.__cause__ = result
+                            future.set_exception(ex)
+                        else:
+                            future.set_result(result)
                 else:
                     # If there are no results, then the task failed according to one of
                     # work queue modes, such as resource exhaustion.
-                    ex = WorkQueueTaskFailure(task_report.reason, task_report.result)
-                    if task_report.result is not None:
-                        ex.__cause__ = task_report.result
+                    ex = WorkQueueTaskFailure(task_report.reason, None)
                     future.set_exception(ex)
         finally:
             logger.debug("Marking all outstanding tasks as failed")
@@ -876,7 +890,7 @@ def _work_queue_submit_wait(*,
                 logger.error("Unable to create task: {}".format(e))
                 collector_queue.put_nowait(WqTaskToParsl(id=task.id,
                                                          result_received=False,
-                                                         result=None,
+                                                         result_file=None,
                                                          reason="task could not be created by work queue",
                                                          status=-1))
                 continue
@@ -937,7 +951,7 @@ def _work_queue_submit_wait(*,
                 logger.error("Unable to submit task to work queue: {}".format(e))
                 collector_queue.put_nowait(WqTaskToParsl(id=task.id,
                                                          result_received=False,
-                                                         result=None,
+                                                         result_file=None,
                                                          reason="task could not be submited to work queue",
                                                          status=-1))
                 continue
@@ -957,24 +971,20 @@ def _work_queue_submit_wait(*,
                 logger.debug("Completed Work Queue task {}, executor task {}".format(t.id, t.tag))
                 result_file = result_file_of_task_id.pop(t.tag)
 
-                # A tasks completes 'succesfully' if it has result file,
-                # and it can be loaded. This may mean that the 'success' is
-                # an exception.
+                # A tasks completes 'succesfully' if it has result file.
+                # The check whether this file can load a serialized Python object
+                # happens later in the collector thread of the executor process.
                 logger.debug("Looking for result in {}".format(result_file))
-                try:
-                    with open(result_file, "rb") as f_in:
-                        result = pickle.load(f_in)
+                if os.path.exists(result_file):
                     logger.debug("Found result in {}".format(result_file))
                     collector_queue.put_nowait(WqTaskToParsl(id=executor_task_id,
                                                              result_received=True,
-                                                             result=result,
+                                                             result_file=result_file,
                                                              reason=None,
                                                              status=t.return_status))
                 # If a result file could not be generated, explain the
-                # failure according to work queue error codes. We generate
-                # an exception and wrap it with RemoteExceptionWrapper, to
-                # match the positive case.
-                except Exception as e:
+                # failure according to work queue error codes.
+                else:
                     reason = _explain_work_queue_result(t)
                     logger.debug("Did not find result in {}".format(result_file))
                     logger.debug("Wrapper Script status: {}\nWorkQueue Status: {}"
@@ -983,7 +993,7 @@ def _work_queue_submit_wait(*,
                                  .format(executor_task_id, t.id, reason))
                     collector_queue.put_nowait(WqTaskToParsl(id=executor_task_id,
                                                              result_received=False,
-                                                             result=e,
+                                                             result_file=None,
                                                              reason=reason,
                                                              status=t.return_status))
     logger.debug("Exiting WorkQueue Monitoring Process")

parsl/jobs/job_status_poller.py

@@ -1,9 +1,8 @@
 import logging
-import parsl  # noqa F401 (used in string type annotation)
+import parsl
 import time
 import zmq
-from typing import Dict, Sequence
-from typing import List  # noqa F401 (used in type annotation)
+from typing import Dict, List, Sequence
 
 from parsl.jobs.states import JobStatus, JobState
 from parsl.jobs.strategy import Strategy

parsl/monitoring/monitoring.py

@@ -194,10 +194,10 @@ class MonitoringHub(RepresentationMixin):
                                                "logdir": self.logdir,
                                                "logging_level": logging.DEBUG if self.monitoring_debug else logging.INFO,
                                                "run_id": run_id
-                                       },
+                                               },
                                        name="Monitoring-Router-Process",
                                        daemon=True,
-        )
+                                       )
         self.router_proc.start()
 
         self.dbm_proc = ForkProcess(target=dbm_starter,
@@ -205,10 +205,10 @@ class MonitoringHub(RepresentationMixin):
                                     kwargs={"logdir": self.logdir,
                                             "logging_level": logging.DEBUG if self.monitoring_debug else logging.INFO,
                                             "db_url": self.logging_endpoint,
-                                    },
+                                            },
                                     name="Monitoring-DBM-Process",
                                     daemon=True,
-        )
+                                    )
         self.dbm_proc.start()
         self.logger.info("Started the router process {} and DBM process {}".format(self.router_proc.pid, self.dbm_proc.pid))
 
@@ -216,7 +216,7 @@ class MonitoringHub(RepresentationMixin):
                                        args=(self.logdir, self.resource_msgs, run_dir),
                                        name="Monitoring-Filesystem-Process",
                                        daemon=True
-        )
+                                       )
         self.filesystem_proc.start()
         self.logger.info(f"Started filesystem radio receiver process {self.filesystem_proc.pid}")
 
@@ -359,7 +359,7 @@ class MonitoringRouter:
                  run_id: str,
                  logging_level: int = logging.INFO,
                  atexit_timeout: int = 3    # in seconds
-                ):
+                 ):
         """ Initializes a monitoring configuration class.
 
         Parameters

parsl/monitoring/remote.py

@@ -143,7 +143,7 @@ def send_first_last_message(try_id: int,
             'first_msg': not is_last,
             'last_msg': is_last,
             'timestamp': datetime.datetime.now()
-    })
+            })
     radio.send(msg)
     return