roc-film 1.14.0__py3-none-any.whl → 1.14.2__py3-none-any.whl

roc/film/commands.py

@@ -1142,24 +1142,6 @@ class CdfPostProCommand(Command):
             required=True,
         )
 
-        parser.add_argument(
-            "--rpw-obs-json",
-            help="""
-            List of RPW SoopKitchen export JSON files. Pattern can also be passed.
-            """,
-            type=str,
-            nargs="+",
-        )
-
-        parser.add_argument(
-            "--rpw-ior-xml",
-            help="""
-            List of RPW IOR XML files. Pattern or ZIP archive can be also passed.
-            """,
-            type=str,
-            nargs="+",
-        )
-
         parser.add_argument(
             "--options",
             help=f"""

roc/film/constants.py

@@ -141,7 +141,6 @@ TIMEOUT = 14400
 
 # Allowed values for keyword --options in l1_post_pro command
 CDF_POST_PRO_OPTS_ARGS = [
-    "soop_type",
     "obs_id",
     "resize_wf",
     "update_cdf",

roc/film/descriptor.json

@@ -6,10 +6,10 @@
     "description": "RPW FILe Maker (FILM): Plugin to make RPW L0, L1 and HK data files"
   },
   "release": {
-    "version": "1.14.0",
-    "date": "2024-12-06",
+    "version": "1.14.2",
+    "date": "2025-01-30",
     "author": "Xavier Bonnin <xavier.bonnin@obspm.fr>, ROC Team <roc.support@sympa.obspm.fr>",
-    "modification": "Update python dev deps and README",
+    "modification": "Update cdf_postpro",
     "url": "https://gitlab.obspm.fr/ROC/Pipelines/Plugins/FILM"
   },
   "tasks": [

roc/film/tasks/cdf_postpro.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-"""Module to create the RPW L1 SBM1/SBM2 CDF files."""
+"""Module to perform some post-processing on the RPW CDF files."""
 
 import json
 import os
@@ -22,13 +22,11 @@ from poppy.core.target import FileTarget
 
 from roc.rpl.time import Time
 from roc.dingo.models.data import EventLog
+from roc.dingo.models.packet import TcLog
 from roc.dingo.tools import query_db
 from roc.dingo.constants import PIPELINE_DATABASE
 
 from roc.film import (
-    TIME_JSON_STRFORMAT,
-    TIME_DOY1_STRFORMAT,
-    TIME_DOY2_STRFORMAT,
     INPUT_DATETIME_STRFTIME,
 )
 from roc.film.tools.file_helpers import is_output_dir, get_output_dir
@@ -80,14 +78,6 @@ class CdfPostPro(Task):
             self.pipeline.exit()
             return
 
-        # Get list of RPW Soopkitchen Observations JSON files
-        self.rpw_obs_json_list = glob_list(
-            self.pipeline.get("rpw_obs_json", default=[])
-        )
-
-        # Get list of RPW IOR XML files
-        self.rpw_ior_xml_list = glob_list(self.pipeline.get("rpw_ior_xml", default=[]))
-
         # Get post-processing options
         self.options = [
             opt.lower()
@@ -167,7 +157,6 @@ class CdfPostPro(Task):
         self.session = Connector.manager[PIPELINE_DATABASE].session
 
         # Initialize some class variables
-        self.soop_type_list = []
         self.obs_id_list = []
         self.event_log = None
 
@@ -227,21 +216,16 @@ class CdfPostPro(Task):
                     # Get time range of the input L1 CDF
                     self.epoch = cdf["Epoch"][...]
                     self.nrec = self.epoch.shape[0]
-                    self.time_min = self.epoch[0]
-                    self.time_max = self.epoch[-1]
+                    self.time_min = min(self.epoch)
+                    self.time_max = max(self.epoch)
                     logger.info(
                         f"{self.current_file} has {self.nrec} records "
                         f"between {self.time_min} "
                         f"and {self.time_max}\t[{self.job_id}]"
                     )
 
-                    # Set SOOP_TYPE global attribute from RPW SOOPKitchen
-                    # export observation JSON files
-                    if "soop_type" in self.options:
-                        self._set_soop_type(cdf)
-
-                    # Set OBS_ID global attribute from IOR XML files (get
-                    # observationID)
+                    # Set OBS_ID global attribute
+                    # from unique_id entries in pipeline.tc_log database table
                     if "obs_id" in self.options:
                         self._set_obs_id(cdf)
 
@@ -410,88 +394,6 @@ class CdfPostPro(Task):
 
         return is_succeeded
 
-    def _set_soop_type(self, cdf_obj):
-        """
-        Set input CDF file with expected value for SOOP_TYPE g.attribute.
-
-        :param cdf_obj: CDF to update (passed as a spacepy.pycdf.CDF class instance)
-        :return: True if SOOP_TYPE has been set, False otherwise
-        """
-
-        logger.info(
-            "Setting SOOP_TYPE global attribute "
-            f"in {self.current_file} ...\t[{self.job_id}]"
-        )
-
-        # Get list of SOOP type from RPW soopkitchen observation json files
-        if not self.soop_type_list:
-            logger.info(
-                "Extracting soopType elements from input "
-                f"list of {len(self.rpw_obs_json_list)} RPW SoopKitchen JSON files...\t[{self.job_id}]"
-            )
-            self.soop_type_list = CdfPostPro.get_soop_type(self.rpw_obs_json_list)
-
-        # Only keep list of soop type betwen time_min and time_max
-        soop_type_list = [
-            current_soop_type["soopType"]
-            for current_soop_type in self.soop_type_list
-            if (
-                datetime.strptime(current_soop_type["startDate"], TIME_JSON_STRFORMAT)
-                <= self.time_max
-                and datetime.strptime(current_soop_type["endDate"], TIME_JSON_STRFORMAT)
-                >= self.time_min
-            )
-        ]
-
-        soop_type_len = len(soop_type_list)
-        if soop_type_len == 0:
-            logger.info(
-                "No Soop Type value found "
-                f"between {self.time_min} and {self.time_max}\t[{self.job_id}]"
-            )
-            cdf_obj.attrs["SOOP_TYPE"] = "none"
-            return False
-        else:
-            cdf_obj.attrs["SOOP_TYPE"] = list(set(soop_type_list))
-            logger.debug(f"SOOP_TYPE = {soop_type_list} in {self.current_file}")
-            logger.info(
-                f"{soop_type_len} entries set for "
-                f"SOOP_TYPE in {self.current_file}\t[{self.job_id}]"
-            )
-
-        # make sure to save the change
-        cdf_obj.save()
-
-        return True
-
-    @staticmethod
-    def get_soop_type(rpw_obs_json_list):
-        """
-        Return list of SOOP_TYPE values for a given set of input RPW SoopKitchen observation JSON files
-
-        :param rpw_obs_json_list: List of input RPW SK JSON files
-        :return: list of SOOP_TYPE values found
-        """
-
-        # Define sub-method
-        def extract_soop_type(json_file):
-            """Extract soopType from input JSON"""
-
-            # Open JSON file
-            with open(json_file, "r") as json_buff:
-                data = json.load(json_buff)
-
-            # Retrieve all "soopType" field from file
-            return data["soops"]
-
-        # Initialize output list
-        soop_type_list = []
-
-        for current_json in rpw_obs_json_list:
-            soop_type_list.extend(extract_soop_type(current_json))
-
-        return soop_type_list
-
     def _set_obs_id(self, cdf_obj):
         """
         Set input CDF file with expected value for OBS_ID g.attribute.
@@ -507,19 +409,19 @@ class CdfPostPro(Task):
 
         # Get list of RPW TC obs id values
         if not self.obs_id_list:
-            logger.info(
-                f"Extracting uniqueID elements from "
-                f"input list of {len(self.rpw_ior_xml_list)} RPW IOR files...\t[{self.job_id}]"
+            logger.debug(
+                f"Requesting pipeline.tc_log table entries from database...\t[{self.job_id}]"
             )
-            self.obs_id_list = CdfPostPro.get_ior_obs_id(self.rpw_ior_xml_list)
+            self.obs_id_list = self.get_tc_log_data()
 
         # Keep only obs_id between time_min and time_max
         obs_id_list = list(
             set(
                 [
-                    current_tc[1]
+                    current_tc["unique_id"]
                     for current_tc in self.obs_id_list
-                    if self.time_max >= current_tc[0] >= self.time_min and current_tc[1]
+                    if current_tc["unique_id"]
+                    and self.time_max >= current_tc["utc_time"] >= self.time_min
                 ]
             )
         )
@@ -546,87 +448,22 @@ class CdfPostPro(Task):
 
         return True
 
-    @staticmethod
-    def get_ior_obs_id(rpw_ior_xml_list):
+    def get_tc_log_data(self):
         """
-        Return list of OBS_ID values from
-        an input list of RPW IOR XML files
+        Return list of [unique_id, utc_time] entries from
+        pipeline.tc_log database table.
 
-        :param rpw_ior_xml_list: List of input RPW TC XML files.
-                                 (ZIP files containing IOR XML can be also passed).
-        :return: list of OBS_ID values found
+        :return: tc_log data entries found
         """
-        import zipfile
-
-        # Define sub-method
-        def extract_obs_id(xml):
-            """
-            Extract OBS_ID from input XML
-
-            :param xml: input IOR XML stream
-            :return: List of (time, observationID) values extracted from IOR
-            """
-            import xmltodict
-
-            # Convert input IOR XML stream into dictionary
-            logger.debug(f"Parsing {xml.name} ...")
-            data = xmltodict.parse(xml.read())
 
-            # Extract list of sequences
-            sequence_list = data["planningData"]["commandRequests"]["occurrenceList"][
-                "sequence"
-            ]
-
-            # Make sure that returned sequence_list is a list
-            # (If only one sequence tag is found in the XML
-            # the xml_to_dict method returns a collections.OrderedDict()
-            # instance).
-            if not isinstance(sequence_list, list):
-                sequence_list = [sequence_list]
-
-            # Retrieve all "observationID" field from input TC XML file
-            # Return as a list of tuple (ExecutionTime, observationID)
-            ior_seq_list = []
-            for current_seq in sequence_list:
-                # Make sure to retrieve executionTime with the
-                # right time format (two are possible)
-                for current_strtformat in [TIME_DOY1_STRFORMAT, TIME_DOY2_STRFORMAT]:
-                    current_time = cast_ior_seq_datetime(
-                        current_seq, current_strtformat
-                    )
-                    if current_time is not None:
-                        break
-                current_obsid = current_seq["observationID"]
-
-                ior_seq_list.append((current_time, current_obsid))
-
-            return ior_seq_list
-
-        # Initialize output list
-        obs_id_list = []
-
-        for current_file in rpw_ior_xml_list:
-            if not os.path.basename(current_file).startswith("IOR"):
-                logger.debug(f"{current_file} not a valid RPW IOR file, skip it")
-                continue
-
-            if zipfile.is_zipfile(current_file):
-                with zipfile.ZipFile(current_file, "r") as zip_stream:
-                    for current_xml in zip_stream.namelist():
-                        with zip_stream.open(current_xml, "r") as ior_xml:
-                            if ior_xml.name.startswith("IOR") and ior_xml.name.endswith(
-                                ".SOL"
-                            ):
-                                obs_id_list.extend(extract_obs_id(ior_xml))
-                            else:
-                                logger.debug(
-                                    f"{current_xml} is not a valid RPW IOR XML file, skip it"
-                                )
-            else:
-                with open(current_file, "r") as ior_xml:
-                    obs_id_list.extend(extract_obs_id(ior_xml))
+        tc_log_data = query_db(
+            self.session,
+            [TcLog.unique_id, TcLog.utc_time],
+            filters=(TcLog.tc_exe_state == "PASSED"),
+            to_dict="records",
+        )
 
-        return obs_id_list
+        return tc_log_data
 
     def _update_cdf(self, cdf_obj):
         """
@@ -824,11 +661,11 @@ class CdfPostPro(Task):
                     # Set 7th bit (X000000)
                     bitmask[w] = bitmask[w] | 64
 
-            logger.debug(
-                f"Set {len(w)} QUALITY_BITMASK records for {row['label']} "
-                f"between {row['start_time']} "
-                f"and {row['end_time']}\t[{self.job_id}]"
-            )
+                logger.debug(
+                    f"Set {len(w)} QUALITY_BITMASK records for {row['label']} "
+                    f"between {row['start_time']} "
+                    f"and {row['end_time']}\t[{self.job_id}]"
+                )
 
         # Save quality_bitmask
         cdf_obj["QUALITY_BITMASK"] = bitmask[...]

roc/film/tasks/file_handler.py

@@ -31,10 +31,16 @@ class MoveToProdDir(Task):
         #   the pipeline is still working on it
         #   Add a LockFile class instance to the Task class in Poppy ?
 
+        self.job_uuid = str(uuid.uuid4())
+        self.job_id = self.job_uuid[:8]
+        logger.debug(f"Task {self.job_id} is starting")
+
         # See if --no-move keyword is defined
         no_move = self.pipeline.get("no_move", default=False, args=True)
         if no_move:
-            logger.info('Skip current task "move_to_products_dir": --no-move is True')
+            logger.info(
+                f'--no-move is passed: skip current task "move_to_products_dir"\t[{self.job_id}]'
+            )
             return
 
         # Retrieve pipeline output file directory
@@ -49,7 +55,7 @@ class MoveToProdDir(Task):
 
         if not products_dir:
             logger.info(
-                'Skip current task "move_to_products_dir": products_dir argument not defined'
+                f'products_dir argument not defined: Skip current task "move_to_products_dir"\t[{self.job_id}]'
             )
         else:
             output_dirbasename = os.path.basename(output_dir)
@@ -58,6 +64,8 @@ class MoveToProdDir(Task):
             if safe_move(output_dir, target_dir, ignore_patterns=ignore_patterns):
                 logger.info(f"{output_dir} moved into {products_dir}")
 
+        logger.debug(f"Task {self.job_id} completed")
+
 
 class MoveFailedFiles(Task):
     """Move any failed files found
@@ -81,7 +89,7 @@ class MoveFailedFiles(Task):
         # Define task job ID (long and short)
         self.job_uuid = str(uuid.uuid4())
         self.job_id = self.job_uuid[:8]
-        logger.info(f"Task {self.job_id} is starting")
+        logger.debug(f"Task {self.job_id} is starting")
         try:
             self.setup_inputs()
         except Exception:
@@ -90,7 +98,7 @@ class MoveFailedFiles(Task):
             return
 
         if self.failed_file_count == 0:
-            logger.debug("No failed file(s) to move")
+            logger.debug("No failed file(s) to move\t[{self.job_id}")
         else:
             # Loop over failed files list
             for i, failed_file in enumerate(self.failed_file_list):
@@ -113,7 +121,11 @@ class MoveFailedFiles(Task):
                     # perform a safe move (i.e., copy, check and delete) into
                     # failed dir
                     if safe_move(failed_file, target_filepath):
-                        logger.info(f"{failed_file} moved into {failed_dir}")
+                        logger.warning(
+                            f"{failed_file} moved into {failed_dir}\t[{self.job_id}]"
+                        )
+
+        logger.debug(f"Task {self.job_id} completed")
 
 
 class CopyProcessedDds(Task):
@@ -125,6 +137,11 @@ class CopyProcessedDds(Task):
     name = "copy_processed_dds"
 
     def run(self):
+        # Define task job ID (long and short)
+        self.job_uuid = str(uuid.uuid4())
+        self.job_id = self.job_uuid[:8]
+        logger.debug(f"Task {self.job_id} is starting")
+
         # Get processed file target directory
         processed_dir = self.pipeline.get(
             "processed_dds_dir", default=[None], args=True
@@ -133,14 +150,14 @@ class CopyProcessedDds(Task):
         # skip task if processed_dir is None
         if processed_dir is None:
             logger.info(
-                "Skip task copy_processed_dds: No processed_dds_dir argument defined"
+                f"No processed_dds_dir argument defined: skip task copy_processed_dds\t[{self.job_id}]"
             )
             return
         elif not os.path.isdir(processed_dir):
-            logger.debug(f"Creating {processed_dir}...")
+            logger.debug(f"Creating {processed_dir}...\t[{self.job_id}]")
             os.makedirs(processed_dir)
         else:
-            logger.debug(f"process_dir set to {processed_dir}")
+            logger.debug(f"process_dir set to {processed_dir}\t[{self.job_id}]")
 
         # If processed_files list not defined in the pipeline properties,
         # initialize it
@@ -148,7 +165,9 @@ class CopyProcessedDds(Task):
         processed_files_count = len(processed_file_list)
         # Skip task if no processed files
         if processed_files_count == 0:
-            logger.info("Skip task copy_processed_dds: No processed file to move")
+            logger.info(
+                f"No processed file to move: skip task copy_processed_dds\t[{self.job_id}]"
+            )
             return
 
         # Get clear-dds keyword
@@ -161,7 +180,9 @@ class CopyProcessedDds(Task):
         for processed_file in processed_file_list.copy():
             # Check first that processed file is not in failed list
             if processed_file in failed_file_list:
-                logger.warning(f"{processed_file} found in the failed file list!")
+                logger.warning(
+                    f"{processed_file} found in the failed file list!\t[{self.job_id}]"
+                )
                 continue
 
             # Build target filepath
@@ -169,16 +190,20 @@ class CopyProcessedDds(Task):
             target_filepath = os.path.join(processed_dir, basename)
 
             # copy file
-            logger.debug(f"Copying {processed_file} into {processed_dir}")
+            logger.debug(
+                f"Copying {processed_file} into {processed_dir}\t[{self.job_id}]"
+            )
             try:
                 shutil.copyfile(processed_file, target_filepath)
             except Exception as e:
                 logger.exception(
-                    f"Copying {processed_file} into {processed_dir} has failed!"
+                    f"Copying {processed_file} into {processed_dir} has failed!\t[{self.job_id}]"
                 )
                 logger.debug(e)
             else:
-                logger.info(f"{processed_file} copied into {target_filepath}")
+                logger.info(
+                    f"{processed_file} copied into {target_filepath}\t[{self.job_id}]"
+                )
 
             # Remove current file from the list in pipeline properties
             processed_file_list.remove(processed_file)
@@ -186,7 +211,7 @@ class CopyProcessedDds(Task):
             # if clear-dds keyword is passed, then remove processed Dds
             if clear_dds:
                 os.remove(processed_file)
-                logger.debug(f"{processed_file} deleted")
+                logger.debug(f"{processed_file} deleted\t[{self.job_id}]")
 
 
 class CopyFailedDds(Task):
@@ -198,17 +223,24 @@ class CopyFailedDds(Task):
     name = "copy_failed_dds"
 
     def run(self):
+        # Define task job ID (long and short)
+        self.job_uuid = str(uuid.uuid4())
+        self.job_id = self.job_uuid[:8]
+        logger.debug(f"Task {self.job_id} is starting")
+
         # Get failed file target directory
         failed_dir = self.pipeline.get("failed_dds_dir", default=[None], args=True)[0]
         # skip task if failed_dir is None
         if failed_dir is None:
-            logger.info("Skip task copy_failed_dds: No failed_dds_dir argument defined")
+            logger.info(
+                f"No failed_dds_dir argument defined: skip task copy_failed_dds\t[{self.job_id}]"
+            )
             return
         elif not os.path.isdir(failed_dir):
-            logger.debug(f"Creating {failed_dir}...")
+            logger.debug(f"Creating {failed_dir}...\t[{self.job_id}]")
             os.makedirs(failed_dir)
         else:
-            logger.debug(f"failed_dir set to {failed_dir}")
+            logger.debug(f"failed_dir set to {failed_dir}\t[{self.job_id}]")
 
         # If failed_files list not defined in the pipeline properties,
         # initialize it
@@ -216,7 +248,9 @@ class CopyFailedDds(Task):
         failed_files_count = len(failed_file_list)
         # Skip task if no failed dds files
         if failed_files_count == 0:
-            logger.info("Skip task copy_failed_dds: No failed file to move")
+            logger.info(
+                f"No failed file to move: skip task copy_failed_dds\t[{self.job_id}]"
+            )
             return
 
         # Get clear-dds keyword
@@ -229,14 +263,18 @@ class CopyFailedDds(Task):
             target_filepath = os.path.join(failed_dir, basename)
 
             # copy file
-            logger.debug(f"Copying {failed_file} into {failed_dir}")
+            logger.debug(f"Copying {failed_file} into {failed_dir}\t[{self.job_id}]")
             try:
                 shutil.copyfile(failed_file, target_filepath)
             except Exception as e:
-                logger.exception(f"Copying {failed_file} into {failed_dir} has failed!")
+                logger.exception(
+                    f"Copying {failed_file} into {failed_dir} has failed!\t[{self.job_id}]"
+                )
                 logger.debug(e)
             else:
-                logger.info(f"{failed_file} copied into {target_filepath}")
+                logger.info(
+                    f"{failed_file} copied into {target_filepath}\t[{self.job_id}]"
+                )
 
             # Remove current file from the list in pipeline properties
             failed_file_list.remove(failed_file)
@@ -244,14 +282,14 @@ class CopyFailedDds(Task):
             # if clear-dds keyword is passed, then remove processed Dds
             if clear_dds:
                 os.remove(failed_file)
-                logger.debug(f"{failed_file} deleted")
+                logger.debug(f"{failed_file} deleted\t[{self.job_id}]")
 
         # Get failed tmraw list
         failed_tmraw_list = self.pipeline.get("failed_tmraw", default=[])
         failed_tmraw_count = len(failed_tmraw_list)
         # Skip task if no failed tmraw
         if failed_tmraw_count == 0:
-            logger.debug("No failed tmraw to write")
+            logger.debug("No failed tmraw to write\t[{self.job_id}]")
             return
         else:
             # Else save list of failed tmraw into text file
@@ -260,5 +298,5 @@ class CopyFailedDds(Task):
                 fw.writelines(failed_tmraw_list)
             logger.info(
                 f"{failed_tmraw_count} failed TmRaw entries "
-                f"saved into {tmraw_failed_file}"
+                f"saved into {tmraw_failed_file}\t[{self.job_id}]"
             )

roc/film/tasks/l0_to_hk.py

@@ -57,7 +57,7 @@ def L0ToHk(task):
 
     # Define task job ID (long and short)
     job_uuid = str(uuid.uuid4())
-    job_id = f"L0ToHk-{job_uuid[:8]}"
+    job_id = f"{job_uuid[:8]}"
     logger.info(f"Task {job_id} is starting")
 
     try:

roc/film/tasks/l0_to_l1_bia_current.py

@@ -4,6 +4,7 @@
 """Contains task to create the RPW L1 Bias current CDF files."""
 
 import os
+import uuid
 
 from poppy.core.logger import logger
 from poppy.core.target import FileTarget
@@ -31,6 +32,11 @@ def L0ToL1BiaCurrent(task):
     :return:
     """
 
+    # Define task job ID (long and short)
+    job_uuid = str(uuid.uuid4())
+    task.job_id = f"{job_uuid[:8]}"
+    logger.info(f"Task {task.job_id} is starting")
+
     # Get list of input l0 file(s)
     l0_file_list = task.inputs["l0_file"].filepath
 

roc/film/tools/file_helpers.py

@@ -572,19 +572,28 @@ def l0_to_trange_cdf(
     l0_file_len = len(l0_file_list)
 
     # Get L0 files time_min/time_max
-    l0_time_min, l0_time_max = get_l0_trange(l0_file_list)
+    try:
+        l0_time_min, l0_time_max = get_l0_trange(l0_file_list)
+        if None in l0_time_min or None in l0_time_max:
+            raise ValueError
+    except TypeError:
+        logger.error(f'Input "l0_files" must be a list!\t[{task.job_id}]')
+        return []
+    except ValueError:
+        logger.error(f"Output L0 time min. or max. list is not valid!\t[{task.job_id}]")
+        return []
 
     # Get start_time for output CDF (use time min of L0 files if not defined)
     if not start_time:
         start_time = task.pipeline.get("start_time", default=[min(l0_time_min)])[0]
 
-    logger.debug(f"start_time value is {start_time}    [{task.job_id}]")
+    logger.debug(f"start_time value is {start_time}\t[{task.job_id}]")
 
     # Get end_time for output CDF (use time max of L0 files if not defined)
     if not end_time:
         end_time = task.pipeline.get("end_time", default=[max(l0_time_max)])[0]
 
-    logger.debug(f"end_time value is {end_time}    [{task.job_id}]")
+    logger.debug(f"end_time value is {end_time}\t[{task.job_id}]")
 
     # Loops over each output dataset to produce for the current task
     for current_dataset in dataset_list:
@@ -594,7 +603,7 @@ def l0_to_trange_cdf(
 
         logger.debug(
             "Running file production for the dataset "
-            f"{dataset_name} (V{data_version})    [{task.job_id}]"
+            f"{dataset_name} (V{data_version})\t[{task.job_id}]"
         )
 
         # get the path to the master CDF file of this dataset
@@ -612,14 +621,14 @@ def l0_to_trange_cdf(
         # Check existence
         if not master_path:
             raise FileNotFoundError(
-                "{0} master CDF not found for the dataset {1}!    [{2}]".format(
+                "{0} master CDF not found for the dataset {1}!\t[{2}]".format(
                     master_pattern, dataset_name, task.job_id
                 )
             )
         else:
             master_path = sorted(master_path)[-1]
             logger.info(
-                'Producing dataset "{0}" with the master CDF "{1}"    [{2}]'.format(
+                'Producing dataset "{0}" with the master CDF "{1}"\t[{2}]'.format(
                     dataset_name, master_path, task.job_id
                 )
             )
@@ -635,12 +644,12 @@ def l0_to_trange_cdf(
                 if l0_time_max[i] < start_time or l0_time_min[i] > end_time:
                     logger.debug(
                         f"{l0_file} is outside the time range: "
-                        f"[{start_time}, {end_time}], skip it    [{task.job_id}]"
+                        f"[{start_time}, {end_time}], skip it\t[{task.job_id}]"
                     )
                     continue
                 else:
                     logger.debug(
-                        f"Processing {l0_file} [{l0_file_len - i - 1}]    [{task.job_id}]"
+                        f"Processing {l0_file} [{l0_file_len - i - 1}]\t[{task.job_id}]"
                     )
 
                 # Append current l0 file to parent list
@@ -655,7 +664,7 @@ def l0_to_trange_cdf(
                 ):
                     logger.info(
                         f"No expected packet found for {dataset_name}"
-                        f" in {l0_file} [{','.join(expected_packet)}]    [{task.job_id}]"
+                        f" in {l0_file} [{','.join(expected_packet)}]\t[{task.job_id}]"
                     )
                     continue
 
@@ -664,18 +673,20 @@ def l0_to_trange_cdf(
                 # as the dataset alias in the descriptor
                 func = dataset_func.get(dataset_name)
                 if func is None:
-                    logger.error(f"No function found for {dataset_name}")
+                    logger.error(
+                        f"No function found for {dataset_name}\t[{task.job_id}]"
+                    )
                     failed_files.append(l0_file)
                     break
 
                 # call the dataset-related function
                 try:
-                    logger.debug(f"Running {func}    [{task.job_id}]")
+                    logger.debug(f"Running {func}\t[{task.job_id}]")
                     result = func(l0, task)
                 except Exception as e:
                     # TODO catch exception in the ROC database
                     logger.exception(
-                        f'Running "{func}" function has failed    [{task.job_id}]: \n{e}'
+                        f'Running "{func}" function has failed\t[{task.job_id}]: \n{e}'
                     )
                     # TODO - Add the current failed dataset processing to failed_files
                     failed_files.append(l0_file)
@@ -685,12 +696,12 @@ def l0_to_trange_cdf(
                 if result is None or result.shape[0] == 0:
                     logger.debug(
                         f"Returned {dataset_name} dataset array"
-                        f" is empty for {l0_file}    [{task.job_id}]"
+                        f" is empty for {l0_file}\t[{task.job_id}]"
                     )
                 else:
                     logger.debug(
                         f"{result.shape[0]} {dataset_name} dataset samples"
-                        f" returned from {l0_file}    [{task.job_id}]"
+                        f" returned from {l0_file}\t[{task.job_id}]"
                     )
 
                     # If data is empty
@@ -706,7 +717,7 @@ def l0_to_trange_cdf(
         if nrec == 0:
             logger.warning(
                 "No data for dataset"
-                f" {dataset_name}: skip output cdf creation    [{task.job_id}]"
+                f" {dataset_name}: skip output cdf creation\t[{task.job_id}]"
             )
             continue
 
@@ -716,12 +727,12 @@ def l0_to_trange_cdf(
         # Generation date
         generation_date = datetime.utcnow().strftime(INPUT_DATETIME_STRFTIME)
         logger.debug(
-            f'Set "Generation_date" attr. value to {generation_date}    [{task.job_id}]'
+            f'Set "Generation_date" attr. value to {generation_date}\t[{task.job_id}]'
         )
 
         # file ID
         file_id = str(uuid.uuid4())
-        logger.debug(f'Set "File_ID" attr. value to {file_id}    [{task.job_id}]')
+        logger.debug(f'Set "File_ID" attr. value to {file_id}\t[{task.job_id}]')
 
         # Re-define datetime and parents g.attribute for time range CDF data
         # products
@@ -781,7 +792,7 @@ def l0_to_trange_cdf(
             metadata["SPICE_KERNELS"] = sclk_file[-1]
         else:
             logger.warning(
-                f"No SPICE SCLK kernel saved for {filepath}    [{task.job_id}]"
+                f"No SPICE SCLK kernel saved for {filepath}\t[{task.job_id}]"
             )
 
         # open the target to update its status according to errors etc
@@ -808,27 +819,27 @@ def l0_to_trange_cdf(
                     else:
                         logger.warning(
                             f"No data found between {start_time} and {end_time}"
-                            f" to be written into {filepath}    [{task.job_id}]"
+                            f" to be written into {filepath}\t[{task.job_id}]"
                         )
 
                 except Exception as e:
                     logger.exception(
-                        f"{filepath} production has failed    [{task.job_id}]:\n{e}"
+                        f"{filepath} production has failed\t[{task.job_id}]:\n{e}"
                     )
                     cdf.attrs["Validate"] = "-1"
                     failed_files.append(filepath)
 
             if nrec == 0:
-                logger.info(f"Removing empty file {filepath}...    [{task.job_id}]")
+                logger.info(f"Removing empty file {filepath}...\t[{task.job_id}]")
                 os.remove(filepath)
                 filepath = ""
             elif os.path.isfile(filepath):
                 processed_files.append(filepath)
-                logger.info(f"{filepath} saved    [{task.job_id}]")
+                logger.info(f"{filepath} saved\t[{task.job_id}]")
                 output_file_list.append(filepath)
             else:
                 failed_files.append(filepath)
-                logger.error(f"Writing {filepath} has failed!    [{task.job_id}]")
+                logger.error(f"Writing {filepath} has failed!\t[{task.job_id}]")
 
             # Set output target filepath
             target.filepath = filepath
@@ -849,8 +860,7 @@ def get_l0_trange(l0_files: list, minmax: bool = False) -> tuple:
     """
 
     if not isinstance(l0_files, list):
-        logger.error('Input "l0_files" must be a list!')
-        return None, None
+        raise TypeError
 
     # Get number of l0_files
     nl0 = len(l0_files)

{roc_film-1.14.0.dist-info → roc_film-1.14.2.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.3
 Name: roc-film
-Version: 1.14.0
+Version: 1.14.2
 Summary: RPW FILe Maker (FILM): Plugin to make RPW L0, L1 and HK data files
-License: CeCILL
+License: CECILL-2.1
 Author: Xavier Bonnin
 Author-email: xavier.bonnin@obspm.fr
 Requires-Python: >=3.9,<4
-Classifier: License :: Other/Proprietary License
+Classifier: License :: OSI Approved :: CEA CNRS Inria Logiciel Libre License, version 2.1 (CeCILL-2.1)
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10

{roc_film-1.14.0.dist-info → roc_film-1.14.2.dist-info}/RECORD

@@ -1,20 +1,20 @@
 roc/__init__.py,sha256=0LOVV4ExL9DrAzmNJj6c6395-nQTPM6v6S1hJnBAf3E,89
 roc/film/__init__.py,sha256=XBPsnRsgcUjJnutv_tkgNViw2TqnA5ozO-bNO2HY-mg,143
-roc/film/commands.py,sha256=kxc2z2qxyLpXG1oxiGYC7cHISMzrbgw0mklIvOAww0o,37489
+roc/film/commands.py,sha256=xzyARalgWc6mPfN5nUvDtqTzaovP2_Xbi6wCDsS4tVY,37019
 roc/film/config/__init__.py,sha256=Yh8cG85CwN7OIAndtBs213LZn5NwEjPjFYKpMnagJuc,68
-roc/film/constants.py,sha256=0qQ3DvJ87gW3IvyfJe_qfvsodMaJbxn6om6ImGXihRI,4015
-roc/film/descriptor.json,sha256=t3WSiLgqH6ykAm8RvrWJ-4gCtwJsHkCFFf69lYSFjgQ,33501
+roc/film/constants.py,sha256=zibC4vjLfg3fpH3BP7AGW4j48vf-AaXn--Afx5gmGH4,3998
+roc/film/descriptor.json,sha256=3Hft4Up8MzSpNy6H11br6BV5VfMAKxhmjbrR1g_-_uw,33486
 roc/film/exceptions.py,sha256=kGWP9VR_DjDdyZYC5gDixtvV7xAv7qEx5srzS4_8TlU,5177
 roc/film/tasks/__init__.py,sha256=GNuQAi7E9nOApSSUUg4DEKlY0OlOzVaJexFKK0h9A2c,961
 roc/film/tasks/cat_solo_hk.py,sha256=PX3HkyJCgFHrw_wwa44r_tWcXQ7jCbd6oiZGS8KRXfI,11227
-roc/film/tasks/cdf_postpro.py,sha256=atGaJgg__QLJF3ZIEeZtYStuJDK7JmoR67FJ21bUNFg,31606
+roc/film/tasks/cdf_postpro.py,sha256=eqw_80t03jeiw7MNZFWclvkQAm_1GndwFRtm5_1tjIg,25309
 roc/film/tasks/check_dds.py,sha256=pb0YZGu_cqPL2-Vi5aUaXAFJy86R2rOLVVaXnTLArug,3734
 roc/film/tasks/db_to_anc_bia_sweep_table.py,sha256=o-rJpj1VzS9azAT_EiWL9fxaZQt2qaArKtGiLMHv3S4,12781
 roc/film/tasks/dds_to_l0.py,sha256=nhsBESTlkEqiKAVVKek2oXe5neLFet1nTVsTiGTm1zY,22120
 roc/film/tasks/export_solo_coord.py,sha256=iuUfyQo3-vkdEdDsp2ZscFxsDVvdZJXxF0K-5IRQitw,5753
-roc/film/tasks/file_handler.py,sha256=jCEfM5YHdcG_vHsPB_VbmJ0f4oDkIZ4SCihwwT6T_k4,9739
-roc/film/tasks/l0_to_hk.py,sha256=95tWZUhW5FUzyeArAY7BmgPO61BkTDSfwv8LBjAMjgM,11008
-roc/film/tasks/l0_to_l1_bia_current.py,sha256=w4KrldizPbKB5M1E7uA5oYd6fd7mO5V8IwSEKD5DddU,2389
+roc/film/tasks/file_handler.py,sha256=elJmRBeMLRhXtvf_YvuBuIa7Wn_JffFV_zLQYRWzqO0,11116
+roc/film/tasks/l0_to_hk.py,sha256=bn9hYHmxGJWBuj_uYovkI9lnonQeplsr4_apxkK1YuA,11001
+roc/film/tasks/l0_to_l1_bia_current.py,sha256=GS6GvukagltY1CUW__b2CX-nBAYjOxxaatfppP5gmVg,2564
 roc/film/tasks/l0_to_l1_bia_sweep.py,sha256=VYjD_ml2M0K7WA7I4UKsmrm4cvxArYRBazmzuNs7_vs,34980
 roc/film/tasks/l0_to_l1_sbm.py,sha256=OjgMdCk7ldhs4mTlAxLVER_Cud6ILlBkW88a7P46ZSI,19219
 roc/film/tasks/l0_to_l1_surv.py,sha256=-n78s2r9aEAGw5U0LRd7NyiwdEehHufg5K4lEY4vR-k,15522
@@ -38,13 +38,13 @@ roc/film/tests/test_metadata.py,sha256=1nl5or5RPMsIgMqtvYz28qdZXVgjYw6olphMm6y8W
 roc/film/tests/tests.py,sha256=boEPC42mZYQfinYE3jyol-7O34ttU5p_Ei0a_9YUHM4,44273
 roc/film/tools/__init__.py,sha256=dkYmLgy3b_B1T3ZZ6s_rv7NyDjLF0yOJPerjLEKAFlA,303
 roc/film/tools/dataset_tasks.py,sha256=CI9UIYchLwXfcjJoD8PsaFIcNX8akAsXz4RQ4hqhJeU,2825
-roc/film/tools/file_helpers.py,sha256=RKPu2nkGPkNOQUvARGhrwPULfuaVKs8UGAH9DANLToU,30679
+roc/film/tools/file_helpers.py,sha256=KtcQxwIBfawj6HnrmvV91YjdvXm4tRfKG4ORVOhccds,30983
 roc/film/tools/l0.py,sha256=a5xxk3BYxtwOeZp36AoDPtF07VZpXfyKrpIYcC83u6w,46657
 roc/film/tools/metadata.py,sha256=gYFoo_VinBFoJOVIBwDfSqq0WvYTdDaS3NjEDtYREUM,12409
 roc/film/tools/skeleton.py,sha256=aTe6VWvy5Y79FuA3aKieTQ91m26PEvJ3MnzC4ZZqMvc,10765
 roc/film/tools/tools.py,sha256=q2eN494T8irkNUn0d6_oQs2W_ZJj1OxJu_ViORGOa3g,17945
 roc/film/tools/xlsx2skt.py,sha256=sHmFLGuL1pT1N4V4Nk8i7yoHM2lveXphuvUUN28MvJs,19599
-roc_film-1.14.0.dist-info/LICENSE,sha256=TqI0k3vHsKpSR-Q2aQ0euTJIdbx1kOzeUL79OONRkKU,21778
-roc_film-1.14.0.dist-info/METADATA,sha256=pSz1BvelqyQQMh6YhuD0dxuQydGB2oMLLZtydGKTfpA,1747
-roc_film-1.14.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-roc_film-1.14.0.dist-info/RECORD,,
+roc_film-1.14.2.dist-info/LICENSE,sha256=TqI0k3vHsKpSR-Q2aQ0euTJIdbx1kOzeUL79OONRkKU,21778
+roc_film-1.14.2.dist-info/METADATA,sha256=9Y6VcPHLBQT674Wf85XWF9vNiqTuqcyZKEcwvqdwzdM,1805
+roc_film-1.14.2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+roc_film-1.14.2.dist-info/RECORD,,