seabirdfilehandler 0.7.7__tar.gz → 0.8.0__tar.gz

{seabirdfilehandler-0.7.7 → seabirdfilehandler-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seabirdfilehandler
-Version: 0.7.7
+Version: 0.8.0
 Summary: Library of parsers to interact with SeaBird CTD files.
 License-File: LICENSE
 Keywords: CTD,parser,seabird,data

{seabirdfilehandler-0.7.7 → seabirdfilehandler-0.8.0}/pyproject.toml

@@ -23,7 +23,7 @@ urls.documentation = "https://ctd-software.pages.io-warnemuende.de/seabirdfileha
 dynamic = []
 requires-python = ">=3.12"
 dependencies = ["pandas>=2.2.1", "xmltodict>=0.13.0"]
-version = "0.7.7"
+version = "0.8.0"
 
 [project.optional-dependencies]
 test = ["pytest>=8.3.0", "parameterized>=0.9.0", "pre-commit>=3.6.2"]

{seabirdfilehandler-0.7.7 → seabirdfilehandler-0.8.0}/src/seabirdfilehandler/file_collection.py

@@ -417,13 +417,25 @@ class CnvCollection(FileCollection):
         A list of dictionaries that represent the data column information.
         """
         all_column_descriptions = [
-            file.parameters.metadata for file in self.data
+            file.parameters.get_metadata() for file in self.data
         ]
-        for info in all_column_descriptions:
+        for index, info in enumerate(all_column_descriptions):
             if all_column_descriptions[0] != info:
-                raise AssertionError(
-                    "Acting on differently formed data files, aborting"
-                )
+                for expected, real in zip(
+                    all_column_descriptions[0].items(), info.items()
+                ):
+                    # allow difference in latitude inside depth
+                    if expected[0] == "depSM":
+                        if real[0] != "depSM":
+                            raise AssertionError(
+                                f"Data files {self.data[0].path_to_file} and {self.data[index].path_to_file} differ in:\n{expected} and {real}"
+                            )
+
+                    elif expected != real:
+                        raise AssertionError(
+                            f"Data files {self.data[0].path_to_file} and {self.data[index].path_to_file} differ in:\n{expected} and {real}"
+                        )
+
         return all_column_descriptions[0]
 
     def get_array(self) -> np.ndarray:
@@ -435,7 +447,7 @@ class CnvCollection(FileCollection):
         A numpy array, representing the data of all input files.
         """
         return np.concatenate(
-            [file.parameters.create_full_ndarray() for file in self.data]
+            [file.parameters.get_full_data_array() for file in self.data]
         )
 
     def get_processing_steps(self) -> list:

{seabirdfilehandler-0.7.7 → seabirdfilehandler-0.8.0}/src/seabirdfilehandler/parameter.py

@@ -36,18 +36,30 @@ class Parameters(UserDict):
         metadata: list,
         only_header: bool = False,
     ):
-        self.raw_input_data = data
-        self.raw_metadata = metadata
-        self.differentiate_table_description()
-        self.metadata, self.duplicate_columns = self.reading_data_header(
+        self.data = {}
+        self.differentiate_table_description(metadata)
+        parsed_metadata, self.duplicate_columns = self.reading_data_header(
             metadata
         )
         if not only_header:
-            self.full_data_array = self.create_full_ndarray()
-            self.data = self.create_parameter_instances()
+            self.full_data_array = self.create_full_ndarray(data)
+            self.create_parameter_instances(
+                self.full_data_array, parsed_metadata
+            )
+
+    def get_full_data_array(self) -> np.ndarray:
+        return np.array(
+            [parameter.data for parameter in self.data.values()], dtype=float
+        ).T
 
-    def get_parameter_names(self) -> list[str]:
-        return [parameter["name"] for parameter in self.metadata.values()]
+    def get_names(self) -> list[str]:
+        return [parameter.name for parameter in self.data.values()]
+
+    def get_metadata(self) -> dict[str, dict]:
+        return {
+            parameter.name: parameter.metadata
+            for parameter in self.data.values()
+        }
 
     def get_parameter_list(self) -> list[Parameter]:
         """ """
@@ -68,9 +80,6 @@ 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
-        )
         n = 11
         row_list = []
         for line in data_table:
@@ -84,7 +93,8 @@ class Parameters(UserDict):
 
     def create_parameter_instances(
         self,
-        metadata: dict[str, dict] = {},
+        array_data: np.ndarray,
+        metadata: dict[str, dict],
     ) -> dict[str, Parameter]:
         """
         Differentiates the individual parameter columns into separate parameter
@@ -101,30 +111,24 @@ class Parameters(UserDict):
         A dictionary of parameter instances
 
         """
-        metadata = (
-            self.metadata if len(list(metadata.keys())) == 0 else metadata
-        )
         parameter_dict = {}
         list_of_metadata_shortnames = list(metadata.keys())
         # if column number and metadata number is different, we are propably
         # working with duplicate_columns and will drop the duplicates
