seabirdfilehandler 0.5.4__tar.gz → 0.6.0__tar.gz

{seabirdfilehandler-0.5.4 → seabirdfilehandler-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: seabirdfilehandler
-Version: 0.5.4
+Version: 0.6.0
 Summary: Library of parsers to interact with SeaBird CTD files.
 Keywords: CTD,parser,seabird,data
 Author: Emil Michels

{seabirdfilehandler-0.5.4 → seabirdfilehandler-0.6.0}/pyproject.toml

@@ -20,7 +20,7 @@ urls.homepage = "https://ctd-software.pages.io-warnemuende.de/seabirdfilehandler
 urls.repository = "https://git.io-warnemuende.de/CTD-Software/SeabirdFileHandler"
 urls.documentation = "https://ctd-software.pages.io-warnemuende.de/seabirdfilehandler"
 dynamic = []
-version = "0.5.4"
+version = "0.6.0"
 
 [tool.poetry]
 

{seabirdfilehandler-0.5.4 → seabirdfilehandler-0.6.0}/src/seabirdfilehandler/__init__.py

@@ -3,6 +3,8 @@ from .bottlefile import *
 from .bottlelogfile import *
 from .cnvfile import *
 from .xmlfiles import *
+from .hexfile import *
 from .validation_modules import *
-from .file_collection import *
 from .geomar_ctd_file_parser import *
+from .parameter import *
+from .file_collection import *

{seabirdfilehandler-0.5.4 → seabirdfilehandler-0.6.0}/src/seabirdfilehandler/file_collection.py

@@ -9,8 +9,9 @@ from seabirdfilehandler import (
     CnvFile,
     BottleFile,
     BottleLogFile,
+    DataFile,
+    HexFile,
 )
-from seabirdfilehandler import DataFile
 from seabirdfilehandler.utils import get_unique_sensor_data
 
 logger = logging.getLogger(__name__)
@@ -20,6 +21,7 @@ def get_collection(
     path_to_files: Path | str,
     file_suffix: str = "cnv",
     only_metadata: bool = False,
+    pattern: str = "",
     sorting_key: Callable | None = None,
 ) -> Type[FileCollection]:
     """
@@ -33,6 +35,8 @@ def get_collection(
         The suffix to search for. (Default value = "cnv")
     only_metadata : bool :
         Whether to read only metadata. (Default value = False)
+    pattern: str
+        A filter for file selection. (Default value = '')
     sorting_key : Callable | None :
         A callable that returns the filename-part to use to sort the collection. (Default value = None)
     Returns
@@ -44,13 +48,14 @@ def get_collection(
         "cnv": CnvCollection,
         "btl": FileCollection,
         "bl": FileCollection,
+        "hex": HexCollection,
     }
     file_suffix = file_suffix.strip(".")
     try:
         collection = mapping_suffix_to_type[file_suffix](
-            path_to_files, file_suffix, only_metadata, sorting_key
+            path_to_files, file_suffix, only_metadata, pattern, sorting_key
         )
-    except ValueError:
+    except KeyError:
         raise ValueError(f"Unknown input file type: {file_suffix}, aborting.")
     else:
         return collection
@@ -71,6 +76,8 @@ class FileCollection(UserList):
         The suffix to search for. (Default value = "cnv")
     only_metadata : bool :
         Whether to read only metadata. (Default value = False)
+    pattern: str
+        A filter for file selection. (Default value = '')
     sorting_key : Callable | None :
         A callable that returns the filename-part to use to sort the collection. (Default value = None)
     """
@@ -80,14 +87,18 @@ class FileCollection(UserList):
         path_to_files: str | Path,
         file_suffix: str,
         only_metadata: bool = False,
+        pattern: str = "",
         sorting_key: Callable | None = None,
     ):
         super().__init__()
         self.path_to_files = Path(path_to_files)
         self.file_suffix = file_suffix.strip(".")
+        self.pattern = pattern
+        self.sorting_key = sorting_key
         self.file_type = self.extract_file_type(self.file_suffix)
         self.individual_file_paths = self.collect_files(
-            sorting_key=sorting_key
+            pattern=pattern,
+            sorting_key=sorting_key,
         )
         self.data = self.load_files(only_metadata)
         if not only_metadata:
@@ -113,6 +124,7 @@ class FileCollection(UserList):
             "cnv": CnvFile,
             "btl": BottleFile,
             "bl": BottleLogFile,
+            "hex": HexFile,
         }
         file_type = DataFile
         for key, value in mapping_suffix_to_type.items():
