tsp 1.4.6__py3-none-any.whl → 1.5.3__py3-none-any.whl

tsp/__init__.py

@@ -1,8 +1,10 @@
 from tsp.core import TSP, IndexedTSP
 from tsp.misc import _is_depth_column
+
 from tsp.plots.static import trumpet_curve, time_series, colour_contour
-from tsp.readers import read_gtnp, read_geotop, read_geoprecision, read_hoboware, read_ntgs, read_logr, read_csv
+from tsp.readers import read_gtnp, read_geotop, read_geoprecision, read_hoboware, read_ntgs, read_logr, read_csv, read_rbr
+from tsp.utils import resolve_duplicate_times
 
 #TSP.__module__ = "teaspoon"
 
-__all__ = ["TSP", "IndexedTSP"]
+__all__ = ["TSP", "IndexedTSP"]

tsp/__meta__.py

@@ -1,3 +1,3 @@
 # Automatically created. Please do not edit.
-__version__ = '1.4.6'
+__version__ = '1.5.3'
 __author__ = 'Nick Brown'

tsp/core.py

@@ -12,10 +12,10 @@ try:
     try:
         from pfit.pfnet_standard import make_temperature_base
     except ModuleNotFoundError:
-        warnings.warn("Missing pfit library. Some functionality will be limited.")
+        warnings.warn("Missing pfit library. Some functionality will be limited.", stacklevel=2)
 
 except ModuleNotFoundError:
-    warnings.warn("Missing netCDF4 library. Some functionality will be limited.")
+    warnings.warn("Missing netCDF4 library. Some functionality will be limited.", stacklevel=2)
 
 from typing import Union, Optional
 from datetime import datetime, tzinfo, timezone, timedelta
@@ -77,9 +77,12 @@ class TSP:
                  latitude: Optional[float]=None, 
                  longitude: Optional[float]=None,
                  site_id: Optional[str]=None,
-                 metadata:dict={}):
+                 metadata: dict={}):
 
         self._times = handle_incoming_times(times)
+        if self._times.duplicated().any():
+            warnings.warn(f"Duplicate timestamps found: {self._times[np.where(self._times.duplicated())[0]]}. That's bad.", stacklevel=2)
+        
         if self.utc_offset:
             self._output_utc_offset = self.utc_offset
         else:
@@ -130,8 +133,14 @@ class TSP:
         
         df = pd.DataFrame({"times": times, "depths": depths, "temperature_in_ground": values, "number_of_observations": number_of_observations})
         df.set_index(["times", "depths"], inplace=True)
-        
-        unstacked = df.unstack()
+
+        try:
+            unstacked = df.unstack()
+        except ValueError as e:
+            if np.any(df.index.duplicated()):
+                print(f"Duplicate data found at {df.iloc[np.where(df.index.duplicated())[0], :].index.get_level_values(0).unique()}")
+            raise e
+
         number_of_observations = unstacked.get('number_of_observations')
         temps = unstacked.get('temperature_in_ground') 
         
@@ -294,7 +303,7 @@ class TSP:
         agg_avg = grouped['temperature_in_ground'].mean().unstack()
         agg_counts = grouped['number_of_observations'].sum().unstack() 
         times = pd.to_datetime(agg_avg.index, format=freq_fmt)
-        
+
         # apply masks
         count_mask = _observation_count_mask(number_of_observations=agg_counts,
                                              min_count=min_count)
@@ -434,6 +443,13 @@ class TSP:
         TSP
             A TSP object with data aggregated to daily averages
         """
+        # if the data is already daily +/- 1min , just return it
+        if np.all(np.isclose(np.diff(self.times).astype('float64'), 
+                            8.64e13,
+                            atol=8.64e13 / (24 * 60 ))):
+            
+            return self
+        
         t = self.__nly(freq_fmt="%Y%m%d", 
                          min_count=min_count,
                          max_gap=max_gap,
@@ -578,7 +594,7 @@ class TSP:
         try:
             ncf = make_temperature_base(file, len(self.depths))
         except NameError:
-            warnings.warn("Missing required packages. Try installing with `pip install tsp[nc]`")
+            warnings.warn("Missing required packages. Try installing with `pip install tsp[nc]`", stacklevel=2)
             return
         
         with nc.Dataset(ncf, 'a') as ncd:
@@ -601,7 +617,7 @@ class TSP:
                 try:
                     ncd.setncattr(key, value)
                 except Exception:
-                    warnings.warn(f"Could not set metadata item: {key}")
+                    warnings.warn(f"Could not set metadata item: {key}", stacklevel=2)
 
     def to_json(self, file: str) -> None:
         """ Write the data to a serialized json file """
@@ -761,7 +777,7 @@ class IndexedTSP(TSP):
         numpy.ndarray
             An array of depth indices
         """
