water-column-sonar-processing 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

{zarr_manager → water_column_sonar_processing/model}/zarr_manager.py

@@ -1,27 +1,28 @@
 import os
-import zarr
+
 import numcodecs
 import numpy as np
 import xarray as xr
+import zarr
 from numcodecs import Blosc
 
-from utility.constants import Constants, Coordinates
-from utility.timestamp import Timestamp
-from aws_manager.s3fs_manager import S3FSManager
+from water_column_sonar_processing.aws.s3fs_manager import S3FSManager
+from water_column_sonar_processing.utility.constants import Constants, Coordinates
+from water_column_sonar_processing.utility.timestamp import Timestamp
 
 numcodecs.blosc.use_threads = False
 numcodecs.blosc.set_nthreads(1)
 
 
-# TODO: when ready switch to version 3 of zarr_manager spec
+# TODO: when ready switch to version 3 of model spec
 # ZARR_V3_EXPERIMENTAL_API = 1
 
-# creates the latlon data: foo = ep.consolidate.add_location(ds_Sv, echodata)
 
+# creates the latlon data: foo = ep.consolidate.add_location(ds_Sv, echodata)
 class ZarrManager:
     #######################################################
     def __init__(
-            self,
+        self,
     ):
         # TODO: revert to Blosc.BITSHUFFLE, troubleshooting misc error
         self.__compressor = Blosc(cname="zstd", clevel=2)  # shuffle=Blosc.NOSHUFFLE
@@ -33,18 +34,18 @@ class ZarrManager:
     #######################################################
     @staticmethod
     def get_depth_values(
-            min_echo_range: float = 1.,  # minimum depth measured (zero non-inclusive) from whole cruise
-            max_echo_range: float = 100.,  # maximum depth measured from whole cruise
+        min_echo_range: float = 1.0,  # minimum depth measured (zero non-inclusive) from whole cruise
+        max_echo_range: float = 100.0,  # maximum depth measured from whole cruise
     ):
         # Gets the set of depth values that will be used when resampling and
-        # regridding the data to a cruise level zarr_manager store.
+        # regridding the data to a cruise level model store.
         # Note: returned values do not start at zero.
-        print('Getting depth values.')
+        print("Getting depth values.")
         all_cruise_depth_values = np.linspace(
             start=min_echo_range,
             stop=max_echo_range,
             num=int(max_echo_range / min_echo_range) + 1,
-            endpoint=True
+            endpoint=True,
         )
 
         print("Done getting depth values.")
@@ -52,18 +53,20 @@ class ZarrManager:
 
     #######################################################
     def create_zarr_store(
-            self,
-            path: str,
-            ship_name: str,
-            cruise_name: str,
-            sensor_name: str,
-            frequencies: list,  # units in Hz
-            width: int,  # TODO: needs better name... "ping_time"
-            min_echo_range: float,  # smallest resolution in meters
-            max_echo_range: float,
-            calibration_status: bool = False  # Assume uncalibrated
+        self,
+        path: str,
+        ship_name: str,
+        cruise_name: str,
+        sensor_name: str,
+        frequencies: list,  # units in Hz
+        width: int,  # TODO: needs better name... "ping_time"
+        min_echo_range: float,  # smallest resolution in meters
+        max_echo_range: float,
+        calibration_status: bool = False,  # Assume uncalibrated
     ) -> str:
-        print(f'Creating local zarr_manager store at {cruise_name}.zarr for ship {ship_name}')
+        print(
+            f"Creating local zarr_manager store at {cruise_name}.zarr for ship {ship_name}"
+        )
 
         # There should be no repeated frequencies
         assert len(frequencies) == len(set(frequencies))
@@ -80,28 +83,29 @@ class ZarrManager:
         # https://zarr.readthedocs.io/en/stable/spec/v2.html#data-type-encoding
         root.create_dataset(
             name=Coordinates.TIME.value,
-            data=np.repeat(0., width),
+            data=np.repeat(0.0, width),
             shape=width,
-            chunks=(Constants.TILE_SIZE.value, ),  # TODO: the chunking scheme doesn't seem to be working here
+            chunks=(
+                Constants.TILE_SIZE.value,
+            ),  # TODO: the chunking scheme doesn't seem to be working here
             dtype=np.dtype(Coordinates.TIME_DTYPE.value),
             compressor=self.__compressor,
             # fill_value=0.,
             fill_value=np.nan,  # TODO: do i want nan's?
-            overwrite=self.__overwrite
+            overwrite=self.__overwrite,
         )
 
-        root.time.attrs['_ARRAY_DIMENSIONS'] = [Coordinates.TIME.value]
+        root.time.attrs["_ARRAY_DIMENSIONS"] = [Coordinates.TIME.value]
 
-        root.time.attrs['calendar'] = Coordinates.TIME_CALENDAR.value
-        root.time.attrs['units'] = Coordinates.TIME_UNITS.value
-        root.time.attrs['long_name'] = Coordinates.TIME_LONG_NAME.value
-        root.time.attrs['standard_name'] = Coordinates.TIME_STANDARD_NAME.value
+        root.time.attrs["calendar"] = Coordinates.TIME_CALENDAR.value
+        root.time.attrs["units"] = Coordinates.TIME_UNITS.value
+        root.time.attrs["long_name"] = Coordinates.TIME_LONG_NAME.value
+        root.time.attrs["standard_name"] = Coordinates.TIME_STANDARD_NAME.value
 
         #####################################################################
         # --- Coordinate: Depth --- #
         depth_values = self.get_depth_values(
-            min_echo_range=min_echo_range,
-            max_echo_range=max_echo_range
+            min_echo_range=min_echo_range, max_echo_range=max_echo_range
         )
 
         root.create_dataset(
@@ -110,54 +114,75 @@ class ZarrManager:
             data=depth_values,
             shape=len(depth_values),
             chunks=Constants.TILE_SIZE.value,
-            dtype=np.dtype(Coordinates.DEPTH_DTYPE.value),  # float16 == 2 significant digits would be ideal
+            dtype=np.dtype(
+                Coordinates.DEPTH_DTYPE.value
+            ),  # float16 == 2 significant digits would be ideal
             compressor=self.__compressor,
             # fill_value=np.nan,
-            overwrite=self.__overwrite
+            overwrite=self.__overwrite,
         )
         # TODO: change to exception
         assert not np.any(np.isnan(depth_values))
 
-        root.depth.attrs['_ARRAY_DIMENSIONS'] = [Coordinates.DEPTH.value]
+        root.depth.attrs["_ARRAY_DIMENSIONS"] = [Coordinates.DEPTH.value]
 
-        root.depth.attrs['long_name'] = Coordinates.DEPTH_LONG_NAME.value
-        root.depth.attrs['units'] = Coordinates.DEPTH_UNITS.value
+        root.depth.attrs["long_name"] = Coordinates.DEPTH_LONG_NAME.value
+        root.depth.attrs["units"] = Coordinates.DEPTH_UNITS.value
 
         #####################################################################
         # --- Coordinate: Latitude --- #
         root.create_dataset(
             name=Coordinates.LATITUDE.value,
-            data=np.repeat(0., width),
+            data=np.repeat(0.0, width),
             shape=width,
             chunks=Constants.TILE_SIZE.value,
             dtype=np.dtype(Coordinates.LATITUDE_DTYPE.value),
             compressor=self.__compressor,
-            fill_value=0.,
-            overwrite=self.__overwrite
+            fill_value=0.0,
+            overwrite=self.__overwrite,
         )
 
-        root.latitude.attrs['_ARRAY_DIMENSIONS'] = [Coordinates.TIME.value]
+        root.latitude.attrs["_ARRAY_DIMENSIONS"] = [Coordinates.TIME.value]
 
-        root.latitude.attrs['long_name'] = Coordinates.LATITUDE_LONG_NAME.value
-        root.latitude.attrs['units'] = Coordinates.LATITUDE_UNITS.value
+        root.latitude.attrs["long_name"] = Coordinates.LATITUDE_LONG_NAME.value
+        root.latitude.attrs["units"] = Coordinates.LATITUDE_UNITS.value
 
         #####################################################################
         # --- Coordinate: Longitude --- #
         root.create_dataset(
             name=Coordinates.LONGITUDE.value,
-            data=np.repeat(0., width),  # root.longitude[:] = np.nan
+            data=np.repeat(0.0, width),  # root.longitude[:] = np.nan
             shape=width,
             chunks=Constants.TILE_SIZE.value,
             dtype=np.dtype(Coordinates.LONGITUDE_DTYPE.value),
             compressor=self.__compressor,
-            fill_value=0.,
-            overwrite=self.__overwrite
+            fill_value=0.0,
+            overwrite=self.__overwrite,
         )
 
-        root.longitude.attrs['_ARRAY_DIMENSIONS'] = [Coordinates.TIME.value]
+        root.longitude.attrs["_ARRAY_DIMENSIONS"] = [Coordinates.TIME.value]
 
-        root.longitude.attrs['long_name'] = Coordinates.LONGITUDE_LONG_NAME.value
-        root.longitude.attrs['units'] = Coordinates.LONGITUDE_UNITS.value
+        root.longitude.attrs["long_name"] = Coordinates.LONGITUDE_LONG_NAME.value
+        root.longitude.attrs["units"] = Coordinates.LONGITUDE_UNITS.value
+
+        #####################################################################
+        # TODO: verify adding this variable for where the bottom was detected
+        # --- Coordinate: Bottom --- #
+        root.create_dataset(
+            name=Coordinates.BOTTOM.value,
+            # data=np.repeat(0.0, width),  # root.longitude[:] = np.nan
+            shape=width,
+            chunks=Constants.TILE_SIZE.value,
+            dtype=np.dtype(Coordinates.BOTTOM_DTYPE.value),
+            compressor=self.__compressor,
+            fill_value=np.nan,
+            overwrite=self.__overwrite,
+        )
+
+        root.longitude.attrs["_ARRAY_DIMENSIONS"] = [Coordinates.TIME.value]
+
+        root.longitude.attrs["long_name"] = Coordinates.LONGITUDE_LONG_NAME.value
+        root.longitude.attrs["units"] = Coordinates.LONGITUDE_UNITS.value
 
         #####################################################################
         # --- Coordinate: Frequency --- #
@@ -168,16 +193,20 @@ class ZarrManager:
             chunks=1,
             dtype=np.dtype(Coordinates.FREQUENCY_DTYPE.value),
             compressor=self.__compressor,
-            fill_value=0.,
-            overwrite=self.__overwrite
+            fill_value=0.0,
+            overwrite=self.__overwrite,
         )
 
         # TODO: best coordinate would be channel with str type
-        root.frequency.attrs['_ARRAY_DIMENSIONS'] = [Coordinates.FREQUENCY.value]  # TODO: is this correct
+        root.frequency.attrs["_ARRAY_DIMENSIONS"] = [
+            Coordinates.FREQUENCY.value
+        ]  # TODO: is this correct
 
-        root.frequency.attrs['long_name'] = Coordinates.FREQUENCY_LONG_NAME.value
-        root.frequency.attrs['standard_name'] = Coordinates.FREQUENCY_STANDARD_NAME.value
-        root.frequency.attrs['units'] = Coordinates.FREQUENCY_UNITS.value
+        root.frequency.attrs["long_name"] = Coordinates.FREQUENCY_LONG_NAME.value
+        root.frequency.attrs["standard_name"] = (
+            Coordinates.FREQUENCY_STANDARD_NAME.value
+        )
+        root.frequency.attrs["units"] = Coordinates.FREQUENCY_UNITS.value
 
         #####################################################################
         # --- Sv Data --- #
@@ -185,21 +214,23 @@ class ZarrManager:
             name=Coordinates.SV.value,
             shape=(len(depth_values), width, len(frequencies)),
             chunks=(Constants.TILE_SIZE.value, Constants.TILE_SIZE.value, 1),
-            dtype=np.dtype(Coordinates.SV_DTYPE.value),  # TODO: try to experiment with 'float16'
+            dtype=np.dtype(
+                Coordinates.SV_DTYPE.value
+            ),  # TODO: try to experiment with 'float16'
             compressor=self.__compressor,
             fill_value=np.nan,
-            overwrite=self.__overwrite
+            overwrite=self.__overwrite,
         )
 
-        root.Sv.attrs['_ARRAY_DIMENSIONS'] = [
+        root.Sv.attrs["_ARRAY_DIMENSIONS"] = [
             Coordinates.DEPTH.value,
             Coordinates.TIME.value,
             Coordinates.FREQUENCY.value,
         ]
 
-        root.Sv.attrs['long_name'] = Coordinates.SV_LONG_NAME.value
-        root.Sv.attrs['units'] = Coordinates.SV_UNITS.value
-        root.Sv.attrs['tile_size'] = Constants.TILE_SIZE.value
+        root.Sv.attrs["long_name"] = Coordinates.SV_LONG_NAME.value
+        root.Sv.attrs["units"] = Coordinates.SV_UNITS.value
+        root.Sv.attrs["tile_size"] = Constants.TILE_SIZE.value
 
         #####################################################################
         # --- Metadata --- #
@@ -208,7 +239,9 @@ class ZarrManager:
         root.attrs["sensor_name"] = sensor_name
         #
         root.attrs["processing_software_name"] = Coordinates.PROJECT_NAME.value
-        root.attrs["processing_software_version"] = "0.0.2"  # TODO: get programmatically
+        root.attrs["processing_software_version"] = (
+            "0.0.6"  # TODO: get programmatically
+        )
         root.attrs["processing_software_time"] = Timestamp.get_timestamp()
         #
         root.attrs["calibration_status"] = calibration_status
@@ -239,43 +272,45 @@ class ZarrManager:
 
     ############################################################################
     def open_s3_zarr_store_with_zarr(
-            self,
-            ship_name: str,
-            cruise_name: str,
-            sensor_name: str,
-            # zarr_synchronizer: Union[str, None] = None,
+        self,
+        ship_name: str,
+        cruise_name: str,
+        sensor_name: str,
+        # zarr_synchronizer: Union[str, None] = None,
     ):
         # Mounts a Zarr store using pythons Zarr implementation. The mounted store
         #  will have read/write privileges so that store can be updated.
-        print('Opening Zarr store with Zarr.')
+        print("Opening Zarr store with Zarr.")
         try:
             s3fs_manager = S3FSManager()
-            root = f'{self.output_bucket_name}/level_2/{ship_name}/{cruise_name}/{sensor_name}/{cruise_name}.zarr'
+            root = f"{self.output_bucket_name}/level_2/{ship_name}/{cruise_name}/{sensor_name}/{cruise_name}.zarr"
             store = s3fs_manager.s3_map(s3_zarr_store_path=root)
-            # synchronizer = zarr_manager.ProcessSynchronizer(f"/tmp/{ship_name}_{cruise_name}.sync")
+            # synchronizer = model.ProcessSynchronizer(f"/tmp/{ship_name}_{cruise_name}.sync")
             cruise_zarr = zarr.open(store=store, mode="r+")
         except Exception as err:  # Failure
-            print(f'Exception encountered opening Zarr store with Zarr.: {err}')
+            print(f"Exception encountered opening Zarr store with Zarr.: {err}")
             raise
-        print('Done opening Zarr store with Zarr.')
+        print("Done opening Zarr store with Zarr.")
         return cruise_zarr
 
     ############################################################################
     def open_s3_zarr_store_with_xarray(
-            self,
-            ship_name: str,
-            cruise_name: str,
-            sensor_name: str,
-            file_name_stem: str,
+        self,
+        ship_name: str,
+        cruise_name: str,
+        sensor_name: str,
+        file_name_stem: str,
     ) -> xr.Dataset:
-        print('Opening Zarr store in S3 as Xarray.')
+        print("Opening Zarr store in S3 as Xarray.")
         try:
             zarr_path = f"s3://{self.output_bucket_name}/level_1/{ship_name}/{cruise_name}/{sensor_name}/{file_name_stem}.zarr"
             s3fs_manager = S3FSManager()
             store_s3_map = s3fs_manager.s3_map(s3_zarr_store_path=zarr_path)
-            ds = xr.open_zarr(store=store_s3_map, consolidated=None)  # synchronizer=SYNCHRONIZER
+            ds = xr.open_zarr(
+                store=store_s3_map, consolidated=None
+            )  # synchronizer=SYNCHRONIZER
         except Exception as err:
-            print('Problem opening Zarr store in S3 as Xarray.')
+            print("Problem opening Zarr store in S3 as Xarray.")
             raise err
         print("Done opening Zarr store in S3 as Xarray.")
         return ds
@@ -284,16 +319,17 @@ class ZarrManager:
 
     #######################################################
     # def create_process_synchronizer(self):
-    #     # TODO: explore aws_manager redis options
+    #     # TODO: explore aws redis options
     #     pass
 
     #######################################################
     # def verify_cruise_store_data(self):
-    #     # TODO: run a check on a finished zarr_manager store to ensure that
+    #     # TODO: run a check on a finished model store to ensure that
     #     #   none of the time, latitude, longitude, or depth values
     #     #   are NaN.
     #     pass
 
     #######################################################
 
+
 ###########################################################

water_column_sonar_processing/process.py

@@ -0,0 +1,147 @@
+import json
+import os
+
+import numpy as np
+
+from water_column_sonar_processing.aws.dynamodb_manager import DynamoDBManager
+from water_column_sonar_processing.aws.s3_manager import S3Manager
+from water_column_sonar_processing.aws.s3fs_manager import S3FSManager
+from water_column_sonar_processing.aws.sns_manager import SNSManager
+
+
+###########################################################
+class Process:
+    #######################################################
+    def __init__(
+        self,
+    ):
+        self.input_bucket_name = os.environ["INPUT_BUCKET_NAME"]
+        self.output_bucket_name = os.environ["OUTPUT_BUCKET_NAME"]
+        self.table_name = os.environ["TABLE_NAME"]
+        self.topic_arn = os.environ["TOPIC_ARN"]
+        # self.output_bucket_access_key = ?
+        # self.output_bucket_secret_access_key = ?
+
+    def execute(self):
+        input_s3_manager = (
+            S3Manager()
+        )  # TODO: Need to allow passing in of credentials when writing to protected bucket
+        s3fs_manager = S3FSManager()  # TODO: delete this
+        print(s3fs_manager)  # TODO: delete this
+        output_s3_manager = S3Manager()
+        # TODO: s3fs?
+        sns_manager = SNSManager()
+        ddb_manager = DynamoDBManager()
+
+        # [1 of 5] Update Pipeline Status in DynamoDB
+        # self.dynamodb.update_ status ()
+
+        # [2 of 5] Download Object From Input Bucket
+        # return_value = input_s3_manager.download_file(
+        #    bucket_name=self.input_bucket_name,
+        #    key="the_input_key",
+        #    file_name="the_input_key",
+        # )
+        # print(return_value)
+
+        # [3 of 5] Update Entry in DynamoDB
+        ship_name = "David_Starr_Jordan"  # TODO: get this from input sns message
+        cruise_name = "DS0604"
+        sensor_name = "EK60"
+        file_name = "DSJ0604-D20060406-T113407.raw"
+
+        test_channels = [
+            "GPT  38 kHz 009072055a7f 2 ES38B",
+            "GPT  70 kHz 00907203400a 3 ES70-7C",
+            "GPT 120 kHz 009072034d52 1 ES120-7",
+            "GPT 200 kHz 0090720564e4 4 ES200-7C",
+        ]
+        test_frequencies = [38_000, 70_000, 120_000, 200_000]
+        ddb_manager.update_item(
+            table_name=self.table_name,
+            key={
+                "FILE_NAME": {"S": file_name},  # Partition Key
+                "CRUISE_NAME": {"S": cruise_name},  # Sort Key
+            },
+            expression_attribute_names={
+                "#CH": "CHANNELS",
+                "#ET": "END_TIME",
+                "#ED": "ERROR_DETAIL",
+                "#FR": "FREQUENCIES",
+                "#MA": "MAX_ECHO_RANGE",
+                "#MI": "MIN_ECHO_RANGE",
+                "#ND": "NUM_PING_TIME_DROPNA",
+                "#PS": "PIPELINE_STATUS",  # testing this updated
+                "#PT": "PIPELINE_TIME",  # testing this updated
+                "#SE": "SENSOR_NAME",
+                "#SH": "SHIP_NAME",
+                "#ST": "START_TIME",
+                "#ZB": "ZARR_BUCKET",
+                "#ZP": "ZARR_PATH",
+            },
+            expression_attribute_values={
+                ":ch": {"L": [{"S": i} for i in test_channels]},
+                ":et": {"S": "2006-04-06T13:35:28.688Z"},
+                ":ed": {"S": ""},
+                ":fr": {"L": [{"N": str(i)} for i in test_frequencies]},
+                ":ma": {"N": str(np.round(499.7653, 4))},
+                ":mi": {"N": str(np.round(0.25, 4))},
+                ":nd": {"N": str(2458)},
+                ":ps": {"S": "SUCCESS_AGGREGATOR"},
+                ":pt": {"S": "2023-10-02T08:54:43Z"},
+                ":se": {"S": sensor_name},
+                ":sh": {"S": ship_name},
+                ":st": {"S": "2006-04-06T11:34:07.288Z"},
+                ":zb": {"S": "r2d2-dev-echofish2-118234403147-echofish-dev-output"},
+                ":zp": {
+                    "S": "level_1/David_Starr_Jordan/DS0604/EK60/DSJ0604-D20060406-T113407.model"
+                },
+            },
+            update_expression=(
+                "SET "
+                "#CH = :ch, "
+                "#ET = :et, "
+                "#ED = :ed, "
+                "#FR = :fr, "
+                "#MA = :ma, "
+                "#MI = :mi, "
+                "#ND = :nd, "
+                "#PS = :ps, "
+                "#PT = :pt, "
+                "#SE = :se, "
+                "#SH = :sh, "
+                "#ST = :st, "
+                "#ZB = :zb, "
+                "#ZP = :zp"
+            ),
+        )
+
+        # [4 of 5] Write Object to Output Bucket
+        output_s3_manager.put(
+            bucket_name=self.output_bucket_name, key="123", body="456"
+        )
+
+        # [_ of _] Read file-level Zarr store from bucket, Create GeoJSON, Write to bucket
+        # [_ of _] Create empty cruise-level Zarr store
+        # [_ of _] Resample and write to cruise-level Zarr Store
+
+        # [5 of 5] Publish Done Message
+        success_message = {
+            "default": {
+                "shipName": ship_name,
+                "cruiseName": cruise_name,
+                "sensorName": sensor_name,
+                "fileName": file_name,
+            }
+        }
+        sns_manager.publish(
+            topic_arn=self.topic_arn,
+            message=json.dumps(success_message),
+        )
+        print("done...")
+
+    #######################################################
+
+
+###########################################################
+###########################################################

water_column_sonar_processing/utility/__init__.py

@@ -0,0 +1,6 @@
+from .cleaner import Cleaner
+from .constants import Constants
+from .pipeline_status import PipelineStatus
+from .timestamp import Timestamp
+
+__all__ = ["Cleaner", "Constants", "PipelineStatus", "Timestamp"]

{utility → water_column_sonar_processing/utility}/cleaner.py

@@ -1,21 +1,20 @@
-import os
 import glob
+import os
 import shutil
 
 
 ###########################################################
 class Cleaner:
     @staticmethod
-    def delete_local_files(
-            file_types=['*.raw*', '*.zarr_manager']  # '*.json'
-    ):
-        print('Deleting all local raw and zarr_manager files')
+    def delete_local_files(file_types=["*.raw*", "*.model"]):  # '*.json'
+        print("Deleting all local raw and model files")
         for i in file_types:
             for j in glob.glob(i):
                 if os.path.isdir(j):
                     shutil.rmtree(j, ignore_errors=True)
                 elif os.path.isfile(j):
                     os.remove(j)
-        print('done deleting')
+        print("done deleting")
 
-###########################################################
+
+###########################################################

water_column_sonar_processing/utility/constants.py

@@ -0,0 +1,63 @@
+from enum import Enum, Flag, unique
+
+
+@unique
+class Constants(Flag):
+    TILE_SIZE = 512
+
+
+class Coordinates(Enum):
+    """
+    Should try to specify
+        dtype
+        units
+        long_name — most readable description of variable
+        standard_name — name in lowercase and snake_case
+    """
+
+    PROJECT_NAME = "echofish"
+
+    DEPTH = "depth"
+    DEPTH_DTYPE = "float32"
+    DEPTH_UNITS = "m"  # TODO: Pint? <https://pint.readthedocs.io/en/stable/>
+    DEPTH_LONG_NAME = "Depth below surface"
+    DEPTH_STANDARD_NAME = "depth"
+
+    TIME = "time"
+    TIME_DTYPE = "float64"
+    # Note: units and calendar are used downstream by Xarray
+    TIME_UNITS = "seconds since 1970-01-01 00:00:00"
+    TIME_LONG_NAME = "Timestamp of each ping"
+    TIME_STANDARD_NAME = "time"
+    TIME_CALENDAR = "proleptic_gregorian"
+    # TODO: create test for reading out timestamps in Xarray
+
+    FREQUENCY = "frequency"
+    FREQUENCY_DTYPE = "int"
+    FREQUENCY_UNITS = "Hz"
+    FREQUENCY_LONG_NAME = "Transducer frequency"
+    FREQUENCY_STANDARD_NAME = "sound_frequency"
+
+    LATITUDE = "latitude"
+    LATITUDE_DTYPE = "float32"
+    LATITUDE_UNITS = "degrees_north"
+    LATITUDE_LONG_NAME = "Latitude"
+    LATITUDE_STANDARD_NAME = "latitude"
+
+    LONGITUDE = "longitude"
+    LONGITUDE_DTYPE = "float32"
+    LONGITUDE_UNITS = "degrees_east"
+    LONGITUDE_LONG_NAME = "Longitude"
+    LONGITUDE_STANDARD_NAME = "longitude"
+
+    BOTTOM = "bottom"
+    BOTTOM_DTYPE = "float32"
+    BOTTOM_UNITS = "m"
+    BOTTOM_LONG_NAME = "Detected sea floor depth"
+    BOTTOM_STANDARD_NAME = "bottom"
+
+    SV = "Sv"
+    SV_DTYPE = "float32"  # TODO: experiment with dtype of int
+    SV_UNITS = "dB"
+    SV_LONG_NAME = "Volume backscattering strength (Sv re 1 m-1)"
+    SV_STANDARD_NAME = "volume_backscattering_strength"