seabirdfilehandler 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

seabirdfilehandler/datatablefiles.py

@@ -9,7 +9,10 @@ import warnings
 from seabirdfilehandler.parameter import Parameters
 from seabirdfilehandler.validation_modules import CnvValidationList
 from seabirdfilehandler.seabirdfiles import SeaBirdFile
-from seabirdfilehandler.dataframe_meta_accessor import SeriesMetaAccessor, DataFrameMetaAccessor
+from seabirdfilehandler.dataframe_meta_accessor import (
+    SeriesMetaAccessor,
+    DataFrameMetaAccessor,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -54,8 +57,8 @@ class DataTableFile(SeaBirdFile):
         """
         file_path = self.file_dir if file_path is None else file_path
         file_name = self.file_name if file_name is None else file_name
-        if file_type[0] != '.':
-            file_type = '.' + file_type
+        if file_type[0] != ".":
+            file_type = "." + file_type
         return Path(file_path).joinpath(file_name).with_suffix(file_type)
 
     def to_csv(
@@ -85,18 +88,21 @@ class DataTableFile(SeaBirdFile):
         -------
 
         """
-        selected_columns = self.df.columns if selected_columns is None else selected_columns
+        selected_columns = (
+            self.df.columns if selected_columns is None else selected_columns
+        )
         df = self.df[selected_columns].reset_index(drop=True)
         new_file_path = self.define_output_path(
-            output_file_path, output_file_name)
+            output_file_path, output_file_name
+        )
         if with_header:
-            with open(new_file_path, 'w') as file:
+            with open(new_file_path, "w") as file:
                 for line in self.header:
                     file.write(line)
-            df.to_csv(new_file_path, index=False, mode='a')
+            df.to_csv(new_file_path, index=False, mode="a")
         else:
