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

water_column_sonar_processing/model/zarr_manager.py

@@ -1,12 +1,14 @@
 import os
-import zarr
+
 import numcodecs
 import numpy as np
 import xarray as xr
+import zarr
 from numcodecs import Blosc
+
+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
-from water_column_sonar_processing.aws.s3fs_manager import S3FSManager
 
 numcodecs.blosc.use_threads = False
 numcodecs.blosc.set_nthreads(1)
@@ -15,11 +17,12 @@ numcodecs.blosc.set_nthreads(1)
 # 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)
 class ZarrManager:
     #######################################################
     def __init__(
-            self,
+        self,
     ):
         # TODO: revert to Blosc.BITSHUFFLE, troubleshooting misc error
         self.__compressor = Blosc(cname="zstd", clevel=2)  # shuffle=Blosc.NOSHUFFLE
@@ -31,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 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.")
@@ -50,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))
@@ -78,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(
@@ -108,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 --- #
@@ -166,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 --- #
@@ -183,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 --- #
@@ -206,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
@@ -237,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 = 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
@@ -294,4 +331,5 @@ class ZarrManager:
 
     #######################################################
 
+
 ###########################################################

water_column_sonar_processing/process.py

@@ -1,118 +1,124 @@
-import os
 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
-from water_column_sonar_processing.aws.dynamodb_manager import DynamoDBManager
+
 
 ###########################################################
 class Process:
     #######################################################
     def __init__(
-            self,
+        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.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
+        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 ()
+        # self.dynamodb.update_ status ()
 
         # [2 of 5] Download Object From Input Bucket
-        return_value = input_s3_manager.get(
-            bucket_name=self.input_bucket_name,
-            key='the_input_key'
-        )
-        print(return_value)
+        # 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'
+        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"
+            "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
+                "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',
+                "#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'},
+                ":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'
-            )
+                "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'
+            bucket_name=self.output_bucket_name, key="123", body="456"
         )
 
         # [_ of _] Read file-level Zarr store from bucket, Create GeoJSON, Write to bucket
@@ -136,5 +142,6 @@ class Process:
 
     #######################################################
 
+
 ###########################################################
 ###########################################################

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"]

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*', '*.model']  # '*.json'
-    ):
-        print('Deleting all local raw and model 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")
 
-###########################################################
+
+###########################################################