seabirdfilehandler 0.4.1__py3-none-any.whl → 0.4.3__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,  # noqa: F401
+    DataFrameMetaAccessor,  # noqa: F401
+)
 
 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
@@ -362,7 +384,7 @@ class CnvFile(DataTableFile):
         a list of dictionaries, that organize the table header information
 
         """
-        if header_info is []:
+        if header_info == []:
             header_info = self.data_table_description
         table_header = {}
         duplicate_columns = []
@@ -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 {}
 
@@ -450,7 +478,10 @@ class CnvFile(DataTableFile):
         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)]
+                [
+                    line[i : i + n].split()[0]
+                    for i in range(0, len(line) - n, n)
+                ]
             )
         df = pd.DataFrame(row_list, dtype=float)
         header_names = [
@@ -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,8 +610,9 @@ 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
 
@@ -620,25 +654,24 @@ class CnvFile(DataTableFile):
         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:
@@ -680,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
 
@@ -697,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
 
@@ -730,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
@@ -758,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()
@@ -769,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
@@ -801,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)
 
@@ -828,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
@@ -845,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)
@@ -856,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.
 
@@ -871,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()
@@ -890,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

@@ -4,8 +4,14 @@ from collections import UserList
 from typing import Type
 import pandas as pd
 import numpy as np
-from seabirdfilehandler import SeaBirdFile, CnvFile, BottleFile, BottleLogFile
+from seabirdfilehandler import (
+    SeaBirdFile,
+    CnvFile,
+    BottleFile,
+    BottleLogFile,
+)
 from seabirdfilehandler.datatablefiles import DataTableFile
+from seabirdfilehandler.utils import get_unique_sensor_data
 
 logger = logging.getLogger(__name__)
 
@@ -14,17 +20,26 @@ class FileCollection(UserList):
     """A representation of multiple files of the same kind. These files share
     the same suffix and are otherwise closely connected to each other. A common
     use case would be the collection of CNVs to allow for easier processing or
-    integration of field calibration measurements."""
+    integration of field calibration measurements.
+
+    Parameters
+    ----------
+
+    Returns
+    -------
+
+    """
 
     def __init__(
         self,
         path_to_files: str | Path,
         file_suffix: str,
-        pattern: str | None = None
+        pattern: str | None = None,
+        only_metadata: bool = False,
     ):
         super().__init__()
         self.path_to_files = Path(path_to_files)
-        self.file_suffix = file_suffix.strip('.')
+        self.file_suffix = file_suffix.strip(".")
         self.file_type: Type[SeaBirdFile]
         self.extract_file_type()
         self.individual_file_paths = []
@@ -33,21 +48,27 @@ class FileCollection(UserList):
             # TODO: implement pattern handling
             self.pattern = pattern
         else:
-            self.load_files()
-        if self.file_type == DataTableFile:
-            self.df_list = self.get_dataframes()
-            self.df = self.get_collection_dataframe(self.df_list)
-        if self.file_type == CnvFile:
-            self.data_meta_info = self.get_data_table_meta_info()
-        self.sensor_data = self.get_sensor_data()
+            self.load_files(only_metadata)
+        if not only_metadata:
+            if self.file_type == DataTableFile:
+                self.df_list = self.get_dataframes()
+                self.df = self.get_collection_dataframe(self.df_list)
+            if self.file_type == CnvFile:
+                self.data_meta_info = self.get_data_table_meta_info()
+            self.sensor_data = get_unique_sensor_data(
+                [file.sensors for file in self.data]
+            )
 
     def __str__(self):
-        return '/n'.join(self.data)
+        return "/n".join(self.data)
 
     def extract_file_type(self):
-        mapping_suffix_to_type = {'cnv': CnvFile,
-                                  'btl': BottleFile,
-                                  'bl': BottleLogFile}
+        """ """
+        mapping_suffix_to_type = {
+            "cnv": CnvFile,
+            "btl": BottleFile,
+            "bl": BottleLogFile,
+        }
         for key, value in mapping_suffix_to_type.items():
             if key == self.file_suffix:
                 self.file_type = value