-        warnings.warn("This TSP uses indices (1,2,3,...) instad of depths. Use set_depths() to use measured depths.")
+        warnings.warn("This TSP uses indices (1,2,3,...) instad of depths. Use set_depths() to use measured depths.", stacklevel=2)
         return self._depths
 
     @depths.setter
@@ -799,7 +815,7 @@ def _temporal_gap_mask(grouped: "pd.core.groupby.DataFrameGroupBy", max_gap: int
     numpy.ndarray
         boolean array with ``True`` where measurement spacing or range in group does not satisfy tolerances
     """    
-    max_diff = grouped.time.apply(np.diff).apply(lambda x: np.max(x, initial=0)).apply(lambda x: x.total_seconds())
+    max_diff = grouped.time.apply(np.diff).apply(lambda x: np.max(x, initial=np.timedelta64(0))).apply(lambda x: x.total_seconds())
     max_diff = max_diff.unstack().to_numpy()
     diff_mask = np.where((max_diff == 0) | (max_diff >= max_gap), True, False)
     

tsp/dataloggers/FG2.py

@@ -75,6 +75,8 @@ class FG2(AbstractReader):
         self.DATA = self.DATA.drop(["NO"], axis=1)
         self.DATA = self.drop_hk(self.DATA)
 
+        self.META.update(parse_fg2_meta_lines(self.META['raw']))
+
         return self.DATA
 
     def _is_metadata(self, line) -> bool:
@@ -96,3 +98,14 @@ class FG2(AbstractReader):
 
     def drop_hk(self, df: "pd.DataFrame") -> "pd.DataFrame":
         return df.drop([c for c in df if self._is_hk(c)], axis=1)
+
+
+def parse_fg2_meta_lines(meta: "list[str]") -> dict:
+    parsed = dict()
+    serial = re.compile(r"LOGGER: \$([\w]{6})")
+
+    for line in meta:
+        if serial.match(line):
+            parsed["logger_serial_number"] = serial.match(line).group(1)
+
+    return parsed

tsp/dataloggers/GP5W.py

@@ -83,6 +83,8 @@ class GP5W(AbstractReader):
         self.DATA = self.DATA.drop(["No"], axis=1)
         self.DATA = self.drop_hk(self.DATA)
 
+        self.META.update(parse_gp5w_meta_lines(self.META['raw']))
+
         return self.DATA
 
     def _is_observation(self, line: str) -> bool:
@@ -99,4 +101,15 @@ class GP5W(AbstractReader):
         return False
 
     def drop_hk(self, df: "pd.DataFrame") -> "pd.DataFrame":
-        return df.drop([c for c in df if self._is_hk(c)], axis=1)
+        return df.drop([c for c in df if self._is_hk(c)], axis=1)
+
+
+def parse_gp5w_meta_lines(meta: "list[str]") -> dict:
+    parsed = dict()
+    serial = re.compile(r"Logger: \#([\w]{6})")
+
+    for line in meta:
+        if serial.match(line):
+            parsed["logger_serial_number"] = serial.match(line).group(1)
+
+    return parsed

tsp/dataloggers/RBRXL800.py

@@ -0,0 +1,190 @@
+import pathlib
+import warnings
+import numpy as np
+import pandas as pd
+import datetime as dt
+from .AbstractReader import AbstractReader
+
+
+class RBRXL800(AbstractReader):
+
+    def read(self, file_path: str) -> "pd.DataFrame":
+        """
+
+        Parameters
+        ----------
+        file
+
+        Returns
+        -------
+
+        """
+        file_extention = pathlib.Path(file_path).suffix.lower()
+        if file_extention not in [".dat", ".hex"]:
+            raise IOError("Unrecognised file. File is not a .dat or .hex")
+
+        with open(file_path, "r") as f:
+            header_lines = [next(f) for i in range(18)]
+            self._parse_meta(header_lines)
+
+            data_lines = f.readlines()
+            if file_extention == ".dat":
+                if data_lines[0] == "\n" or len(data_lines[0].split()) == self.META["num channels"] + 2:
+                    self._read_daily_dat_format(data_lines)
+                else:
+                    if len(data_lines[0].split()) == 1 + self.META["num channels"]:
+                        self._read_standard_dat_format(data_lines, True)
+                    elif len(data_lines[0].split()) == self.META["num channels"]:
+                        self._read_standard_dat_format(data_lines, False)
+                    else:
+                        raise RuntimeError("Error: Number of column names and number of columns do not match any"
+                                           "expected pattern.")
+
+            elif file_extention == ".hex":
+                self.META["num bytes"] = int(data_lines[0].split()[-1])
+                data_lines = data_lines[1:]
+                self._read_standard_hex_format(data_lines)
+
+            if len(self.DATA.index) != self.META["num samples"]:
+                warnings.warn(f"{file_path} Mismatch between number of samples in specified header "
+                              f"({self.META['num samples']}) and number of samples read {len(self.DATA.index)}. Some "
+                              "data may be missing")
+        return self.DATA
+
+    def _parse_meta(self, header_lines: list):
+        self.META["logger model"] = header_lines[0].split()[1]
+        self.META["logger SN"] = header_lines[0].split()[3]
+        sample_interval = dt.datetime.strptime(header_lines[5].split()[-1], "%H:%M:%S")
+        self.META["sample interval"] = dt.timedelta(hours=sample_interval.hour, minutes=sample_interval.minute,
+                                                    seconds=sample_interval.second)
+        # try:
+        self.META["logging start"] = dt.datetime.strptime(" ".join(header_lines[3].split()[-2:]), "%y/%m/%d %H:%M:%S")
+        """
+        except ValueError:
+            date = header_lines[3].split()[-2]
+            if "00" in date.split("/"):
+                warnings.warn("Invalid logging start date given in header. Logger may have experienced power issues and"
+                              "data may be corrupt")"""
+
+        line_7_info = header_lines[6].split(",")
+        self.META["num channels"] = int(line_7_info[0].split()[-1])
+        self.META["num samples"] = int(line_7_info[1].split()[-1])
+        self.META["precision"] = int(header_lines[9].split("%")[1][-2])
+
+        self.META["calibration parameters"] = {}
+        calibration_start_line = 10
+        for i in range(self.META["num channels"]):
+            self.META["calibration parameters"][f"channel {i + 1}"] = {}
+            line_num = calibration_start_line + i
+            raw_calibration = header_lines[line_num].split()
+            if raw_calibration[1] != "2":
+                raise ValueError(f"Calibration equation #{raw_calibration[1]} currently unsupported.")
+            self.META["calibration parameters"][f"channel {i + 1}"]["a0"] = float(raw_calibration[2])
+            self.META["calibration parameters"][f"channel {i + 1}"]["a1"] = float(raw_calibration[3])
+            self.META["calibration parameters"][f"channel {i + 1}"]["a2"] = float(raw_calibration[4])
+            if raw_calibration[5] == "0":
+                self.META["calibration parameters"][f"channel {i + 1}"]["a3"] = 1
+            else:
+                self.META["calibration parameters"][f"channel {i + 1}"]["a3"] = float(raw_calibration[2])
+        self.META['raw'] = "".join(header_lines)
+        return
+
+    def _read_daily_dat_format(self, raw_data: list):
+        """
+
+        Parameters
+        ----------
+        raw_data
+
+        Returns
+        -------
+
+        """
+        self.DATA = pd.DataFrame(columns=[f"channel {i + 1}" for i in range(self.META["num channels"])])
+        for line in raw_data:
+            if line != "\n":
+                if len(line) == 20 or len(line.split()) == self.META["num channels"] + 2:
+                    date_stamp = dt.datetime.strptime(" ".join(line.split()[0:2]), "%Y/%m/%d %H:%M:%S")
+                    interval_num = 0
+                elif len(line.split()) == self.META["num channels"] + 1:
+                    self.DATA.loc[date_stamp + self.META["sample interval"] * interval_num] = line.split()[1:]
+                    interval_num += 1
+                else:
+                    self.DATA.loc[date_stamp + self.META["sample interval"] * interval_num] = line.split()
+                    interval_num += 1
+        for col in self.DATA:
+            self.DATA[col] = pd.to_numeric(self.DATA[col], errors='coerce')
+        self.DATA.reset_index(inplace=True)
+        self.DATA.rename(columns={"index": "TIME"}, inplace=True)
+        return
+
+    def _read_standard_hex_format(self, raw_data: list):
+        byte_list = []
+        for line in raw_data:
+            eight_bytes = [line[i: i + 4] for i in range(0, len(line), 4)][:-1]
+            for byte in eight_bytes:
+                byte_list.append(byte)
+        byte_num = 0
+        self.DATA = pd.DataFrame(columns=[f"channel {i + 1}" for i in range(self.META["num channels"])])
+        line_num = 0
+        prev_line_day = 0
+        for line in range(self.META["num samples"]):
+            line_time = self.META["logging start"] + self.META["sample interval"] * line_num
+            if line_time.day != prev_line_day:
+                byte_num += 7
+                prev_line_day = line_time.day
+            line_bytes = byte_list[byte_num: byte_num + 8]
+            line_temps = []
+            for channel in range(len(line_bytes)):
+                hex_val = line_bytes[channel]
+                first_digit = hex_val[0]
+                if first_digit == "0":
+                    data_val = -int(hex_val[1:], 16)
+                if first_digit == "2":
+                    data_val = int(hex_val[1:], 16)
+                elif first_digit in ["1", "3"]:
+                    data_val = np.nan
+                if not np.isnan(data_val) and data_val > 0:
+                    a0 = self.META["calibration parameters"][f"channel {channel + 1}"]["a0"]
+                    a1 = self.META["calibration parameters"][f"channel {channel + 1}"]["a1"]
+                    a2 = self.META["calibration parameters"][f"channel {channel + 1}"]["a2"]
+                    a3 = self.META["calibration parameters"][f"channel {channel + 1}"]["a3"]
+                    y = a2 * ((2048 * (a3 / data_val)) - 1)
+                    temp = (a1 / ((a1 / 273.15) - np.log(a0 / y))) - 273.15
+                    line_temps.append(round(temp, self.META["precision"]))
+                else:
+                    line_temps.append(np.nan)
+            self.DATA.loc[line_time] = line_temps
+            byte_num += 8
+            line_num += 1
+        for col in self.DATA:
+            self.DATA[col] = pd.to_numeric(self.DATA[col], errors='coerce')
+        self.DATA.reset_index(inplace=True)
+        self.DATA.rename(columns={"index": "TIME"}, inplace=True)
+        return
+
+    def _read_standard_dat_format(self, raw_data: list, line_numbers=False):
+        """
+
+        Parameters
+        ----------
+        raw_data
+        line_numbers
+
+        Returns
+        -------
+
+        """
+        self.DATA = pd.DataFrame(columns=[f"channel {i + 1}" for i in range(self.META["num channels"])])
+        line_num = 0
+        for line in raw_data:
+            line_data = line.split()
+            if line_numbers:
+                line_data = line_data[1:]
+            self.DATA.loc[self.META["logging start"] + self.META["sample interval"] * line_num] = line_data
+            line_num += 1
+        for col in self.DATA:
+            self.DATA[col] = pd.to_numeric(self.DATA[col], errors='coerce')
+        self.DATA.reset_index(inplace=True)
+        self.DATA.rename(columns={"index": "TIME"}, inplace=True)
+        return

tsp/dataloggers/RBRXR420.py

@@ -0,0 +1,307 @@
+import sqlite3
+import pathlib
+import warnings
+import numpy as np
+import pandas as pd
+import datetime as dt
+try:
+    from pyrsktools import RSK
+except ModuleNotFoundError:
+    warnings.warn("Missing pyRSKtools library. .rsk files can not be imported.")
+from .AbstractReader import AbstractReader
+
+
+class RBRXR420(AbstractReader):
+
+    def read(self, file_path: str) -> "pd.DataFrame":
+        """
+
+        Parameters
+        ----------
+        file_path
+
+        Returns
+        -------
+
+        """
+        file_extention = pathlib.Path(file_path).suffix.lower()
+        if file_extention in [".dat", ".hex"]:
+            with open(file_path, "r") as f:
+                first_50 = [next(f) for i in range(50)]
+                for line_num in range(len(first_50)):
+                    if first_50[line_num].lower().startswith("logger start:"):
+                        header_length = line_num + 1
+                        break
+
+            with open(file_path, "r") as f:
+                header_lines = [next(f) for i in range(header_length)]
+                self._parse_meta(header_lines)
+
+                data_lines = f.readlines()
+                if file_extention == ".dat":
+                    line_num = 0
+                    for line_num in range(len(data_lines)):
+                        if data_lines[line_num] != "\n":
+                            split_line = data_lines[line_num].split()
+                        else:
+                            split_line = ["no data"]
+                        if split_line[0].lower() == "temp":
+                            break
+                    if line_num == len(data_lines) - 1:
+                        raise RuntimeError("No column names found")
+                    data_lines = data_lines[line_num:]
+                    first_line = data_lines[0].split()
+                    second_line = data_lines[1].split()
+
+                    if len(first_line) == len(second_line):
+                        self._read_standard_dat_format(data_lines[1:], False)
+                    elif len(first_line) + 2 == len(second_line):
+                        try:
+                            is_datetime = bool(dt.datetime.strptime(" ".join(second_line[:2]), "%Y/%m/%d %H:%M:%S"))
+                        except ValueError:
+                            is_datetime = False
+                        if is_datetime:
+                            self._read_standard_dat_format(data_lines[1:], True)
+                        else:
+                            raise RuntimeError("Error, expected date time with format %Y/%m/%d %H:%M:%S at start of"
+                                               "row.")
+                    else:
+                        raise RuntimeError("Error: Number of column names and number of columns do not match any"
+                                           "expected pattern.")
+
+                else:
+                    self._read_standard_hex_format(data_lines)
+        elif file_extention == ".xls":
+            self._read_standard_xls_format(file_path)
+        elif file_extention == ".xlsx":
+            self._read_standard_xlsx_format(file_path)
+        elif file_extention == ".rsk":
+            self._read_standard_rsk_format(file_path)
+        else:
+            raise IOError("Unrecognised file. File is not a .dat, .hex, .xls, .xlsx, or .rsk.")
+        return self.DATA
+
+    def _parse_meta(self, header_lines: list):
+        self.META["logger model"] = header_lines[0].split()[1]
+        self.META["logger SN"] = header_lines[0].split()[3]
+        sample_interval = dt.datetime.strptime(header_lines[5].split()[-1], "%H:%M:%S")
+        self.META["sample interval"] = dt.timedelta(hours=sample_interval.hour, minutes=sample_interval.minute,
+                                                    seconds=sample_interval.second)
+        self.META["logging start"] = dt.datetime.strptime(" ".join(header_lines[3].split()[-2:]),
+                                                          "%y/%m/%d %H:%M:%S")
+        line_7_info = header_lines[6].split(",")
+        self.META["num channels"] = int(line_7_info[0].split()[-1])
+        self.META["num samples"] = int(line_7_info[1].split()[-1])
+        formatting = header_lines[7].split("%")[1]
+        if formatting.endswith("\n"):
+            self.META["precision"] = int(formatting[-3])
+        else:
+            self.META["precision"] = int(formatting[-2])
+
+        self.META["calibration parameters"] = {}
+        calibration_start_line = 8
+        for i in range(self.META["num channels"]):
+            self.META["calibration parameters"][f"channel {i + 1}"] = {}
+            for j in range(4):
+                line_num = calibration_start_line + 4 * i + j
+                if header_lines[line_num].lower().startswith("calibration"):
+                    self.META["calibration parameters"][f"channel {i + 1}"][chr(ord("a") + j)]\
+                        = float(header_lines[line_num].split()[-1])
+                else:
+                    self.META["calibration parameters"][f"channel {i + 1}"][chr(ord("a") + j)] \
+                        = float(header_lines[line_num].split()[0])
+
+        self.META['raw'] = "".join(header_lines)
+        return
+
+    def _read_standard_dat_format(self, raw_data: list, time_stamps: bool = False):
+        """
+
+        Parameters
+        ----------
+        raw_data
+        line_numbers
+
+        Returns
+        -------
+
+        """
+        self.DATA = pd.DataFrame(columns=[f"channel {i + 1}" for i in range(self.META["num channels"])])
+        line_num = 0
+        for line in raw_data:
+            line_data = line.split()
+            if time_stamps:
+                self.DATA.loc[dt.datetime.strptime(" ".join(line_data[:2]), "%Y/%m/%d %H:%M:%S")] = line_data[2:]
+            else:
+                self.DATA.loc[self.META["logging start"] + self.META["sample interval"] * line_num] = line_data
+            line_num += 1
+        for col in self.DATA:
+            self.DATA[col] = pd.to_numeric(self.DATA[col], errors='coerce')
+        self.DATA.reset_index(inplace=True)
+        self.DATA.rename(columns={"index": "TIME"}, inplace=True)
+        return
+
+    def _read_standard_hex_format(self, raw_data: list):
+        """
+
+        Parameters
+        ----------
+        raw_data
+
+        Returns
+        -------
+
+        """
+        for line_num in range(len(raw_data)):
+            if raw_data[line_num].lower().startswith("number of bytes of data"):
+                hex_header_length = line_num + 2
+                break
+            elif raw_data[line_num].lower().startswith("number of bytes in header"):
+                header_bytes = int(raw_data[line_num].split()[-1])
+        num_hex_header_values = int(header_bytes / 3)
+        hex_vals = []
+        raw_data = raw_data[hex_header_length:]
+        for line_num in range(len(raw_data)):
+            line = raw_data[line_num]
+            line_hex_vals = [line[i: i + 6] for i in range(0, len(line), 6)][:-1]
+            for hex_val in line_hex_vals:
+                hex_vals.append(hex_val)
+        hex_vals = hex_vals[num_hex_header_values:]
+
+        self.DATA = pd.DataFrame(columns=[f"channel {i + 1}" for i in range(self.META["num channels"])])
+        line_num = 0
+        hex_num = 0
+        for line in range(self.META["num samples"]):
+            line_time = self.META["logging start"] + self.META["sample interval"] * line_num
+            time_hex_vals = hex_vals[hex_num: hex_num + 8]
+            line_vals = [int(h, 16) / int("FFFFFF", 16) for h in time_hex_vals]
+            line_temps = []
+            for channel in range(len(line_vals)):
+                val = line_vals[channel]
+                if val not in [0, 1]:
+                    a = self.META["calibration parameters"][f"channel {channel + 1}"]["a"]
+                    b = self.META["calibration parameters"][f"channel {channel + 1}"]["b"]
+                    c = self.META["calibration parameters"][f"channel {channel + 1}"]["c"]
+                    d = self.META["calibration parameters"][f"channel {channel + 1}"]["d"]
+                    x = np.log((1 / val) - 1)
+                    temp = 1 / (a + b * x + c * x**2 + d * x**3) - 273.15
+                    line_temps.append(round(temp, self.META["precision"]))
+                else:
+                    line_temps.append(np.nan)
+            self.DATA.loc[line_time] = line_temps
+            line_num += 1
+            hex_num += 8
+        for col in self.DATA:
+            self.DATA[col] = pd.to_numeric(self.DATA[col], errors='coerce')
+        self.DATA.reset_index(inplace=True)
+        self.DATA.rename(columns={"index": "TIME"}, inplace=True)
+        return
+
+    def _read_standard_xls_format(self, file_path: str):
+        xls = pd.ExcelFile(file_path)
+        sheet = xls.sheet_names[0]
+        xls.close()
+        raw_data = pd.read_excel(file_path, sheet, header=None)
+        raw_meta = raw_data.iloc[:5].copy()
+        if raw_meta.iloc[0, 0] != "RBR data file":
+            raise IOError("Not a valid .xls file")
+        meta = {}
+        for i, r in raw_meta.iterrows():
+            for j in range(0, len(r) - 1, 2):
+                if not pd.isna(raw_meta.iloc[i, j]):
+                    meta[raw_meta.iloc[i, j]] = raw_meta.iloc[i, j + 1]
+        self.META["logger model"] = meta["Model:"]
+        self.META["logger SN"] = meta["Serial Number:"]
+        self.META["sample interval"] = dt.timedelta(seconds=int(meta["Logging sampling period (s):"]))
+        self.META["logging start"] = dt.datetime.strptime(meta["Logging start time:"], "%Y/%m/%d")
+
+        column_names = {}
+        for col in raw_data:
+            if col == 0:
+                col_name = "TIME"
+            else:
+                col_name = f"channel {col}"
+            column_names[col] = col_name
+        self.DATA = raw_data.iloc[6:].copy()
+        self.DATA.reset_index(drop=True, inplace=True)
+        self.DATA.rename(columns=column_names, inplace=True)
+        for col in self.DATA:
+            if col == "TIME":
+                self.DATA["TIME"] = pd.to_datetime(self.DATA["TIME"], format="%d/%m/%Y %H:%M:%S.%f")
+            else:
+                self.DATA[col] = pd.to_numeric(self.DATA[col], errors='coerce')
+        return
+
+    def _read_standard_xlsx_format(self, file_path: str):
+        meta_table = {"Instrument": pd.read_excel(file_path, sheet_name="Metadata", header=9, nrows=1),
+                      "Schedule": pd.read_excel(file_path, sheet_name="Metadata", header=24, nrows=1),
+                      "Sampling": pd.read_excel(file_path, sheet_name="Metadata", header=28, nrows=1)}
+        self.META["logger model"] = meta_table["Instrument"]["Model"].loc[0]
+        self.META["logger SN"] = meta_table["Instrument"]["Serial"].loc[0]
+        self.META["sample interval"] = dt.timedelta(seconds=int(meta_table["Sampling"]["Period"].loc[0]))
+        self.META["logging start"] = meta_table["Schedule"]["Start time"].loc[0]
+
+        self.DATA = pd.read_excel(file_path, sheet_name="Data", header=1)
+
+        column_names = {}
+        for col in self.DATA:
+            if col == "Time":
+                col_name = "TIME"
+            elif col == "Temperature":
+                col_name = "channel 1"
+            else:
+                col_name = f"channel {int(col.split('.')[-1]) + 1}"
+            column_names[col] = col_name
+        self.DATA.rename(columns=column_names, inplace=True)
+
+        for col in self.DATA:
+            if col == "TIME":
+                self.DATA["TIME"] = pd.to_datetime(self.DATA["TIME"], format="%Y-%m-%d %H:%M:%S.%f")
+            else:
+                self.DATA[col] = pd.to_numeric(self.DATA[col], errors='coerce')
+        return
+
+    def _read_standard_rsk_format(self, file_path: str):
+        raw_meta = {}
+        try:
+            with RSK(file_path) as rsk:
+                rsk.open()
+                rsk.readdata()
+                rsk_data = rsk.data
+                raw_meta["calibration"] = rsk.calibrations
+                raw_meta["instrument"] = rsk.instrument
+                raw_meta["schedule"] = rsk.scheduleInfo
+                raw_meta["parameter key"] = rsk.parameterKeys
+                raw_meta["epoch"] = rsk.epoch
+        except NameError:
+            raise ModuleNotFoundError("You must install pyRSKtools")
+        except sqlite3.OperationalError:
+            raise RuntimeError("An error occurred when opening the .rsk file. Try opening the .rsk file in the ruskin\n"
+                               " software then rerunning the code.")
+        self.DATA = pd.DataFrame(rsk_data)
+
+        self.META["logger model"] = raw_meta["instrument"].model
+        self.META["logger SN"] = raw_meta["instrument"].serialID
+        self.META["sample interval"] = dt.timedelta(seconds=raw_meta["schedule"].samplingPeriod/1000)
+        self.META["logging start"] = raw_meta["epoch"].startTime
+        self.META["utc offset"] = [int(float(element.value) * 3600) for element in raw_meta["parameter key"]
+                                   if element.key == "OFFSET_FROM_UTC"][0]
+        self.META["calibration parameters"] = {}
+        for cal in raw_meta["calibration"]:
+            self.META["calibration parameters"][f"channel {cal.channelOrder}"] = {}
+            self.META["calibration parameters"][f"channel {cal.channelOrder}"]["a"] = cal.c[0]
+            self.META["calibration parameters"][f"channel {cal.channelOrder}"]["b"] = cal.c[1]
+            self.META["calibration parameters"][f"channel {cal.channelOrder}"]["c"] = cal.c[2]
+            self.META["calibration parameters"][f"channel {cal.channelOrder}"]["d"] = cal.c[3]
+
+        column_names = {}
+        for col in self.DATA:
+            if col == "timestamp":
+                col_name = "TIME"
+            elif col == "temperature":
+                col_name = "channel 1"
+            else:
+                col_name = f"channel {int(col[-1]) + 1}"
+            column_names[col] = col_name
+        self.DATA.rename(columns=column_names, inplace=True)
+        return