water-column-sonar-processing 0.0.9__py3-none-any.whl → 26.1.9__py3-none-any.whl

water_column_sonar_processing/process.py

@@ -1,147 +0,0 @@
-import json
-import os
-
-import numpy as np
-
-from water_column_sonar_processing.aws import DynamoDBManager
-from water_column_sonar_processing.aws import S3Manager
-from water_column_sonar_processing.aws import S3FSManager
-from water_column_sonar_processing.aws 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/processing/cruise_sampler.py

@@ -1,342 +0,0 @@
-import gc
-import os
-import echopype as ep
-import numpy as np
-from numcodecs import Blosc
-
-from water_column_sonar_processing.utility import Cleaner
-
-TEMPDIR = "/tmp"
-
-
-# This code is getting copied from echofish-aws-raw-to-zarr-lambda
-class CruiseSampler:
-    #######################################################
-    def __init__(
-            self,
-    ):
-        # TODO: revert to Blosc.BITSHUFFLE, troubleshooting misc error
-        self.__compressor = Blosc(cname="zstd", clevel=2)  # shuffle=Blosc.NOSHUFFLE
-        self.bucket_name = os.environ.get("INPUT_BUCKET_NAME")
-        # self.__s3 = s3_operations
-
-    ############################################################################
-    ############################################################################
-    def __zarr_info_to_table(
-            self,
-            file_name,
-            cruise_name,
-            zarr_path,
-            min_echo_range,
-            max_echo_range,
-            num_ping_time_dropna,
-            start_time,
-            end_time,
-            frequencies,
-            channels
-    ):
-        print('Writing Zarr information to DynamoDB table.')
-        self.__dynamo.update_item(
-            table_name=self.__table_name,
-            key={
-                'FILE_NAME': {'S': file_name},  # Partition Key
-                'CRUISE_NAME': {'S': cruise_name},  # Sort Key
-                # TODO: should be FILE_NAME & SENSOR_NAME so they are truely unique for when two sensors are processed within one cruise
-            },
-            expression='SET #ZB = :zb, #ZP = :zp, #MINER = :miner, #MAXER = :maxer, #P = :p, #ST = :st, #ET = :et, #F = :f, #C = :c',
-            attribute_names={
-                '#ZB': 'ZARR_BUCKET',
-                '#ZP': 'ZARR_PATH',
-                '#MINER': 'MIN_ECHO_RANGE',
-                '#MAXER': 'MAX_ECHO_RANGE',
-                '#P': 'NUM_PING_TIME_DROPNA',
-                '#ST': 'START_TIME',
-                '#ET': 'END_TIME',
-                '#F': 'FREQUENCIES',
-                '#C': 'CHANNELS',
-            },
-            attribute_values={
-                ':zb': {
-                    'S': self.__output_bucket
-                },
-                ':zp': {
-                    'S': zarr_path
-                },
-                ':miner': {
-                    'N': str(np.round(min_echo_range, 4))
-                },
-                ':maxer': {
-                    'N': str(np.round(max_echo_range, 4))
-                },
-                ':p': {
-                    'N': str(num_ping_time_dropna)
-                },
-                ':st': {
-                    'S': start_time
-                },
-                ':et': {
-                    'S': end_time
-                },
-                ':f': {
-                    'L': [{'N': str(i)} for i in frequencies]
-                },
-                ':c': {
-                    'L': [{'S': i} for i in channels]
-                }
-            }
-        )
-
-    ############################################################################
-    ############################################################################
-    ############################################################################
-    def raw_to_zarr(
-            self,
-            ship_name,
-            cruise_name,
-            sensor_name,
-            file_name,
-    ):
-        print(f'Opening raw: {file_name} and creating zarr store.')
-        geometry_manager = GeometryManager()
-        try:
-            gc.collect()
-            print('Opening raw file with echopype.')
-            bucket_name="test_input_bucket" # noaa-wcsd-pds
-            s3_file_path = f"s3://{bucket_name}/data/raw/{ship_name}/{cruise_name}/{sensor_name}/{file_name}"
-            # s3_file_path = Path(f"s3://noaa-wcsd-pds/data/raw/{ship_name}/{cruise_name}/{sensor_name}/{file_name}")
-            # TODO: add the bottom file here
-            echodata = ep.open_raw(
-                raw_file=s3_file_path,
-                sonar_model=sensor_name,
-                # include_bot=True,
-                use_swap=True,
-                # max_chunk_size=100,
-                # storage_options={'anon': True} # this was creating problems
-            )
-            print('Compute volume backscattering strength (Sv) from raw data.')
-            ds_sv = ep.calibrate.compute_Sv(echodata)
-            print('Done computing volume backscattering strength (Sv) from raw data.')
-            frequencies = echodata.environment.frequency_nominal.values
-            #################################################################
-            # Get GPS coordinates
-            gps_data, lat, lon = geometry_manager.read_echodata_gps_data(
-                echodata=echodata,
-                ship_name=ship_name,
-                cruise_name=cruise_name,
-                sensor_name=sensor_name,
-                file_name=file_name,
-                write_geojson=True
-            )
-            # gps_data, lat, lon = self.__get_gps_data(echodata=echodata)
-            #################################################################
-            # Technically the min_echo_range would be 0 m.
-            # TODO: this var name is supposed to represent minimum resolution of depth measurements
-            # The most minimum the resolution can be is as small as 0.25 meters
-            min_echo_range = np.maximum(0.25, np.nanmin(np.diff(ds_sv.echo_range.values)))
-            max_echo_range = float(np.nanmax(ds_sv.echo_range))
-            #
-            num_ping_time_dropna = lat[~np.isnan(lat)].shape[0]  # symmetric to lon
-            #
-            start_time = np.datetime_as_string(ds_sv.ping_time.values[0], unit='ms') + "Z"
-            end_time = np.datetime_as_string(ds_sv.ping_time.values[-1], unit='ms') + "Z"
-            channels = list(ds_sv.channel.values)
-            #
-            #################################################################
-            # Create the zarr store
-            ds_sv.to_zarr(store=store_name)
-            #################################################################
-            print('Note: Adding GeoJSON inside Zarr store')
-            self.__write_geojson_to_file(store_name=store_name, data=gps_data)
-            #################################################################
-            self.__zarr_info_to_table(
-                file_name=raw_file_name,
-                cruise_name=cruise_name,
-                zarr_path=os.path.join(output_zarr_prefix, store_name),
-                min_echo_range=min_echo_range,
-                max_echo_range=max_echo_range,
-                num_ping_time_dropna=num_ping_time_dropna,
-                start_time=start_time,
-                end_time=end_time,
-                frequencies=frequencies,
-                channels=channels
-            )
-        except Exception as err:
-            print(f'Exception encountered creating local Zarr store with echopype: {err}')
-            raise RuntimeError(f"Problem creating local Zarr store, {err}")
-        print('Done creating local zarr store.')
-
-    ############################################################################
-    def __upload_files_to_output_bucket(
-            self,
-            local_directory,
-            object_prefix,
-    ):
-        # Note: this will be passed credentials if using NODD
-        print('Uploading files using thread pool executor.')
-        all_files = []
-        for subdir, dirs, files in os.walk(local_directory):
-            for file in files:
-                local_path = os.path.join(subdir, file)
-                s3_key = os.path.join(object_prefix, local_path)
-                all_files.append([local_path, s3_key])
-        # all_files
-        all_uploads = self.__s3.upload_files_with_thread_pool_executor(
-            bucket_name=self.__output_bucket,
-            all_files=all_files,
-            access_key_id=self.__output_bucket_access_key,
-            secret_access_key=self.__output_bucket_secret_access_key
-        )
-        return all_uploads
-
-    ############################################################################
-    def execute(self, input_message):
-        ship_name = input_message['shipName']
-        cruise_name = input_message['cruiseName']
-        sensor_name = input_message['sensorName']
-        input_file_name = input_message['fileName']
-        #
-        try:
-            self.__update_processing_status(
-                file_name=input_file_name,
-                cruise_name=cruise_name,
-                pipeline_status="PROCESSING_RAW_TO_ZARR"
-            )
-            #######################################################################
-            store_name = f"{os.path.splitext(input_file_name)[0]}.zarr"
-            output_zarr_prefix = f"level_1/{ship_name}/{cruise_name}/{sensor_name}"
-            bucket_key = f"data/raw/{ship_name}/{cruise_name}/{sensor_name}/{input_file_name}"
-            zarr_prefix = os.path.join("level_1", ship_name, cruise_name, sensor_name)
-            #
-            os.chdir(TEMPDIR)  # Lambdas require use of temp directory
-            #######################################################################
-            #######################################################################
-            # Check if zarr store already exists
-            s3_objects = self.__s3.list_objects(
-                bucket_name=self.__output_bucket,
-                prefix=f"{zarr_prefix}/{os.path.splitext(input_file_name)[0]}.zarr/",
-                access_key_id=self.__output_bucket_access_key,
-                secret_access_key=self.__output_bucket_secret_access_key
-            )
-            if len(s3_objects) > 0:
-                print('Zarr store data already exists in s3, deleting existing and continuing.')
-                self.__s3.delete_objects(
-                    bucket_name=self.__output_bucket,
-                    objects=s3_objects,
-                    access_key_id=self.__output_bucket_access_key,
-                    secret_access_key=self.__output_bucket_secret_access_key
-                )
-            #######################################################################
-            # self.__delete_all_local_raw_and_zarr_files()
-            Cleaner.delete_local_files(file_types=["*.raw*", "*.zarr"])
-            self.__s3.download_file(
-                bucket_name=self.__input_bucket,
-                key=bucket_key,
-                file_name=input_file_name
-            )
-            self.__create_local_zarr_store(
-                raw_file_name=input_file_name,
-                cruise_name=cruise_name,
-                sensor_name=sensor_name,
-                output_zarr_prefix=output_zarr_prefix,
-                store_name=store_name
-            )
-            #######################################################################
-            self.__upload_files_to_output_bucket(store_name, output_zarr_prefix)
-            #######################################################################
-            # # TODO: verify count of objects matches
-            # s3_objects = self.__s3.list_objects(
-            #     bucket_name=self.__output_bucket,
-            #     prefix=f"{zarr_prefix}/{os.path.splitext(input_file_name)[0]}.zarr/",
-            #     access_key_id=self.__output_bucket_access_key,
-            #     secret_access_key=self.__output_bucket_secret_access_key
-            # )
-            #######################################################################
-            self.__update_processing_status(
-                file_name=input_file_name,
-                cruise_name=cruise_name,
-                pipeline_status='SUCCESS_RAW_TO_ZARR'
-            )
-            #######################################################################
-            self.__publish_done_message(input_message)
-            #######################################################################
-        # except Exception as err:
-        #     print(f'Exception encountered: {err}')
-        # self.__update_processing_status(
-        #     file_name=input_file_name,
-        #     cruise_name=cruise_name,
-        #     pipeline_status='FAILURE_RAW_TO_ZARR',
-        #     error_message=str(err),
-        # )
-        finally:
-            self.__delete_all_local_raw_and_zarr_files()
-        #######################################################################
-
-    ############################################################################
-
-################################################################################
-############################################################################
-# TODO: DELETE
-# def __get_gps_data(
-#         self,
-#         echodata: ep.echodata.echodata.EchoData
-# ) -> tuple:
-#     print('Getting GPS data.')
-#     try:
-#         # if 'latitude' not in echodata.platform.variables and 'longitude' not in echodata.platform.variables:
-#         #     raise KeyError;
-#         assert(  # TODO: raise error, e.g. KeyError
-#                 'latitude' in echodata.platform.variables and 'longitude' in echodata.platform.variables
-#         ), "Problem: GPS coordinates not found in echodata."
-#         latitude = echodata.platform.latitude.values
-#         longitude = echodata.platform.longitude.values  # len(longitude) == 14691
-#         # RE: time coordinates: https://github.com/OSOceanAcoustics/echopype/issues/656#issue-1219104771
-#         assert(
-#                 'time1' in echodata.platform.variables and 'time1' in echodata.environment.variables
-#         ), "Problem: Time coordinate not found in echodata."
-#         # 'nmea_times' are times from the nmea datalogger associated with GPS
-#         #   nmea times, unlike env times, can be sorted
-#         nmea_times = np.sort(echodata.platform.time1.values)
-#         # 'time1' are times from the echosounder associated with transducer measurement
-#         time1 = echodata.environment.time1.values
-#         # Align 'sv_times' to 'nmea_times'
-#         assert(
-#                 np.all(time1[:-1] <= time1[1:]) and np.all(nmea_times[:-1] <= nmea_times[1:])
-#         ), "Problem: NMEA time stamps are not sorted."
-#         # Finds the indices where 'v' can be inserted just to the right of 'a'
-#         indices = np.searchsorted(a=nmea_times, v=time1, side="right") - 1
-#         #
-#         lat = latitude[indices]
-#         lat[indices < 0] = np.nan  # values recorded before indexing are set to nan
-#         lon = longitude[indices]
-#         lon[indices < 0] = np.nan
-#         if len(lat) < 2 or len(lon) < 2:
-#             raise Exception("There was not enough data in lat or lon to create geojson.")
-#         assert(  # TODO: raise ValueError
-#                 np.all(lat[~np.isnan(lat)] >= -90.) and np.all(lat[~np.isnan(lat)] <= 90.) and np.all(lon[~np.isnan(lon)] >= -180.) and np.all(lon[~np.isnan(lon)] <= 180.)
-#         ), "Problem: Data falls outside GPS bounds!"
-#         # TODO: check for visits to null island
-#         # https://osoceanacoustics.github.io/echopype-examples/echopype_tour.html
-#         print(np.count_nonzero(np.isnan(lat)))
-#         print(np.count_nonzero(np.isnan(lon)))
-#         if len(lat[~np.isnan(lat)]) < 1:
-#             raise RuntimeError(f"Problem all data is NaN.")
-#         time1 = time1[~np.isnan(lat)]
-#         lat = lat[~np.isnan(lat)]
-#         lon = lon[~np.isnan(lon)]
-#         #
-#         gps_df = pd.DataFrame({
-#             'latitude': lat,
-#             'longitude': lon,
-#             'time1': time1
-#         }).set_index(['time1'])
-#         gps_gdf = geopandas.GeoDataFrame(
-#             gps_df,
-#             geometry=geopandas.points_from_xy(gps_df['longitude'], gps_df['latitude']),
-#             crs="epsg:4326"  # TODO: does this sound right?
-#         )
-#         # GeoJSON FeatureCollection with IDs as "time1"
-#         geo_json = gps_gdf.to_json()
-#     except Exception as err:
-#         print(f'Exception encountered creating local Zarr store with echopype: {err}')
-#         raise
-#     return geo_json, lat, lon

water_column_sonar_processing-0.0.9.dist-info/METADATA

@@ -1,134 +0,0 @@
-Metadata-Version: 2.1
-Name: water_column_sonar_processing
-Version: 0.0.9
-Summary: A processing tool for water column sonar data.
-Author-email: Rudy Klucik <rudy.klucik@noaa.gov>
-Project-URL: Homepage, https://github.com/CI-CMG/water-column-sonar-processing
-Project-URL: Issues, https://github.com/CI-CMG/water-column-sonar-processing/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: aiobotocore==2.15.2
-Requires-Dist: boto3==1.35.36
-Requires-Dist: botocore==1.35.36
-Requires-Dist: echopype==0.9.0
-Requires-Dist: fiona==1.10.1
-Requires-Dist: geopandas==1.0.1
-Requires-Dist: mock==5.1.0
-Requires-Dist: moto[all]==5.0.21
-Requires-Dist: moto[server]==5.0.21
-Requires-Dist: numcodecs==0.13.1
-Requires-Dist: numpy==1.26.4
-Requires-Dist: pandas==2.2.3
-Requires-Dist: pyarrow==18.1.0
-Requires-Dist: python-dotenv==1.0.0
-Requires-Dist: requests==2.32.3
-Requires-Dist: s3fs==2023.12.1
-Requires-Dist: scipy==1.14.1
-Requires-Dist: setuptools==75.6.0
-Requires-Dist: shapely==2.0.3
-Requires-Dist: typing-extensions==4.10.0
-Requires-Dist: xarray==2024.10.0
-Requires-Dist: zarr==2.18.3
-
-# Water Column Sonar Processing
-Processing tool for converting L0 data to L1 and L2 as well as generating geospatial information
-
-# Setting up the Python Environment
-> Python 3.10.12
-
-# MacOS Pyenv Installation Instructions
-  1. Install pyenv (https://github.com/pyenv/pyenv#set-up-your-shell-environment-for-pyenv)
-     1. ```brew update```
-     2. ```arch -arm64 brew install pyenv```
-     3. In ~/.bashrc add
-        1. ```export PYENV_ROOT="$HOME/.pyenv"```
-        2. ```export PATH="$PYENV_ROOT/bin:$PATH"```
-        3. ```eval "$(pyenv init -)"```
-     4. ```arch -arm64 brew install openssl readline sqlite3 xz zlib tcl-tk```
-  2. Install pyenv-virtualenv (https://github.com/pyenv/pyenv-virtualenv)
-     1. ```arch -arm64 brew install pyenv-virtualenv```
-     2. In ~/.bashrc add
-         1. ```eval "$(pyenv virtualenv-init -)"```
-  3. Open a new terminal
-  4. Install Python version
-     1. ```env CONFIGURE_OPTS='--enable-optimizations' arch -arm64 pyenv install 3.10.12```
-  5. Create virtual env (to delete 'pyenv uninstall 3.10.12/water-column-sonar-processing')
-     1. ```pyenv virtualenv 3.10.12 water-column-sonar-processing```
-  6. Set local version of python (if not done already)
-     1. change directory to root of project
-     2. ```pyenv local 3.10.12 water-column-sonar-processing```
-     3. ```pyenv activate water-column-sonar-processing```
-
-# Setting up IntelliJ
-
-  1. Install the IntelliJ Python plugin
-  2. Set up pyenv
-     1. File -> Project Structure or CMD + ;
-     2. SDKs -> + -> Add Python SDK -> Virtual Environment
-     3. Select Existing Environment
-     4. Choose ~/.pyenv/versions/mocking_aws/bin/python
-  3. Set up Python Facet (not sure if this is required)
-     1. File -> Project Structure or CMD + ;
-     2. Facets -> + -> Python 
-     3. Set interpreter 
-
-# Installing Dependencies
-
-  1. Add dependencies with versions to requirements.txt
-  2. ```pip install --upgrade pip && pip install -r requirements_dev.txt```
-
-
-# Pytest
-```commandline
-pytest --disable-warnings
-```
-or
-> pytest --cache-clear --cov=src tests/ --cov-report=xml
-
-# Instructions
-Following this tutorial:
-https://packaging.python.org/en/latest/tutorials/packaging-projects/
-
-# To Publish To TEST
-```commandline
-python -m build
-# python -m build --sdist
-# python -m build --wheel
-python -m twine upload --repository testpypi dist/*
-pytho -m pip install --index-url https://test.pypi.org/simple/ hello-pypi-rudy-klucik
-python
-```
-```
-from water-column-sonar-processing import ZarrManager
-example.add_one(2)
-```
-
-# To Publish To PROD
-```commandline
-python -m build
-python -m twine upload --repository pypi dist/*
-```
-
-# Pre Commit Hook
-https://dev.to/rafaelherik/using-trufflehog-and-pre-commit-hook-to-prevent-secret-exposure-edo
-```
-pre-commit install --allow-missing-config
-```
-
-# Linting
-Ruff
-https://plugins.jetbrains.com/plugin/20574-ruff
-
-# Colab Test
-https://colab.research.google.com/drive/1KiLMueXiz9WVB9o4RuzYeGjNZ6PsZU7a#scrollTo=AayVyvpBdfIZ
-
-# Test Coverage
-20241124
-8 failed, 32 passed, 3 skipped, 1 warning in 6.92s
-20241125
-5 failed, 35 passed, 3 skipped, 1 warning in 9.71s
-3 failed, 38 passed, 3 skipped, 1 warning in 7.24s

water_column_sonar_processing-0.0.9.dist-info/RECORD

@@ -1,32 +0,0 @@
-water_column_sonar_processing/__init__.py,sha256=fvRK4uFo_A0l7w_T4yckvDqJ3wMUq4JB3VVPXqWfewE,226
-water_column_sonar_processing/process.py,sha256=-yQtK3rnZq6lGAr3q02zLDe1NuMH9c0PiUOxKzG_r18,5386
-water_column_sonar_processing/aws/__init__.py,sha256=KJqK8oYMn-u8n8i-Jp_lG5BvCOTjwWSjWP8yAyDlWVo,297
-water_column_sonar_processing/aws/dynamodb_manager.py,sha256=sZHn-hgCt3K3w0x5BcXfF5jLMt_F11dAtQHJToij9nU,10008
-water_column_sonar_processing/aws/s3_manager.py,sha256=ctNWMkgqMlwbwmXHgwKEV8otLwIjr-dHX6bQ2rOw1ug,14718
-water_column_sonar_processing/aws/s3fs_manager.py,sha256=thVJPQKhbvF1g-Ue3BYgwazFOFDYOICIEJx4zkXBQ1E,2381
-water_column_sonar_processing/aws/sns_manager.py,sha256=Dp9avG5VSugSWPR1dZ-askuAw1fCZkNUHbOUP65iR-k,1867
-water_column_sonar_processing/aws/sqs_manager.py,sha256=NSUrWmnSC8h8Gf7gT0U8zFaQQ-yX89h0Q0mDLKGqp2Y,1597
-water_column_sonar_processing/cruise/__init__.py,sha256=H5hW0JMORuaFvQk_R31B4VL8RnRyKeanOOiWmqEMZJk,156
-water_column_sonar_processing/cruise/create_empty_zarr_store.py,sha256=uLwHZazndSy4puXrS-2PrGhicV-umsCCiXoqt2MMpkM,7317
-water_column_sonar_processing/cruise/resample_regrid.py,sha256=4Tw6Ro9mQZOr0uIph6foz6a1OeFAZW0SMUT_asIwvKw,12309
-water_column_sonar_processing/geometry/__init__.py,sha256=_ol5nI8AL30pYXeAh5rtP7YmQggitPC6LA_kuTfPJ0Q,231
-water_column_sonar_processing/geometry/geometry_manager.py,sha256=7WZ1UerY_h3uOKc3mcaOpvhgZ1yV3gD-CUnhZJl1BOQ,10550
-water_column_sonar_processing/geometry/geometry_simplification.py,sha256=im1HG9nfYIerQv3w-PUHzphw2B7aGgnsA3Zcdy2oTmA,3016
-water_column_sonar_processing/geometry/pmtile_generation.py,sha256=7Lm08Jr6YaM4nYmexClxbIMOqSV1teo9wMm6dfjFuNA,12384
-water_column_sonar_processing/index/__init__.py,sha256=izEObsKiOoIJ0kZCFhvaYsBd6Ga71XJxnogjrNInw68,68
-water_column_sonar_processing/index/index_manager.py,sha256=YS6y_THfGAZpjfBZOj5n8O1aY_BnBYS781eNHfhpip0,11239
-water_column_sonar_processing/model/__init__.py,sha256=FXaCdbPqxp0ogmZm9NplRirqpgMiYs1iRYgJbFbbX2Y,65
-water_column_sonar_processing/model/zarr_manager.py,sha256=fpRkk6Qg1_LVdLg1M_X0J9Lchp2OJygTxfekEk1Mi88,13641
-water_column_sonar_processing/processing/__init__.py,sha256=UwdB3BnoUxy4q3k9-ZjBF6KzmCWVDcqbcArTeHgmvGA,118
-water_column_sonar_processing/processing/cruise_sampler.py,sha256=hadPrnH5nz7_oG_4pND7YbMFH6NMR9d6p3xAXedtKU8,15927
-water_column_sonar_processing/processing/raw_to_zarr.py,sha256=QBz58P-hYTZwg6hhf4u_kNg710lrfxPwnvIr7UmK30I,16125
-water_column_sonar_processing/utility/__init__.py,sha256=yDObMOL0_OxKWet5wffK2-XVJgoE9iwiY2q04GZrtBQ,234
-water_column_sonar_processing/utility/cleaner.py,sha256=bNbs-hopWxtKAFBK0Eu18xdRErZCGZvtla3j-1bTwQw,619
-water_column_sonar_processing/utility/constants.py,sha256=EbzsorvYKadsPjuutRjQKKByGibhFm0Gw6D-Sp2ZD3I,2143
-water_column_sonar_processing/utility/pipeline_status.py,sha256=O-0SySqdRGJ6bs3zQe1NV9vkOpmsRM7zj5QoHgzYioY,4395
-water_column_sonar_processing/utility/timestamp.py,sha256=bO0oir7KxxoEHPGRkz9FCBfOligkocUyRiWRzAq8fnU,361
-water_column_sonar_processing-0.0.9.dist-info/LICENSE,sha256=lz4IpJ5_adG3S0ali-WaIpQFVTnEAOucMDQPECUVEYw,1110
-water_column_sonar_processing-0.0.9.dist-info/METADATA,sha256=5mtfW5UU7dpl2oKGUi7GKTbjsrcMo13ackWFpNVkjr4,4432
-water_column_sonar_processing-0.0.9.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-water_column_sonar_processing-0.0.9.dist-info/top_level.txt,sha256=aRYU4A7RNBlNrL4vzjytFAir3BNnmOgsvIGKKA36tg4,30
-water_column_sonar_processing-0.0.9.dist-info/RECORD,,