@@ -56,17 +77,21 @@ class FileCollection(UserList):
                 self.file_type = SeaBirdFile
 
     def collect_files(self):
-        for path in self.path_to_files.rglob(f'*{self.file_suffix}'):
+        """ """
+        for path in self.path_to_files.rglob(f"*{self.file_suffix}"):
             self.individual_file_paths.append(path)
         self.individual_file_paths.sort()
 
-    def load_files(self):
+    def load_files(self, only_metadata: bool = False):
+        """ """
         for file in self.individual_file_paths:
             try:
                 self.data.append(self.file_type(file))
             except TypeError:
-                logger.error(f'Could not open file {file} with the type '
-                             f'{self.file_type}.')
+                logger.error(
+                    f"Could not open file {file} with the type "
+                    f"{self.file_type}."
+                )
                 continue
 
     def get_dataframes(
@@ -78,6 +103,27 @@ class FileCollection(UserList):
         long_header_names: bool = False,
         full_data_header: bool = True,
     ) -> list[pd.DataFrame]:
+        """
+
+        Parameters
+        ----------
+        event_log: bool :
+             (Default value = False)
+        coordinates: bool :
+             (Default value = False)
+        time_correction: bool :
+             (Default value = False)
+        cast_identifier: bool :
+             (Default value = False)
+        long_header_names: bool :
+             (Default value = False)
+        full_data_header: bool :
+             (Default value = True)
+
+        Returns
+        -------
+
+        """
         for index, file in enumerate(self.data):
             if full_data_header:
                 file.rename_dataframe_header(header_detail_level="longinfo")
@@ -91,73 +137,121 @@ class FileCollection(UserList):
                 file.absolute_time_calculation()
                 file.add_start_time()
             if cast_identifier:
-                file.add_cast_number(index+1)
+                file.add_cast_number(index + 1)
         return [file.df for file in self.data]
 
     def get_collection_dataframe(
-        self,
-        list_of_dfs: list[pd.DataFrame] | None = None
+        self, list_of_dfs: list[pd.DataFrame] | None = None
     ) -> pd.DataFrame:
+        """
+
+        Parameters
+        ----------
+        list_of_dfs: list[pd.DataFrame] | None :
+             (Default value = None)
+
+        Returns
+        -------
+
+        """
         if not list_of_dfs:
             list_of_dfs = self.get_dataframes()
         df = pd.concat(list_of_dfs, ignore_index=True)
