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

roc/film/tools/xlsx2skt.py

@@ -18,7 +18,6 @@ from openpyxl import load_workbook
 from collections import OrderedDict
 
 
-
 # ________________ HEADER _________________________
 
 # Mandatory
@@ -40,30 +39,43 @@ CURRENT_DATETIME = datetime.now()
 ROW_LENGTH_MAX = 79
 DEF_INDENT = " " * 16
 
-SHEET_NAMES = ["header", "GLOBALattributes",
-               "zVariables", "VARIABLEattributes", "Options", "NRV"]
+SHEET_NAMES = [
+    "header",
+    "GLOBALattributes",
+    "zVariables",
+    "VARIABLEattributes",
+    "Options",
+    "NRV",
+]
 
 CDF_OPTION_NAMES = ["CDF_COMPRESSION", "CDF_CHECKSUM"]
-VAR_OPTION_NAMES = ["VAR_COMPRESSION",
-                    "VAR_SPARSERECORDS",
-                    "VAR_PADVALUE"]
-
-HEADER_BOARD = "! Variables     G.Attributes     " + \
-    "V.Attributes     Records     Dims     Sizes\n"
-HEADER_BOARD += "! ---------     ------------     " + \
-    "------------     -------     ----     -----"
+VAR_OPTION_NAMES = ["VAR_COMPRESSION", "VAR_SPARSERECORDS", "VAR_PADVALUE"]
+
+HEADER_BOARD = (
+    "! Variables     G.Attributes     "
+    + "V.Attributes     Records     Dims     Sizes\n"
+)
+HEADER_BOARD += (
+    "! ---------     ------------     " + "------------     -------     ----     -----"
+)
 HEADER_SPACE = DEF_INDENT
 
 GLOBAL_BOARD = "! Attribute    Entry        Data\n"
 GLOBAL_BOARD += "! Name        Number       Type        Value\n"
 GLOBAL_BOARD += "! ---------    ------       ----       -----"
 
-VARIABLE_BOAD = "! Variable      Data      Number " + \
-    "                                Record        Dimension\n"
-VARIABLE_BOAD += "! Name          Type      Elements" + \
-    "   Dims    Sizes    Variance     Variances\n"
-VARIABLE_BOAD += "! --------           ----          --------   " + \
-    "       ----        -----        --------           ---------"
+VARIABLE_BOAD = (
+    "! Variable      Data      Number "
+    + "                                Record        Dimension\n"
+)
+VARIABLE_BOAD += (
+    "! Name          Type      Elements"
+    + "   Dims    Sizes    Variance     Variances\n"
+)
+VARIABLE_BOAD += (
+    "! --------           ----          --------   "
+    + "       ----        -----        --------           ---------"
+)
 
 VATTRS_BOARD = "  ! Attribute    Data\n"
 VATTRS_BOARD += "  ! Name        Type   Value\n"
@@ -73,22 +85,19 @@ VATTRS_BOARD += "  ! --------         ----       -----"
 # ________________ Class Definition __________
 # (If required, define here classes)
 class Xlsx2Skt:
-
-    """ Class to transform a formatted Excel file into a CDF skeleton table"""
+    """Class to transform a formatted Excel file into a CDF skeleton table"""
 
     def __init__(self, **kwargs):
-
-        self.xlsx = kwargs.pop('xlsx_file')
-        self.skt = kwargs.pop('skt_file')
-        self.overwrite = kwargs.pop('Overwrite')
-        self.verbose = kwargs.pop('Verbose')
-        self.ignore = kwargs.pop('Ignore_none')
-        self.auto_pad = kwargs.pop('Auto_pad')
+        self.xlsx = kwargs.pop("xlsx_file")
+        self.skt = kwargs.pop("skt_file")
+        self.overwrite = kwargs.pop("Overwrite")
+        self.verbose = kwargs.pop("Verbose")
+        self.ignore = kwargs.pop("Ignore_none")
+        self.auto_pad = kwargs.pop("Auto_pad")
 
         self.cdf_items = {}
 
     def parse_xlsx(self):
-
         """Parse the Excel 2007 format file"""
 
         xlsx = self.xlsx