@@ -123,6 +135,7 @@ class FileCollection(UserList):
 
     def collect_files(
         self,
+        pattern: str = "",
         sorting_key: Callable | None = lambda file: int(
             file.stem.split("_")[3]
         ),
@@ -135,6 +148,8 @@ class FileCollection(UserList):
 
         Parameters
         ----------
+        pattern: str
+            A filter for file selection. Is given to rglob. (Default value = '')
         sorting_key : Callable | None :
             The part of the filename to use in sorting. (Default value = lambda file: int(file.stem.split("_")[3]))
         Returns
@@ -142,7 +157,7 @@ class FileCollection(UserList):
         A list of all paths found.
         """
         return sorted(
-            self.path_to_files.rglob(f"*{self.file_suffix}"),
+            self.path_to_files.rglob(f"*{pattern}*{self.file_suffix}"),
             key=sorting_key,
         )
 
@@ -161,7 +176,12 @@ class FileCollection(UserList):
         data = []
         for file in self.individual_file_paths:
             try:
-                data.append(self.file_type(file, only_metadata))
+                data.append(
+                    self.file_type(
+                        path_to_file=file,
+                        only_header=only_metadata,
+                    )
+                )
             except TypeError:
                 logger.error(
                     f"Could not open file {file} with the type "
@@ -409,3 +429,64 @@ class CnvCollection(FileCollection):
         return np.concatenate(
             [file.parameters.create_full_ndarray() for file in self.data]
         )
+
+
+class HexCollection(FileCollection):
+    """
+    Specific methods to work with collections of .hex files.
+
+    Especially concerned with the detection of corresponding .XMLCON files.
+    """
+
+    def __init__(
+        self,
+        *args,
+        xmlcon_pattern: str = "",
+        path_to_xmlcons: Path | str = "",
+        **kwargs,
+    ):
+        # force only_metadata, as the hex data cannot be put into a DataFrame
+        kwargs["only_metadata"] = True
+        super().__init__(*args, **kwargs)
+        if not xmlcon_pattern:
+            xmlcon_pattern = self.pattern
+        self.xmlcon_pattern = xmlcon_pattern
+        self.path_to_xmlcons = (
+            Path(path_to_xmlcons)
+            if path_to_xmlcons
+            else self.path_to_files.parent
+        )
+        self.xmlcons = self.get_xmlcons()
+
+    def get_xmlcons(self) -> list[str]:
+        """
+        Returns all .xmlcon files found inside the root directory and its
+        children, matching a given pattern.
+
+        Does use the global sorting_key to attempt to also sort the xmlcons the
+        same way.
+        This is meant to be used in the future for a more specific hex-xmlcon
+        matching.
+
+        Returns
+        -------
+        A list of the found xmlcon filenames.
+        """
+        try:
+            xmlcons = [
+                Path(xmlcon_path).stem
+                for xmlcon_path in sorted(
+                    self.path_to_xmlcons.rglob(
+                        f"*{self.xmlcon_pattern}*.XMLCON"
+                    ),
+                    key=self.sorting_key,
+                )
+            ]
+        except (KeyError, IndexError):
+            xmlcons = [
+                Path(xmlcon_path).stem
+                for xmlcon_path in self.path_to_xmlcons.rglob(
+                    f"*{self.xmlcon_pattern}*.XMLCON"
+                )
+            ]
+        return xmlcons

seabirdfilehandler-0.6.0/src/seabirdfilehandler/hexfile.py

@@ -0,0 +1,71 @@
+from pathlib import Path
+from seabirdfilehandler import DataFile, XMLCONFile
+
+
+class HexFile(DataFile):
+    """
+    A representation of a .hex file as used by SeaBird.
+
+    Parameters
+    ----------
+    path_to_file: Path | str:
+        the path to the file
+    """
+
+    def __init__(
+        self,
+        path_to_file: Path | str,
+        path_to_xmlcon: Path | str = "",
+        *args,
+        **kwargs,
+    ):
+        # force loading only metadata
+        super().__init__(path_to_file, True)
+        self.xmlcon = self.get_corresponding_xmlcon(path_to_xmlcon)
+
+    def get_corresponding_xmlcon(
+        self,
+        path_to_xmlcon: Path | str = "",
+    ) -> XMLCONFile | None:
+        """
+        Finds the best matching .xmlcon file inside the same directory.
+
+        Parameters
+        ----------
+        path_to_xmlcon: Path | str:
+            A fixed path to a xmlcon file. Will be checked.
+        """
+        # xmlcon path given, test and use it
+        if isinstance(path_to_xmlcon, str):
+            if path_to_xmlcon:
+                return XMLCONFile(path_to_xmlcon)
+        else:
+            if path_to_xmlcon.exists():
+                return XMLCONFile(path_to_xmlcon)
+        # no xmlcon path, lets find one in the same dir
+        # get all xmlcons in the dir
+        xmlcons = [
+            xmlcon.stem
+            for xmlcon in self.file_dir.glob("*.XMLCON", case_sensitive=False)
+        ]
+        if not xmlcons:
+            return None
+        # find excact match
+        if self.file_name in xmlcons:
+            return XMLCONFile(
+                self.file_dir.joinpath(self.file_name + ".XMLCON")
+            )
+        # TODO:
+        # otherwise, take the last fitting one in a sorted xmlcon list, or,
+        # the one sharing the same prefix
+        else:
+            same_prefix_xmlcons = [
+                xmlcon
+                for xmlcon in xmlcons
+                if self.file_name.startswith(xmlcon[:5])
+            ]
+            if not same_prefix_xmlcons:
+                return None
+            return XMLCONFile(
+                self.file_dir.joinpath(same_prefix_xmlcons[0] + ".XMLCON")
+            )

{seabirdfilehandler-0.5.4 → seabirdfilehandler-0.6.0}/src/seabirdfilehandler/xmlfiles.py

@@ -33,6 +33,23 @@ class XMLFile(UserDict):
         self.xml_tree = ET.fromstring(self.input)
         self.data = xmltodict.parse(self.input)
 
+    def __eq__(self, other) -> bool:
+        """
+        Allows comparison of two instances of this class.
+
+        Uses the parsed xml information to determine equality.
+
+        Parameters
+        ----------
+        other: XMLFile
+            An instance of this class.
+
+        Returns
+        -------
+        Whether the given instance and this one are equal.
+        """
+        return self.data == other.data
+
     def to_xml(self, file_name=None, file_path=None):
         """
         Writes the dictionary to xml.