-        df.meta.metadata = list_of_dfs[0].meta.metadata
+        # df.meta.metadata = list_of_dfs[0].meta.metadata
         return df
 
     def tidy_collection_dataframe(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+
+        Parameters
+        ----------
+        df: pd.DataFrame :
+
+
+        Returns
+        -------
+
+        """
         df = self.use_bad_flag_for_nan(df)
         df = self.set_dtype_to_float(df)
         return self.select_real_scan_data(df)
 
     def use_bad_flag_for_nan(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+
+        Parameters
+        ----------
+        df: pd.DataFrame :
+
+
+        Returns
+        -------
+
+        """
         bad_flags = set()
         for file in self.data:
             for line in file.data_table_description:
-                if line.startswith('bad_flag'):
-                    flag = line.split('=')[1].strip()
+                if line.startswith("bad_flag"):
+                    flag = line.split("=")[1].strip()
                     bad_flags.add(flag)
         for flag in bad_flags:
             df.replace(to_replace=flag, value=np.nan, inplace=True)
         return df
 
     def set_dtype_to_float(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+
+        Parameters
+        ----------
+        df: pd.DataFrame :
+
+
+        Returns
+        -------
+
+        """
         for parameter in df.columns:
-            if parameter in ['datetime']:
+            if parameter in ["datetime"]:
                 continue
             try:
-                df[parameter] = df[parameter].astype('float')
+                df[parameter] = df[parameter].astype("float")
             finally:
                 continue
         return df
 
     def select_real_scan_data(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+
+        Parameters
+        ----------
+        df: pd.DataFrame :
+
+
+        Returns
+        -------
+
+        """
         # TODO: fix this hardcoded name
         try:
-            df = df.loc[df['Scan Count'].notna()]
+            df = df.loc[df["Scan Count"].notna()]
         finally:
             pass
         return df
 
     def to_csv(self, file_name):
+        """
+
+        Parameters
+        ----------
+        file_name :
+
+
+        Returns
+        -------
+
+        """
         self.get_collection_dataframe().to_csv(file_name)
 
     def get_data_table_meta_info(self) -> list[list[dict]]:
+        """ """
         return [file.data_header_meta_info for file in self.data]
-
-    def get_sensor_data(self) -> list[tuple[list[dict]]]:
-        unique = []
-        last_unique = None
-        for file in [file for file in self.data]:
-            cast_sensors = file.sensors
-            if last_unique is None:
-                unique.append((file.file_name, cast_sensors))
-            else:
-                differing_dicts = [
-                    current_dict
-                    for last_dict, current_dict in zip(last_unique, cast_sensors)
-                    if current_dict != last_dict
-                ]
-                if differing_dicts:
-                    unique.append((file.file_name, differing_dicts))
-            last_unique = cast_sensors
-        return unique

seabirdfilehandler/parameter.py

@@ -37,7 +37,9 @@ class Parameters(UserDict):
         self.raw_metadata = metadata
         self.full_data_array = self.create_full_ndarray()
         self.differentiate_table_description()
-        self.metadata, self.duplicate_columns = self.reading_data_header(metadata)
+        self.metadata, self.duplicate_columns = self.reading_data_header(
+            metadata
+        )
         self.data = self.create_parameter_instances()
 
     def get_parameter_list(self) -> list[Parameter]:
@@ -59,12 +61,17 @@ class Parameters(UserDict):
         A numpy array of the same shape as the cnv files data table
 
         """
-        data_table = self.raw_input_data if len(data_table) == 0 else data_table
+        data_table = (
+            self.raw_input_data if len(data_table) == 0 else data_table
+        )
         n = 11
         row_list = []
         for line in data_table:
             row_list.append(
-                [line[i : i + n].split()[0] for i in range(0, len(line) - n, n)]
+                [
+                    line[i : i + n].split()[0]
+                    for i in range(0, len(line) - n, n)
+                ]
             )
         return np.array(row_list, dtype=float)
 
@@ -87,17 +94,23 @@ class Parameters(UserDict):
         A dictionary of parameter instances
 
         """
-        metadata = self.metadata if len(list(metadata.keys())) == 0 else metadata
+        metadata = (
+            self.metadata if len(list(metadata.keys())) == 0 else metadata
+        )
         parameter_dict = {}
         list_of_metadata_shortnames = list(metadata.keys())
         if self.full_data_array.shape[1] != len(list_of_metadata_shortnames):
             raise AssertionError(
-                f"{self.full_data_array.shape} and metadata:{metadata}"
+                f"Array column width {
+                    self.full_data_array.shape[1]
+                } does not fit metadata length {len(metadata)}"
             )
         for i in range(self.full_data_array.shape[1]):
             column_data = self.full_data_array[:, i]
             key = list_of_metadata_shortnames[i]
-            parameter_dict[key] = Parameter(data=column_data, metadata=metadata[key])
+            parameter_dict[key] = Parameter(
+                data=column_data, metadata=metadata[key]
+            )
         return parameter_dict
 
     def differentiate_table_description(self):
@@ -124,10 +137,12 @@ class Parameters(UserDict):
                     post.append(line)
         assert len(column_names) == len(column_value_spans)
         self.data_table_stats = {
-            line.split("=")[0].strip(): line.split("=")[1].strip() for line in pre
+            line.split("=")[0].strip(): line.split("=")[1].strip()
+            for line in pre
         }
         self.data_table_names_and_spans = [
-            (name, span) for name, span in zip(column_names, column_value_spans)
+            (name, span)
+            for name, span in zip(column_names, column_value_spans)
         ]
         self.data_table_misc = post
 
@@ -175,9 +190,13 @@ class Parameters(UserDict):
         """
         if len(metadata) < 5:
             if len(name) > 0:
-                metadata = self.add_default_metadata(name=name, metadata=metadata)
+                metadata = self.add_default_metadata(
+                    name=name, metadata=metadata
+                )
             else:
-                raise ValueError("Please specify either a name or sufficient metadata")
+                raise ValueError(
+                    "Please specify either a name or sufficient metadata"
+                )
         if not isinstance(data, np.ndarray):
             data = np.full(
                 fill_value=data,
@@ -239,7 +258,9 @@ class Parameters(UserDict):
 
     def get_pandas_dataframe(self) -> pd.DataFrame:
         """Returns a pandas DataFrame of the current parameter data."""
-        data = np.array([parameter.data for parameter in self.get_parameter_list()]).T
+        data = np.array(
+            [parameter.data for parameter in self.get_parameter_list()]
+        ).T
         columns = [parameter.name for parameter in self.get_parameter_list()]
         assert data.shape[1] == len(columns)
         return pd.DataFrame(data=data, columns=columns, dtype=float)
@@ -298,12 +319,15 @@ class Parameters(UserDict):
                         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())
+                        metainfo = self._extract_data_header_meta_info(
+                            longinfo.strip()
+                        )
                         header_meta_info = {**header_meta_info, **metainfo}
                         table_header[shortname.strip()] = header_meta_info
         return table_header, duplicate_columns

seabirdfilehandler/seabirdfiles.py

@@ -30,7 +30,7 @@ class SeaBirdFile:
     ):
         self.path_to_file = Path(path_to_file)
         self.file_name = self.path_to_file.stem
-        self.file_dir = self.path_to_file.parents[0]
+        self.file_dir = self.path_to_file.parent
         self.timestamp = datetime.now(timezone.utc)
         self.raw_file_data = []  # the text file input
         self.header = []  # the full file header
@@ -53,7 +53,9 @@ class SeaBirdFile:
                     break
         self.extract_file_information(only_header)
         if len(self.sensor_data) > 0:
-            self.sensors = self.sensor_xml_to_flattened_dict("".join(self.sensor_data))
+            self.sensors = self.sensor_xml_to_flattened_dict(
+                "".join(self.sensor_data)
+            )
 
     def __str__(self) -> str:
         return "/n".join(self.file_data)
@@ -114,6 +116,7 @@ class SeaBirdFile:
         post = []
         for line in self.data_table_description:
             if line.startswith("name"):
+                # TODO: cuts off lines containing multiple '=' symbols
                 column_names.append(line.split("=")[1].strip())
             elif line.startswith("span"):
                 past_spans = True
@@ -125,14 +128,21 @@ class SeaBirdFile:
                     post.append(line)
         assert len(column_names) == len(column_value_spans)
         self.data_table_stats = {
-            line.split("=")[0].strip(): line.split("=")[1].strip() for line in pre
+            line.split("=")[0].strip(): line.split("=")[1].strip()
+            for line in pre
         }
         self.data_table_names_and_spans = [
-            (name, span) for name, span in zip(column_names, column_value_spans)
+            (name, span)
+            for name, span in zip(column_names, column_value_spans)
         ]
-        self.data_table_misc = {line.split("=")[0].strip(): line.split("=")[1].strip() for line in post}
+        self.data_table_misc = {
+            line.split("=")[0].strip(): line.split("=")[1].strip()
+            for line in post
+        }
 
-    def sensor_xml_to_flattened_dict(self, sensor_data: str) -> list[dict] | dict:
+    def sensor_xml_to_flattened_dict(
+        self, sensor_data: str
+    ) -> list[dict] | dict:
         """Reads the pure xml sensor input and creates a multilevel dictionary,
         dropping the first two dictionaries, as they are single entry only
 

seabirdfilehandler/utils.py

@@ -0,0 +1,53 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def get_unique_sensor_data(
+    sensor_data: list[list[dict]],
+) -> list[tuple[list[dict]]]:
+    """
+    Returns all the unique sensors and their configuration used in the given
+    collection of sensor data. These will typically be parsed from xml inside
+    .cnv or .xmlcon files.
+    If for example, the first oxygen sensor has been replaced after the 8 cast,
+    then we will see that in the output structure by a seconde tuple, with the
+    number 8 and the individual sensor information for that new oxygen sensor.
+
+    Parameters
+    ----------
+    sensor_data:
+        The structure of xml-parsed dicts inside two organizing lists.
+
+    Returns
+    -------
+    The input structure stripped down to unique sensor data and appended by
+    the index, at which this new sensor appeared the first time.
+
+    """
+    unique = []
+    last_unique = None
+    for index, individual_sensor_data in enumerate(
+        [file for file in sensor_data]
+    ):
+        if last_unique is None:
+            unique.append((index, individual_sensor_data))
+        else:
+            differing_dicts = [
+                current_dict
+                for last_dict, current_dict in zip(
+                    last_unique, individual_sensor_data
+                )
+                if current_dict != last_dict
+            ]
+            if differing_dicts:
+                unique.append((index, differing_dicts))
+        last_unique = individual_sensor_data
+    return unique
+
+
+class UnexpectedFileFormat(Exception):
+    def __init__(self, file_type: str, error: str) -> None:
+        message = f"{file_type} is not formatted as expected: {error}"
+        logger.error(message)
+        super().__init__(message)

seabirdfilehandler/validation_modules.py

@@ -27,8 +27,10 @@ class CnvValidationList(UserDict):
         """ """
         module_list = []
         for line in self.cnv_header_val_modules:
-            module = line.split('_')[0]
-            if ((module not in module_list) and (line.split()[0] != 'file_type')):
+            module = line.split("_")[0]
+            if (module not in module_list) and (
+                line.split()[0] != "file_type"
+            ):
                 module_list.append(module)
         return module_list
 
@@ -50,41 +52,42 @@ class CnvValidationList(UserDict):
         action_dict_present = False
         # extract lines corresponding to the module
         for line in self.cnv_header_val_modules:
-            if module == line.split('_')[0]:
+            if module == line.split("_")[0]:
                 # removing the module names from the lines
                 shifting_index = len(module) + 1
                 line_content = line[shifting_index:]
                 # handle the case of the validation methods keyword being
                 # 'action', which corresponds to an entire dict of values
-                if line_content[:6] == 'action':
+                if line_content[:6] == "action":
                     action_dict_present = True
                     inner_action_dict = self.module_dict_feeder(
-                        line_content[6:], inner_action_dict)
+                        line_content[6:], inner_action_dict
+                    )
                 else:
                     # handle the cases where after some date value, another value
                     # is printed inside of [] brackets