@@ -112,8 +121,7 @@ class Xlsx2Skt:
             if self.verbose:
                 logger.info("Loading %s sheet..." % (shtn))
             if shtn not in sheet_names:
-                sys.exit("ERROR: Missing %s sheet in the input Excel file!"
-                         % (shtn))
+                sys.exit("ERROR: Missing %s sheet in the input Excel file!" % (shtn))
             else:
                 wksht = wkbk[shtn]
 
@@ -131,15 +139,15 @@ class Xlsx2Skt:
 
                 sheets[shtn] = sheet_data
 
-        self.cdf_items["GLOBALattributes"] = \
-            uniq(sheets["GLOBALattributes"]["Attribute Name"],
-                 not_none=True)
-        self.cdf_items["VARIABLEattributes"] = \
-            uniq(sheets["VARIABLEattributes"]["Attribute Name"],
-                 not_none=True)
-        self.cdf_items["zVariables"] = \
-            uniq(sheets["zVariables"]["Variable Name"],
-                 not_none=True)
+        self.cdf_items["GLOBALattributes"] = uniq(
+            sheets["GLOBALattributes"]["Attribute Name"], not_none=True
+        )
+        self.cdf_items["VARIABLEattributes"] = uniq(
+            sheets["VARIABLEattributes"]["Attribute Name"], not_none=True
+        )
+        self.cdf_items["zVariables"] = uniq(
+            sheets["zVariables"]["Variable Name"], not_none=True
+        )
         if self.verbose:
             self._display()
 
@@ -147,23 +155,15 @@ class Xlsx2Skt:
 
     def _display(self):
         logger.info(
-            "%i GLOBAL attributes returned" % (
-                len(self.cdf_items["GLOBALattributes"])
-            )
+            "%i GLOBAL attributes returned" % (len(self.cdf_items["GLOBALattributes"]))
         )
         logger.info(
-            "%i Variable attributes returned" % (
-                len(self.cdf_items["VARIABLEattributes"])
-            )
-        )
-        logger.info(
-            "%i zVariables returned" % (
-                len(self.cdf_items["zVariables"])
-            )
+            "%i Variable attributes returned"
+            % (len(self.cdf_items["VARIABLEattributes"]))
         )
+        logger.info("%i zVariables returned" % (len(self.cdf_items["zVariables"])))
 
     def build_skt(self, xlsx_sheets):
-
         """Build the CDF skeleton table content using the Excel data"""
 
         if self.verbose:
@@ -172,40 +172,50 @@ class Xlsx2Skt:
         skt_name = os.path.splitext(os.path.basename(self.skt))[0]
         xlsx_name = os.path.basename(self.xlsx)
 
-        file_header = "!Skeleton table for the \"" + skt_name + "\" CDF.\n"
-        file_header += "!Generated: " + \
-            CURRENT_DATETIME.strftime("%Y-%m-%d %H:%M:%S") + "\n"
-        file_header += "!Skeleton table created by xlsx2skt.py V" + \
-            __version__ + "\n"
+        file_header = '!Skeleton table for the "' + skt_name + '" CDF.\n'
+        file_header += (
+            "!Generated: " + CURRENT_DATETIME.strftime("%Y-%m-%d %H:%M:%S") + "\n"
+        )
+        file_header += "!Skeleton table created by xlsx2skt.py V" + __version__ + "\n"
         file_header += "!Skeleton table created from " + xlsx_name + "\n"
 
-        skt_header = self.build_header(xlsx_sheets["header"],
-                                       xlsx_sheets["Options"])
+        skt_header = self.build_header(xlsx_sheets["header"], xlsx_sheets["Options"])
         skt_global = self.build_global(xlsx_sheets["GLOBALattributes"])
         skt_vattrs = self.build_vattributes()
-        skt_zvars = self.build_zvariables(xlsx_sheets["zVariables"],
-                                          xlsx_sheets["VARIABLEattributes"],
-                                          xlsx_sheets["Options"],
-                                          xlsx_sheets["NRV"],
-                                          ignore_none=self.ignore,
-                                          auto_pad=self.auto_pad)
+        skt_zvars = self.build_zvariables(
+            xlsx_sheets["zVariables"],
+            xlsx_sheets["VARIABLEattributes"],
+            xlsx_sheets["Options"],
+            xlsx_sheets["NRV"],
+            ignore_none=self.ignore,
+            auto_pad=self.auto_pad,
+        )
 
-        skt_body = "\n".join([file_header, "", skt_header, "",
-                              skt_global, "", skt_vattrs, "",
-                              skt_zvars, "", "#end"])
+        skt_body = "\n".join(
+            [
+                file_header,
+                "",
+                skt_header,
+                "",
+                skt_global,
+                "",
+                skt_vattrs,
+                "",
+                skt_zvars,
+                "",
+                "#end",
+            ]
+        )
 
         return skt_body
 
     def write_skt(self, skt_body):
-
         """Write the CDF skeleton table file"""
 
         skt = self.skt
 
         if os.path.splitext(skt)[1] != ".skt":
-            logger.warning(
-                ".skt extension will be automatically appended to %s" % skt
-            )
+            logger.warning(".skt extension will be automatically appended to %s" % skt)
             skt = skt + ".skt"
 
         if not (self.overwrite) and (os.path.isfile(skt)):
@@ -225,7 +235,6 @@ class Xlsx2Skt:
             return None
 
     def run(self):
-
         """Run the complete xlsx to skt conversion process"""
 
         xlsx_sheets = self.parse_xlsx()
@@ -239,7 +248,6 @@ class Xlsx2Skt:
             return False
 
     def build_header(self, header_sheet, options_sheet):
-
         """Build the CDF skeleton table header part"""
 
         if self.verbose:
@@ -257,16 +265,20 @@ class Xlsx2Skt:
         nvattr = len(self.cdf_items["VARIABLEattributes"])
         nvar = len(self.cdf_items["zVariables"])
 
-        header_board_info = ["    0/" + str(nvar),
-                             str(nglobal), str(nvattr), "0/z", "0"]
+        header_board_info = [
+            "    0/" + str(nvar),
+            str(nglobal),
+            str(nvattr),
+            "0/z",
+            "0",
+        ]
         header_board_info = "            ".join(header_board_info)
         header_body.append(header_board_info)
 
         header_opt_info = "\n"
         for opt in CDF_OPTION_NAMES:
             if opt in options_sheet:
-                header_opt_info += "!" + opt + ": " + \
-                    options_sheet[opt][0] + "\n"
+                header_opt_info += "!" + opt + ": " + options_sheet[opt][0] + "\n"
         header_body.append(header_opt_info)
 
         header_body = "\n".join(header_body)
@@ -277,7 +289,6 @@ class Xlsx2Skt:
         return header_body
 
     def build_global(self, global_sheet):
-
         """Build the CDF skeleton table GLOBALattributes part"""
 
         if self.verbose:
@@ -295,7 +306,6 @@ class Xlsx2Skt:
         nindent = DEF_INDENT
         new_entry = ""
         for i, attr in enumerate(global_sheet["Attribute Name"]):
-
             if attr is None:
                 continue
 
@@ -317,17 +327,18 @@ class Xlsx2Skt:
 
             new_entry += enum_i + ":  " + dtype_i + "    { "
 
-            value_i = truncate_str(value_i,
-                                   int(ROW_LENGTH_MAX / 3),
-                                   gap=(" " * (len(new_entry) + 12)),
-                                   min_length=6)
+            value_i = truncate_str(
+                value_i,
+                int(ROW_LENGTH_MAX / 3),
+                gap=(" " * (len(new_entry) + 12)),
+                min_length=6,
+            )
 
             new_entry += quote(value_i) + " }"
 
             if len(new_entry) > ROW_LENGTH_MAX and int(enum_i) == 1:
                 nindent = len(attr)
-                new_entry = insert_char(new_entry, "\n" + " " * nindent,
-                                        nindent + 4)
+                new_entry = insert_char(new_entry, "\n" + " " * nindent, nindent + 4)
             elif int(enum_i) == 1:
                 nindent = len(attr) + 14
 
@@ -343,13 +354,10 @@ class Xlsx2Skt:
         return global_body
 
     def build_vattributes(self):
-
         """Build the list of variable attributes"""
 
         if self.verbose:
-            logger.debug(
-                "Building skeleton table variable attributes section..."
-            )
+            logger.debug("Building skeleton table variable attributes section...")
 
         vattrs_body = ["#VARIABLEattributes", ""]
 
@@ -363,11 +371,15 @@ class Xlsx2Skt:
 
         return vattrs_body
 
-    def build_zvariables(self, zvars_sheet, vattrs_sheet,
-                         options_sheet, nrv_sheet,
-                         ignore_none=False,
-                         auto_pad=True):
-
+    def build_zvariables(
+        self,
+        zvars_sheet,
+        vattrs_sheet,
+        options_sheet,
+        nrv_sheet,
+        ignore_none=False,
+        auto_pad=True,
+    ):
         """Build the CDF skeleton table VARIABLEattributes
         and zVariables parts"""
 
@@ -379,12 +391,9 @@ class Xlsx2Skt:
         zvar_body.extend(["#zVariables", ""])
 
         for i, zvar in enumerate(zvars_sheet["Variable Name"]):
-
             if zvar is None:
                 if ignore_none:
-                    logger.warning(
-                        "Warning: current zVariable is NoneType, skipping!"
-                    )
+                    logger.warning("Warning: current zVariable is NoneType, skipping!")
                     continue
                 else:
                     sys.exit("ERROR: Current zVariable is NoneType!")
@@ -403,9 +412,20 @@ class Xlsx2Skt:
 
             if self.verbose:
                 logger.debug(
-                    "  " + quote(zvar) + "    " + dtype_i +
-                    "     " + nelem_i + "     " + dims_i + "     " +
-                    sizes_i + "     " + recvar_i + "     " + dimvars_i
+                    "  "
+                    + quote(zvar)
+                    + "    "
+                    + dtype_i
+                    + "     "
+                    + nelem_i
+                    + "     "
+                    + dims_i
+                    + "     "
+                    + sizes_i
+                    + "     "
+                    + recvar_i
+                    + "     "
+                    + dimvars_i
                 )
 
             if dtype_i == "None":
@@ -420,9 +440,22 @@ class Xlsx2Skt:
             if dimvars_i == "None":
                 dimvars_i = ""
 
-            zvar_entry = "  " + quote(zvar) + "    " + dtype_i + \
-                "     " + nelem_i + "     " + dims_i + "     " + \
-                sizes_i + "     " + recvar_i + "     " + dimvars_i
+            zvar_entry = (
+                "  "
+                + quote(zvar)
+                + "    "
+                + dtype_i
+                + "     "
+                + nelem_i
+                + "     "
+                + dims_i
+                + "     "
+                + sizes_i
+                + "     "
+                + recvar_i
+                + "     "
+                + dimvars_i
+            )
 
             if len(zvar_entry) > ROW_LENGTH_MAX:
                 zvar_entry = insert_char(zvar_entry, "\n", len(zvar) + 2)
@@ -434,8 +467,7 @@ class Xlsx2Skt:
                 if opt in options_sheet:
                     if opt == "VAR_PADVALUE" and auto_pad:
                         options_sheet[opt][0] = assign_pad(dtype_i)
-                    var_opt_info += "! " + opt + ": " + \
-                        options_sheet[opt][0] + "\n"
+                    var_opt_info += "! " + opt + ": " + options_sheet[opt][0] + "\n"
             zvar_body.append(var_opt_info)
 
             # Add variable attributes info
@@ -443,27 +475,28 @@ class Xlsx2Skt:
 
             vattr_entry = ""
             for j, vattr_var in enumerate(vattrs_sheet["Variable Name"]):
-
                 if vattr_var == zvar:
                     vattr_entry += "\n"
                     vattr_name = quote(str(vattrs_sheet["Attribute Name"][j]))
                     vattr_dtype = str(vattrs_sheet["Data Type"][j])
                     if vattr_dtype == "None":
-                        sys.exit("ERROR: Wrong Data Type for the " +
-                                 "attribute %s " % (vattr_name) +
-                                 "of the variable %s !" % (zvar))
+                        sys.exit(
+                            "ERROR: Wrong Data Type for the "
+                            + "attribute %s " % (vattr_name)
+                            + "of the variable %s !" % (zvar)
+                        )
 
                     vattr_value = str(vattrs_sheet["Value"][j])
 
-                    vattr_entry_j = "   " + vattr_name + "    " \
-                        + vattr_dtype + "     { "
+                    vattr_entry_j = (
+                        "   " + vattr_name + "    " + vattr_dtype + "     { "
+                    )
 
                     if vattr_dtype == "CDF_CHAR":
                         gap = " " * (2 * len(vattr_entry_j) - 1)
-                        vattr_value = truncate_str(vattr_value,
-                                                   int(ROW_LENGTH_MAX / 3),
-                                                   gap=gap,
-                                                   min_length=6)
+                        vattr_value = truncate_str(
+                            vattr_value, int(ROW_LENGTH_MAX / 3), gap=gap, min_length=6
+                        )
                         vattr_value = quote(vattr_value)
 
                     vattr_entry += vattr_entry_j + vattr_value + " }"
@@ -479,8 +512,7 @@ class Xlsx2Skt:
                     val_k = str(nrv_sheet["Value"][k])
                     if (idx_k == "") or (idx_k == "None"):
                         sys.exit("ERROR: Wrong NRV index for %s!" % nrv_k)
-                    nrv_body += "    [" + idx_k + "] = { " + \
-                        quote(val_k) + " }\n"
+                    nrv_body += "    [" + idx_k + "] = { " + quote(val_k) + " }\n"
 
             if len(nrv_body) == 0:
                 nrv_body = "  ! RV values were not requested.\n"
@@ -495,7 +527,6 @@ class Xlsx2Skt:
 
 # ________________ Global Functions __________
 def uniq(seq, not_none=False):
-
     """Get list of unique elements from an input sequence of list type"""
 
     seen = set()
@@ -507,24 +538,20 @@ def uniq(seq, not_none=False):
 
 
 def quote(string, unquote=False):
-
     """Double quote a given string"""
 
     if string is not None:
-        if string.startswith("\""):
+        if string.startswith('"'):
             string = string[1:]
-        if string.endswith("\""):
+        if string.endswith('"'):
             string = string[:-1]
         if unquote:
             return string
-        return "\"" + string + "\""
+        return '"' + string + '"'
 
 
-def truncate_str(string, max_length,
-                 gap=DEF_INDENT,
-                 min_length=3):
-
-    """ truncate a too long CDF_CHAR value"""
+def truncate_str(string, max_length, gap=DEF_INDENT, min_length=3):
+    """truncate a too long CDF_CHAR value"""
 
     nstr = len(string)
     new_string = ""
@@ -534,20 +561,18 @@ def truncate_str(string, max_length,
             break
         new_string += val_c
         if (i % max_length == 0) and (i != 0):
-            new_string += "\" - \n" + gap + "\""
+            new_string += '" - \n' + gap + '"'
 
     return new_string
 
 
 def insert_char(string, char, pos):
-
-    """ Insert substring in a string """
+    """Insert substring in a string"""
 
     return string[:pos] + char + string[pos:]
 
 
 def assign_pad(data_type):
-
     """
     Automatically assigns VAR_PADVALUE
     depending to the input data_type
@@ -563,24 +588,21 @@ def assign_pad(data_type):
     elif ("FLOAT" in dtype) or ("REAL" in dtype):
         return "0.0"
     elif "CHAR" in dtype:
-        return "\" \""
+        return '" "'
     else:
         return "None"
 
 
-def make_cdf(skt_file, cdf_file=None,
-             exe="skeletoncdf",
-             overwrite=False):
-
-    """ Make a CDF format file from a skeleton
-    table using the skeletoncdf program """
+def make_cdf(skt_file, cdf_file=None, exe="skeletoncdf", overwrite=False):
+    """Make a CDF format file from a skeleton
+    table using the skeletoncdf program"""
 
     if not os.path.isfile(skt_file):
         logger.error(skt_file + " does not exist!")
         return False
 
     if cdf_file is None:
-        cdf_file = os.path.basename(skt_file).replace('.skt', '.cdf')
+        cdf_file = os.path.basename(skt_file).replace(".skt", ".cdf")
         cdf_dir = os.path.dirname(skt_file)
         cdf_file = os.path.join(cdf_dir, cdf_file)