-            df.to_csv(new_file_path, index=False, mode='w')
-        logger.info(f'Wrote file {self.path_to_file} to {new_file_path}.')
+            df.to_csv(new_file_path, index=False, mode="w")
+        logger.info(f"Wrote file {self.path_to_file} to {new_file_path}.")
 
     def selecting_columns(
         self,
@@ -159,12 +165,17 @@ class BottleFile(DataTableFile):
         top_names, bottom_names = self.reading_data_header()
         # creating statistics column to store the row type information:
         # 4 rows per bottle, average, standard deviation, max value, min value
-        top_names.append('Statistic')
+        top_names.append("Statistic")
         # TODO: sexier way to construct dataframe than opening the file a
         # second time
         # # df = pd.DataFrame(self.data, index=None, columns=top_names)
-        df: pd.DataFrame = pd.read_fwf(self.path_to_file, index_col=False, skiprows=len(
-            self.header)+2, header=None, names=top_names)
+        df: pd.DataFrame = pd.read_fwf(
+            self.path_to_file,
+            index_col=False,
+            skiprows=len(self.header) + 2,
+            header=None,
+            names=top_names,
+        )
 
         # handling the double row header
         rowtypes = df[df.columns[-1]].unique()
@@ -184,22 +195,25 @@ class BottleFile(DataTableFile):
 
             """
             column_idx = df.columns.get_loc(column)
-            old_column = df.iloc[:: length, column_idx].reset_index(drop=True)
-            new_column = df.iloc[1:: length, column_idx].reset_index(drop=True)
+            old_column = df.iloc[::length, column_idx].reset_index(drop=True)
+            new_column = df.iloc[1::length, column_idx].reset_index(drop=True)
             old_column_expanded = pd.Series(
-                np.repeat(old_column, length)).reset_index(drop=True)
+                np.repeat(old_column, length)
+            ).reset_index(drop=True)
             new_column_expanded = pd.Series(
-                np.repeat(new_column, length)).reset_index(drop=True)
+                np.repeat(new_column, length)
+            ).reset_index(drop=True)
             df[column] = old_column_expanded
-            df.insert(column_idx + 1,
-                      bottom_names[column_idx], new_column_expanded)
+            df.insert(
+                column_idx + 1, bottom_names[column_idx], new_column_expanded
+            )
             return df
 
-        df = separate_double_header_row(df, 'Date', len(rowtypes))
+        df = separate_double_header_row(df, "Date", len(rowtypes))
         df = separate_double_header_row(df, top_names[0], len(rowtypes))
         # remove brackets around statistics values
-        df["Statistic"] = df["Statistic"].str.strip('()')
-        df = df.rename(mapper={'Btl_ID': 'Bottle_ID'}, axis=1)
+        df["Statistic"] = df["Statistic"].str.strip("()")
+        df = df.rename(mapper={"Btl_ID": "Bottle_ID"}, axis=1)
         return df
 
     def adding_timestamp_column(self):
@@ -216,9 +230,10 @@ class BottleFile(DataTableFile):
         # constructing timestamp column
         timestamp = []
         for datepoint, timepoint in zip(self.df.Date, self.df.Time):
-            timestamp.append(datetime.combine(
-                datepoint, time.fromisoformat(str(timepoint))))
-        self.df.insert(2, 'Timestamp', timestamp)
+            timestamp.append(
+                datetime.combine(datepoint, time.fromisoformat(str(timepoint)))
+            )
+        self.df.insert(2, "Timestamp", timestamp)
         self.df.Timestamp = pd.to_datetime(self.df.Timestamp)
 
     def setting_dataframe_dtypes(self):
@@ -228,9 +243,9 @@ class BottleFile(DataTableFile):
         self.df.Date = pd.to_datetime(self.df.Date)
         self.df.Bottle_ID = self.df.Bottle_ID.astype(int)
 
-    def selecting_rows(self,
-                       df=None,
-                       statistic_of_interest: Union[list, str] = ['avg']):
+    def selecting_rows(
+        self, df=None, statistic_of_interest: Union[list, str] = ["avg"]
+    ):
         """Creates a dataframe with the given row identifier, using the
         statistics column. A single string or a list of strings can be
         processed.
@@ -251,7 +266,7 @@ class BottleFile(DataTableFile):
         # ensure that the input is a list, so that isin() can do its job
         if isinstance(statistic_of_interest, str):
             statistic_of_interest = [statistic_of_interest]
-        self.df = df.loc[df['Statistic'].isin(statistic_of_interest)]
+        self.df = df.loc[df["Statistic"].isin(statistic_of_interest)]
 
     def reading_data_header(self):
         """Identifies and separatly collects the rows that specify the data
@@ -267,21 +282,24 @@ class BottleFile(DataTableFile):
         n = 11  # fix column width of a seabird btl file
         top_line = self.data[0]
         second_line = self.data[1]
-        top_names = [top_line[i:i+n].split()[0]
-                     for i in range(0, len(top_line)-n, n)]
-        bottom_names = [second_line[i:i+n].split()[0]
-                        for i in range(0, 2*n, n)]
+        top_names = [
+            top_line[i : i + n].split()[0]
+            for i in range(0, len(top_line) - n, n)
+        ]
+        bottom_names = [
+            second_line[i : i + n].split()[0] for i in range(0, 2 * n, n)
+        ]
         return top_names, bottom_names
 
     def add_station_and_event_column(self):
-        event_list = [self.metadata['Station'] for _ in self.data]
-        self.df.insert(0, 'Event', pd.Series(event_list))
+        event_list = [self.metadata["Station"] for _ in self.data]
+        self.df.insert(0, "Event", pd.Series(event_list))
 
     def add_position_columns(self):
-        latitude_list = [self.metadata['GPS_Lat'] for _ in self.data]
-        self.df.insert(1, 'Latitude', pd.Series(latitude_list))
-        longitude_list = [self.metadata['GPS_Lon'] for _ in self.data]
-        self.df.insert(2, 'Longitude', pd.Series(longitude_list))
+        latitude_list = [self.metadata["GPS_Lat"] for _ in self.data]
+        self.df.insert(1, "Latitude", pd.Series(latitude_list))
+        longitude_list = [self.metadata["GPS_Lon"] for _ in self.data]
+        self.df.insert(2, "Longitude", pd.Series(longitude_list))
 
 
 class CnvFile(DataTableFile):
@@ -331,12 +349,13 @@ class CnvFile(DataTableFile):
         self.start_time = self.reading_start_time()
         if create_dataframe:
             warnings.warn(
-                'The default of constructing a pandas Dataframe will soon be replaced by using the Parameters class that works on numpy arrays.',
+                "The default of constructing a pandas Dataframe will soon be replaced by using the Parameters class that works on numpy arrays.",
                 DeprecationWarning,
-                stacklevel=2  # Ensures the warning points to the caller's line
+                stacklevel=2,  # Ensures the warning points to the caller's line
+            )
+            self.data_header_meta_info, self.duplicate_columns = (
+                self.reading_data_header(self.data_table_description)
             )
-            self.data_header_meta_info, self.duplicate_columns = self.reading_data_header(
-                self.data_table_description)
             self.original_df = self.create_dataframe(data_table_info_level)
             self.df = self.original_df
             if absolute_time_calculation:
@@ -347,9 +366,12 @@ class CnvFile(DataTableFile):
                 self.add_position_columns()
         else:
             self.parameters = Parameters(
-                self.data, self.data_table_description)
+                self.data, self.data_table_description
+            )
 
-    def reading_data_header(self, header_info: list = []) -> Tuple[dict[str, dict], list[int]]:
+    def reading_data_header(
+        self, header_info: list = []
+    ) -> Tuple[dict[str, dict], list[int]]:
         """Reads the tables header data from the header.
 
         Parameters
@@ -380,16 +402,20 @@ class CnvFile(DataTableFile):
                     if shortname in list(table_header.keys()):
                         try:
                             duplicate_columns.append(
-                                int(line.split("=")[0].strip().split()[1]))
-                        except (IndexError) as error:
+                                int(line.split("=")[0].strip().split()[1])
+                            )
+                        except IndexError as error:
                             logger.error(
                                 f"Could not resolve duplicate column: {
-                                    shortname}, {error}")
+                                    shortname
+                                }, {error}"
+                            )
                     else:
                         header_meta_info["shortname"] = shortname
                         header_meta_info["longinfo"] = longinfo.strip()
                         metainfo = self._extract_data_header_meta_info(
-                            longinfo.strip())
+                            longinfo.strip()
+                        )
                         header_meta_info = {**header_meta_info, **metainfo}
                         table_header[shortname.strip()] = header_meta_info
         return table_header, duplicate_columns