-        if self.full_data_array.shape[1] != len(list_of_metadata_shortnames):
-            self.full_data_array = np.delete(
-                self.full_data_array, self.duplicate_columns, 1
-            )
-            assert self.full_data_array.shape[1] == len(
-                list_of_metadata_shortnames
-            )
+        if array_data.shape[1] != len(list_of_metadata_shortnames):
+            array_data = np.delete(array_data, self.duplicate_columns, 1)
+            assert array_data.shape[1] == len(list_of_metadata_shortnames)
             # rewrite the column number in the metadata header
             self.data_table_stats["nquan"] = str(
                 int(self.data_table_stats["nquan"])
                 - len(self.duplicate_columns)
             )
-        for i in range(self.full_data_array.shape[1]):
-            column_data = self.full_data_array[:, i]
+        for i in range(array_data.shape[1]):
             key = list_of_metadata_shortnames[i]
-            parameter_dict[key] = Parameter(
-                data=column_data, metadata=metadata[key]
+            parameter_dict[key] = self.create_parameter(
+                data=array_data[:, i],
+                metadata=metadata[key],
+                name=key,
             )
         return parameter_dict
 
@@ -132,17 +136,25 @@ class Parameters(UserDict):
         """Recreates the data table descriptions, like column names and spans
         from the structured dictionaries these values were stored in."""
         new_table_info = []
-        for key, value in self.data_table_stats.items():
-            new_table_info.append(f"{key} = {value}\n")
-        for index, (name, _) in enumerate(self.data_table_names_and_spans):
-            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")
+        # 'data table stats'
+        data_array = self.get_full_data_array()
+        new_table_info.append(f"nquan = {data_array.shape[1]}")
+        new_table_info.append(f"nvalues = {data_array.shape[0]}")
+        new_table_info.append(f"units = {self.data_table_stats['units']}\n")
+        # 'data tables names'
+        for index, metadata in enumerate(self.get_metadata().values()):
+            new_table_info.append(
+                f"name {index} = {metadata['shortname']}: {metadata['longinfo']}\n"
+            )
+        # 'data table spans'
+        for index, (minimum, maximum) in enumerate(self.get_spans()):
+            new_table_info.append(f"span {index} = {minimum}, {maximum}\n")
+        # '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 differentiate_table_description(self):
+    def differentiate_table_description(self, metadata: list):
         """
         The original method that structures data table metadata.
 
@@ -153,7 +165,7 @@ class Parameters(UserDict):
         column_names = []
         column_value_spans = []
         post = []
-        for line in self.raw_metadata:
+        for line in metadata:
             if line.startswith("name"):
                 column_names.append(line.split("=", 1)[1].strip())
             elif line.startswith("span"):
@@ -188,31 +200,18 @@ class Parameters(UserDict):
             The new parameter
 
         """
-        position_index = -1
-        # add to parameter dict at given
+        # add to parameter dict at given position
         if position:
             new_dict = {}
-            for index, (key, value) in enumerate(self.data.items()):
+            for key, value in self.data.items():
                 new_dict[key] = value
                 if key == position:
                     new_dict[parameter.name] = parameter
-                    position_index = index + 1
             self.data = new_dict
 
         else:
             self.data[parameter.name] = parameter
 
-        # update metadata dict
-        self.metadata = {
-            parameter.name: parameter.metadata
-            for parameter in self.data.values()
-        }
-        # add to the data array if data
-        if parameter.type == "data":
-            self.full_data_array = np.insert(
-                self.full_data_array, position_index, parameter.data, axis=1
-            )
-
     def create_parameter(
         self,
         data: np.ndarray | int | float | str | None,
@@ -357,17 +356,17 @@ class Parameters(UserDict):
 
 
         """
-        if len(header_info) == 0:
-            header_info = self.raw_metadata
         table_header = {}
         duplicate_columns = []
         for line in header_info:
             if line.startswith("name"):
                 header_meta_info = {}
                 # get basic shortname and the full, non-differentiated info
-                shortname = longinfo = line_info = line.split("=")[1].strip()
+                shortname = longinfo = line_info = line.split("=", 1)[
+                    1
+                ].strip()
                 try:
-                    shortname, longinfo = line_info.split(":")
+                    shortname, longinfo = line_info.split(":", 1)
                 except IndexError:
                     pass
                 finally:
@@ -375,7 +374,7 @@ class Parameters(UserDict):
                     if shortname in list(table_header.keys()):
                         try:
                             duplicate_columns.append(
-                                int(line.split("=")[0].strip().split()[1])
+                                int(line.split("=", 1)[0].strip().split()[1])
                             )
                         except IndexError as error:
                             logger.error(
@@ -452,6 +451,9 @@ class Parameter:
         self.data = data
         self.metadata = metadata
         self.name = metadata["shortname"]
+        self.param = re.split(r"[,\s]", metadata["name"])[0]
+        self.sensor_number = 2 if metadata["name"][-1] == "2" else 1
+        self.unit = metadata["unit"]
         self.type = "data" if self.data.dtype in ["float", "int"] else "meta"
         self.parse_to_float()
         self.update_span()