-                    double_value_list = line_content.split('[')
+                    double_value_list = line_content.split("[")
                     if len(double_value_list) > 1:
                         out_dict = self.module_dict_feeder(
-                            double_value_list[1][shifting_index:-2], out_dict)
+                            double_value_list[1][shifting_index:-2], out_dict
+                        )
                         line_content = double_value_list[0]
-                    if line_content[:11] == 'surface_bin':
+                    if line_content[:11] == "surface_bin":
                         surface_bin_dict = {}
-                        for line in line_content.split(','):
+                        for line in line_content.split(","):
                             self.module_dict_feeder(line, surface_bin_dict)
-                        out_dict['surface_bin'] = surface_bin_dict
+                        out_dict["surface_bin"] = surface_bin_dict
                         continue
                     # usual behavior, for 99% cases:
                     # assigning key and value to the module dict
                     out_dict = self.module_dict_feeder(line_content, out_dict)
         if action_dict_present:
-            out_dict['action'] = inner_action_dict
+            out_dict["action"] = inner_action_dict
         return out_dict
 
-    def module_dict_feeder(self,
-                           line: str,
-                           dictionary: dict,
-                           split_value: str = '='):
+    def module_dict_feeder(
+        self, line: str, dictionary: dict, split_value: str = "="
+    ):
         """
 
         Parameters

seabirdfilehandler/xmlfiles.py

@@ -4,6 +4,8 @@ import xml.etree.ElementTree as ET
 import json
 import xmltodict
 
+from seabirdfilehandler.utils import UnexpectedFileFormat
+
 
 class XMLFile(UserDict):
     """
@@ -78,6 +80,58 @@ class XMLCONFile(XMLFile):
 
     def __init__(self, path_to_file):
         super().__init__(path_to_file)
+        self.sensor_info = self.get_sensor_info()
+
+    def get_sensor_info(self) -> list[dict]:
+        """
+        Creates a multilevel dictionary, dropping the first four dictionaries,
+        to retrieve pure sensor information.
+
+        Returns
+        -------
+        A list of all the individual sensor information, stored in dictionaries
+
+        """
+        try:
+            sensors = self.data["SBE_InstrumentConfiguration"]["Instrument"][
+                "SensorArray"
+            ]["Sensor"]
+        except KeyError as error:
+            raise UnexpectedFileFormat("XMLCON", error)
+        else:
+            # create a tidied version of the xml-parsed sensor dict
+            sensor_names = []
+            tidied_sensor_list = []
+            for entry in sensors:
+                sensor_key = list(entry.keys())[-1]
+                if not sensor_key.endswith(("Sensor", "Meter")):
+                    continue
+                sensor_name = sensor_key.removesuffix("Sensor")
+                # the wetlab sensors feature a suffix _Sensor
+                sensor_name = sensor_name.removesuffix("_")
+                # assuming, that the first sensor in the xmlcon is also on the
+                # first sensor strand, the second occurence of the name is
+                # suffixed with '2'
+                if sensor_name in sensor_names:
+                    sensor_name += "2"
+                sensor_names.append(sensor_name)
+                # move the calibration info one dictionary level up
+                calibration_info = entry[sensor_key]
+                # build the new dictionary
+                try:
+                    new_dict = {
+                        "Channel": str(int(entry["@index"]) + 1),
+                        "SensorName": sensor_name,
+                        **calibration_info,
+                    }
+                except TypeError:
+                    new_dict = {
+                        "Channel": entry["@Channel"],
+                        "SensorName": sensor_name,
+                        "Info": calibration_info,
+                    }
+                tidied_sensor_list.append(new_dict)
+            return tidied_sensor_list
 
 
 class PsaFile(XMLFile):

{seabirdfilehandler-0.4.1.dist-info → seabirdfilehandler-0.4.3.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.3
 Name: seabirdfilehandler
-Version: 0.4.1
+Version: 0.4.3
 Summary: Library of parsers to interact with SeaBird CTD files.
 Keywords: CTD,parser,seabird,data
 Author: Emil Michels
 Author-email: <emil.michels@io-warnemuende.de>
-Requires-Python: >=3.12,<3.13
+Requires-Python: >=3.12
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Development Status :: 3 - Alpha
 Classifier: Operating System :: OS Independent
@@ -13,7 +13,8 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Oceanography
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: pandas (>=2.1.1,<2.2)
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: pandas (>=2.2.1)
 Requires-Dist: xmltodict (>=0.13.0)
 Project-URL: Homepage, https://git.io-warnemuende.de/CTD-Software/SeabirdFileHandler
 Project-URL: Repository, https://git.io-warnemuende.de/CTD-Software/SeabirdFileHandler

seabirdfilehandler-0.4.3.dist-info/RECORD

@@ -0,0 +1,14 @@
+seabirdfilehandler/__init__.py,sha256=8Vk2TURWXv2_NG_U_fR0fIVDFymkFkBipvmlS5ucB3M,147
+seabirdfilehandler/dataframe_meta_accessor.py,sha256=x4mSEN49us6Ezzjdt41fl5Ry8IJR09ORrZ1roOIJbyc,6439
+seabirdfilehandler/datatablefiles.py,sha256=yzTAzsWcdrHYaa2QaR6OpdEs-cu2py8V5o79s2Uz7MM,31646
+seabirdfilehandler/file_collection.py,sha256=nWyi5FToCV9-e_zcaLhRb4oOt8KAmyHC-SBGLJO9KQ4,6909
+seabirdfilehandler/logging.yaml,sha256=mXxbhJPio3OGaukTpc3rLGA8Ywq1DNqp0Vn5YCbH6jY,459
+seabirdfilehandler/parameter.py,sha256=UyKb_HGQ57pETdhSfR5FbJ60aOj8_d3_Tgw_akth0TY,13283
+seabirdfilehandler/seabirdfiles.py,sha256=BKLyk5gUMkt1CG4ljDXlCqcr5zej0-9PjPS0sX2E4n8,7449
+seabirdfilehandler/utils.py,sha256=5KXdB8Hdv65dv5tPyXxNMct1mCEOyA3S8XP54AFAnx0,1745
+seabirdfilehandler/validation_modules.py,sha256=eZ6x0giftUtlxnRMOnK_vCkgccdwUXPrDjajFa-E6n0,4698
+seabirdfilehandler/xmlfiles.py,sha256=L_puQf8eg0ojv85AyEMID4jnwkOlV_fgZP3W5yeSUBY,4668
+seabirdfilehandler-0.4.3.dist-info/LICENSE,sha256=Ifd1VPmYv32oJd2QVh3wIQP9X05vYJlcY6kONz360ws,34603
+seabirdfilehandler-0.4.3.dist-info/METADATA,sha256=ODlAzixojiAr_KtwyXVmYlWDn0UJTzFlp_RBAWzLxug,1289
+seabirdfilehandler-0.4.3.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+seabirdfilehandler-0.4.3.dist-info/RECORD,,

seabirdfilehandler-0.4.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-seabirdfilehandler/__init__.py,sha256=8Vk2TURWXv2_NG_U_fR0fIVDFymkFkBipvmlS5ucB3M,147
-seabirdfilehandler/dataframe_meta_accessor.py,sha256=x4mSEN49us6Ezzjdt41fl5Ry8IJR09ORrZ1roOIJbyc,6439
-seabirdfilehandler/datatablefiles.py,sha256=yphs3cFs636-dQ0iPNjonm9-8gNRHvtkBSgVtw-APm4,31307
-seabirdfilehandler/file_collection.py,sha256=andpNZwoVd8gFo4umOBzPn2gR3OQnh6d4_ou0r6zEpM,5889
-seabirdfilehandler/logging.yaml,sha256=mXxbhJPio3OGaukTpc3rLGA8Ywq1DNqp0Vn5YCbH6jY,459
-seabirdfilehandler/parameter.py,sha256=hd7dG0aAhI21GUvW2NioGpeDGV7moRsm_R3mQeAmdmg,12835
-seabirdfilehandler/seabirdfiles.py,sha256=EH23sa4U_pytl3XPcumHU6g-NOzuLSX2KtDIhG7wFsI,7280
-seabirdfilehandler/validation_modules.py,sha256=nwiwfkDLltE3S_aQDlqZrMeiNlGVJP9XNNw0abxgjfc,4691
-seabirdfilehandler/xmlfiles.py,sha256=Es0pUCoB0af-meCH-75h-s-r0mEfrthl-8QDjqNBWPk,2441
-seabirdfilehandler-0.4.1.dist-info/LICENSE,sha256=Ifd1VPmYv32oJd2QVh3wIQP9X05vYJlcY6kONz360ws,34603
-seabirdfilehandler-0.4.1.dist-info/METADATA,sha256=RBi3HJEgQJh68-f_ElkPxfp2N-pekeR-yLsQsO_SYGU,1249
-seabirdfilehandler-0.4.1.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-seabirdfilehandler-0.4.1.dist-info/RECORD,,