@@ -408,22 +434,24 @@ class CnvFile(DataTableFile):
 
         """
         regex_string = r"(?:(?P<name0>.+),\s(?P<metainfo0>.+)\s\[(?P<unit0>.+)\]|(?P<name2>.+)\s\[(?P<unit2>.+)\]|(?P<name3>.+),\s(?P<metainfo2>.[^\s]+)|(?P<name4>.+))"
-        regex_check = re.search(
-            regex_string, line, flags=re.IGNORECASE)
+        regex_check = re.search(regex_string, line, flags=re.IGNORECASE)
         if regex_check:
             regex_info = dict(regex_check.groupdict())
-            regex_info = {key[:-1]: value for key,
-                          value in regex_info.items() if value is not None}
+            regex_info = {
+                key[:-1]: value
+                for key, value in regex_info.items()
+                if value is not None
+            }
             if len(regex_info) > 2:
                 # check for second sensors and adjust their names
-                if regex_info["metainfo"][-1] == '2':
+                if regex_info["metainfo"][-1] == "2":
                     regex_info["name"] = regex_info["name"] + " 2"
-                    regex_info["metainfo"] = regex_info['metainfo'][:-1]
+                    regex_info["metainfo"] = regex_info["metainfo"][:-1]
                     if len(regex_info["metainfo"]) == 0:
                         regex_info.pop("metainfo")
-            if regex_info['name'] == 'flag':
-                regex_info["metainfo"] = regex_info['name']
-                regex_info["unit"] = regex_info['name']
+            if regex_info["name"] == "flag":
+                regex_info["metainfo"] = regex_info["name"]
+                regex_info["unit"] = regex_info["name"]
             return regex_info
         return {}
 
@@ -449,10 +477,13 @@ class CnvFile(DataTableFile):
         n = 11
         row_list = []
         for line in self.data:
-            row_list.append([line[i:i+n].split()[0]
-                            for i in range(0, len(line)-n, n)])
-        # TODO: force float dtype here and handle that in rest of code
-        df = pd.DataFrame(row_list)
+            row_list.append(
+                [
+                    line[i : i + n].split()[0]
+                    for i in range(0, len(line) - n, n)
+                ]
+            )
+        df = pd.DataFrame(row_list, dtype=float)
         header_names = [
             metainfo[header_info_detail_level]
             for metainfo in list(self.data_header_meta_info.values())
@@ -463,8 +494,9 @@ class CnvFile(DataTableFile):
         try:
             df.columns = header_names
         except ValueError as error:
-            logger.error(f"Could not set dataframe header for {
-                         self.file_name}: {error}")
+            logger.error(
+                f"Could not set dataframe header for {self.file_name}: {error}"
+            )
             logger.error(header_names)
         else:
             df.meta.metadata = self.data_header_meta_info
@@ -472,26 +504,27 @@ class CnvFile(DataTableFile):
         return df
 
     def rename_dataframe_header(
-            self,
-            df: pd.DataFrame | None = None,
-            header_detail_level: str = "shortname",
+        self,
+        df: pd.DataFrame | None = None,
+        header_detail_level: str = "shortname",
     ) -> list:
         df = self.df if df is None else df
         df.meta.rename(header_detail_level)
         return [column for column in df.columns]
 
     def reading_start_time(
-            self,
-            time_source: str = "System UTC",
+        self,
+        time_source: str = "System UTC",
     ) -> datetime | None:
         """
         Extracts the Cast start time from the metadata header.
         """
         for line in self.sbe9_data:
             if line.startswith(time_source):
-                start_time = line.split('=')[1]
+                start_time = line.split("=")[1]
                 start_time = datetime.strptime(
-                    start_time, ' %b %d %Y %H:%M:%S ')
+                    start_time, " %b %d %Y %H:%M:%S "
+                )
                 return start_time
         return None
 
@@ -504,11 +537,11 @@ class CnvFile(DataTableFile):
         """
         time_parameter = None
         for parameter in self.df.columns:
-            if parameter.lower().startswith('time'):
+            if parameter.lower().startswith("time"):
                 time_parameter = parameter
         if time_parameter and self.start_time:
             self.df.meta.add_column(
-                name='datetime',
+                name="datetime",
                 data=[
                     timedelta(days=float(time)) + self.start_time
                     if time_parameter == "timeJ"
@@ -526,7 +559,7 @@ class CnvFile(DataTableFile):
         """
         if self.start_time:
             self.df.meta.add_column(
-                name='start_time',
+                name="start_time",
                 data=pd.Series([self.start_time for _ in self.data]),
             )
             return True
@@ -541,9 +574,9 @@ class CnvFile(DataTableFile):
         return CnvValidationList(validation_modules)
 
     def df2cnv(
-            self,
-            header_names: list | None = None,
-            header_detail_level: str | None = None,
+        self,
+        header_names: list | None = None,
+        header_detail_level: str | None = None,
     ) -> list:
         """
         Parses a pandas dataframe into a list that represents the lines inside
@@ -577,16 +610,23 @@ class CnvFile(DataTableFile):
         )
         cnv_out = []
         for _, row in df.iterrows():
-            cnv_like_row = ''.join(
-                (lambda column: f"{str(column):>11}")(value) for value in row)
+            cnv_like_row = "".join(
+                (lambda column: f"{str(column):>11}")(value) for value in row
+            )
             cnv_out.append(cnv_like_row + "\n")
         return cnv_out
 
+    def array2cnv(self) -> list:
+        result = []
+        for row in self.parameters.full_data_array:
+            formatted_row = "".join(f"{elem:11}" for elem in row)
+            result.append(formatted_row + "\n")
+        return result
+
     def to_cnv(
         self,
         file_name: Path | str | None = None,
-        use_current_df: bool = True,
-        use_current_processing_header: bool = False,
+        use_dataframe: bool = True,
         header_list: list | None = None,
     ):
         """
@@ -606,32 +646,32 @@ class CnvFile(DataTableFile):
         """
         file_name = self.path_to_file if file_name is None else file_name
         # content construction
-        if use_current_df:
-            self.data = self.df2cnv(header_list)
-        if use_current_processing_header:
-            self._update_header()
-        self.file_data = [*self.header, *self.data]
+        if use_dataframe:
+            data = self.df2cnv(header_list)
+        else:
+            data = self.array2cnv()
+        self._update_header()
+        self.file_data = [*self.header, *data]
         # writing content out
         try:
-            with open(file_name, 'w', encoding='latin-1') as file:
+            with open(file_name, "w", encoding="latin-1") as file:
                 for line in self.file_data:
                     file.write(line)
-            logger.info(f'Wrote cnv {self.path_to_file} to {file_name}.')
 
         except IOError as error:
-            logger.error(f'Could not write cnv file: {error}')
+            logger.error(f"Could not write cnv file: {error}")
 
     def _update_header(self):
         """Re-creates the cnv header."""
         self.data_table_description = self._form_data_table_info()
         self.header = [
-            *[f'* {data}' for data in self.sbe9_data[:-1]],
-            *[f'** {data}' for data in self.metadata_list],
-            f'* {self.sbe9_data[-1]}',
-            *[f'# {data}' for data in self.data_table_description],
-            *[f'# {data}' for data in self.sensor_data],
-            *[f'# {data}' for data in self.processing_info],
-            '*END*\n'
+            *[f"* {data}" for data in self.sbe9_data[:-1]],
+            *[f"** {data}" for data in self.metadata_list],
+            f"* {self.sbe9_data[-1]}",
+            *[f"# {data}" for data in self.data_table_description],
+            *[f"# {data}" for data in self.sensor_data],
+            *[f"# {data}" for data in self.processing_info],
+            "*END*\n",
         ]
 
     def _form_data_table_info(self) -> list:
@@ -644,7 +684,8 @@ class CnvFile(DataTableFile):
             new_table_info.append(f"name {index} = {name}\n")
         for index, (_, span) in enumerate(self.data_table_names_and_spans):
             new_table_info.append(f"span {index} = {span}\n")
-        new_table_info = [*new_table_info, *self.data_table_misc]
+        for key, value in self.data_table_misc.items():
+            new_table_info.append(f"{key} = {value}\n")
         return new_table_info
 
     def add_processing_metadata(self, addition: str | list):
@@ -672,14 +713,12 @@ class CnvFile(DataTableFile):
 
         """
         try:
-            event_list = [self.metadata['Station'] for _ in self.data]
+            event_list = [self.metadata["Station"] for _ in self.data]
         except KeyError:
             return False
         else:
             self.df.meta.add_column(
-                name='Event',
-                data=pd.Series(event_list),
-                location=0
+                name="Event", data=pd.Series(event_list), location=0
             )
             return True
 
@@ -689,26 +728,22 @@ class CnvFile(DataTableFile):
         These must be present inside the extra metadata header.
 
         """
-        if ('latitude' or 'longitude') in [
-            column['shortname']
+        if ("latitude" or "longitude") in [
+            column["shortname"]
             for column in list(self.df.meta.metadata.values())
         ]:
             return True
         try:
-            latitude_list = [self.metadata['GPS_Lat'] for _ in self.data]
-            longitude_list = [self.metadata['GPS_Lon'] for _ in self.data]
+            latitude_list = [self.metadata["GPS_Lat"] for _ in self.data]
+            longitude_list = [self.metadata["GPS_Lon"] for _ in self.data]
         except KeyError:
             return False
         else:
             self.df.meta.add_column(
-                name='Latitude',
-                data=pd.Series(latitude_list),
-                location=1
+                name="Latitude", data=pd.Series(latitude_list), location=1
             )
             self.df.meta.add_column(
-                name='Longitude',
-                data=pd.Series(longitude_list),
-                location=2
+                name="Longitude", data=pd.Series(longitude_list), location=2
             )
             return True
 
@@ -722,13 +757,13 @@ class CnvFile(DataTableFile):
             the cast number of this files cast
 
         """
-        if ('Cast' in self.metadata.keys()) and (not number):
-            number = int(self.metadata['Cast'])
+        if ("Cast" in self.metadata.keys()) and (not number):
+            number = int(self.metadata["Cast"])
         try:
             self.df.meta.add_column(
-                name='Cast',
+                name="Cast",
                 data=pd.Series([number for _ in self.data]),
-                location=0
+                location=0,
             )
         except ValueError:
             # Cast is already part of the dataframe, so nothing left to do
@@ -750,7 +785,7 @@ class BottleLogFile(DataTableFile):
 
     """
 
-    def __init__(self, path_to_file, create_dataframe = False):
+    def __init__(self, path_to_file, create_dataframe=False):
         super().__init__(path_to_file)
         self.reset_time = self.obtaining_reset_time()
         self.origin_cnv = self.raw_file_data[0].strip()
@@ -761,8 +796,6 @@ class BottleLogFile(DataTableFile):
             self.df = self.original_df
         else:
             self.data_list = self.create_list()
-    
-    
 
     def data_whitespace_removal(self) -> list:
         """Strips the input from whitespace characters, in this case especially
@@ -793,13 +826,15 @@ class BottleLogFile(DataTableFile):
 
         """
 
-        regex_check = re.search(r'RESET\s(\w{3}\s\d+\s\d{4}\s\d\d:\d\d:\d\d)',
-                                self.raw_file_data[1])
+        regex_check = re.search(
+            r"RESET\s(\w{3}\s\d+\s\d{4}\s\d\d:\d\d:\d\d)",
+            self.raw_file_data[1],
+        )
         if regex_check:
-            return datetime.strptime(regex_check.group(1), '%b %d %Y %H:%M:%S')
+            return datetime.strptime(regex_check.group(1), "%b %d %Y %H:%M:%S")
         else:
-            error_message = '''BottleLogFile is not formatted as expected:
-                Reset time could not be extracted.'''
+            error_message = """BottleLogFile is not formatted as expected:
+                Reset time could not be extracted."""
             logger.error(error_message)
             raise IOError(error_message)
 
@@ -820,13 +855,12 @@ class BottleLogFile(DataTableFile):
             bottles = [int(x) for x in self.data[i].split(",")[:2]]
             date = self.convert_date(self.data[i].split(",")[2])
             lines = tuple([int(x) for x in self.data[i].split(",")[3:]])
-            
+
             content_array.append([bottles, date, lines])
-        
+
         return content_array
-        
 
-    def convert_date(self, date : str):
+    def convert_date(self, date: str):
         """Converts the Dates of the .bl files to an ISO 8601 standard
 
         Parameters
@@ -837,8 +871,21 @@ class BottleLogFile(DataTableFile):
         a string with the date in the form of "yymmddThhmmss"
         """
         date = date.strip()
-        month_list = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
-        
+        month_list = [
+            "Jan",
+            "Feb",
+            "Mar",
+            "Apr",
+            "May",
+            "Jun",
+            "Jul",
+            "Aug",
+            "Sep",
+            "Oct",
+            "Nov",
+            "Dec",
+        ]
+
         month_ind = month_list.index(date.split(" ")[0]) + 1
         if month_ind < 10:
             month = "0" + str(month_ind)
@@ -848,9 +895,7 @@ class BottleLogFile(DataTableFile):
         year = (date.split(" ")[2])[2:]
         time = date.split(" ")[3].replace(":", "")
         return year + month + day + "T" + time
-    
 
-    
     def create_dataframe(self) -> pd.DataFrame:
         """Creates a dataframe from the list specified in self.data.
 
@@ -863,16 +908,15 @@ class BottleLogFile(DataTableFile):
         """
         data_lists = []
         for line in self.data:
-            inner_list = line.split(',')
+            inner_list = line.split(",")
             # dropping first column as its the index
             data_lists.append(inner_list[1:])
         df = pd.DataFrame(data_lists)
-        df.columns = ['Bottle ID', 'Datetime', 'start_range', 'end_range']
+        df.columns = ["Bottle ID", "Datetime", "start_range", "end_range"]
         return df
 
 
 class FieldCalibrationFile(DataTableFile):
-
     def __init__(self, path_to_file):
         super().__init__(path_to_file)
         self.original_df = self.create_dataframe()
@@ -882,5 +926,5 @@ class FieldCalibrationFile(DataTableFile):
         try:
             return pd.read_csv(self.path_to_file, skiprows=len(self.header))
         except IOError as error:
-            logger.error(f'Could not read field calibration file: {error}.')
+            logger.error(f"Could not read field calibration file: {error}.")
             return pd.DataFrame()

seabirdfilehandler/file_collection.py

@@ -81,8 +81,7 @@ class FileCollection(UserList):
                 self.data.append(self.file_type(file))
             except TypeError:
                 logger.error(
-                    f"Could not open file {
-                        file} with the type "
+                    f"Could not open file {file} with the type "
                     f"{self.file_type}."
                 )
                 continue
@@ -260,7 +259,9 @@ class FileCollection(UserList):
             else:
                 differing_dicts = [
                     current_dict
-                    for last_dict, current_dict in zip(last_unique, cast_sensors)
+                    for last_dict, current_dict in zip(
+                        last_unique, cast_sensors
+                    )
                     if current_dict != last_dict
                 ]
                 if differing_dicts: