pyadps 0.1.0b0__py3-none-any.whl → 0.1.2__py3-none-any.whl

pyadps/utils/writenc.py

@@ -17,7 +17,6 @@ from netCDF4 import date2num
 from pyadps.utils import readrdi as rd
 
 
-
 def pd2nctime(time, t0="hours since 2000-01-01"):
     """
     Function to convert pandas datetime format to netcdf datetime format.
@@ -68,9 +67,16 @@ def flead_ncatt(fl_obj, ncfile_id, ens=0):
             setattr(ncfile_id, format_key, format(value))
 
 
-def main(infile, outfile, attributes=None):
+def rawnc(
+    infile,
+    outfile,
+    time,
+    axis_option=None,
+    attributes=None,
+    t0="hours since 2000-01-01",
+):
     """
-    Main function to create netcdf file. Stores 3-D data types like
+    rawnc is a function to create netcdf file. Stores 3-D data types like
     velocity, echo, correlation, and percent good.
 
     Args:
@@ -90,14 +96,33 @@ def main(infile, outfile, attributes=None):
     beam_list = flead.fleader["Beams"]
 
     # Dimensions
-    outnc.createDimension("ensemble", None)
+    # Define the primary axis based on axis_option
+    if axis_option == "ensemble":
+        outnc.createDimension("ensemble", None)
+        primary_axis = "ensemble"
+        ensemble = outnc.createVariable("ensemble", "i4", ("ensemble",))
+        ensemble.axis = "T"
+    elif axis_option == "time":
+        tsize = len(time)
+        outnc.createDimension("time", tsize)
+        primary_axis = "time"
+        time_var = outnc.createVariable("time", "i4", ("time",))
+        time_var.axis = "T"
+        time_var.units = t0
+        time_var.long_name = "time"
+
+        # Convert time_data to numerical format
+        nctime = pd2nctime(time, t0)
+        time_var[:] = nctime
+
+    else:
+        raise ValueError(f"Invalid axis_option: {axis_option}.")
+
     outnc.createDimension("cell", max(cell_list))
     outnc.createDimension("beam", max(beam_list))
 
     # Variables
     # Dimension Variables
-    ensemble = outnc.createVariable("ensemble", "u4", ("ensemble",))
-    ensemble.axis = "T"
     cell = outnc.createVariable("cell", "i2", ("cell",))
     cell.axis = "Z"
     beam = outnc.createVariable("beam", "i2", ("beam",))
@@ -118,9 +143,9 @@ def main(infile, outfile, attributes=None):
     for i, item in enumerate(varlist):
         if item == "Velocity":
             varid[i] = outnc.createVariable(
-                item, "i2", ("ensemble", "cell", "beam"), fill_value=-32768
+                item, "i2", (primary_axis, "cell", "beam"), fill_value=-32768
             )
-            varid[i].missing_value = -32768
+            # varid[i].missing_value = -32768
             vel = getattr(rd, item)
             var = vel(infile).data
             # var = rd.variables(infile, item)
@@ -129,7 +154,7 @@ def main(infile, outfile, attributes=None):
             # Unsigned integers might be assigned for future netcdf versions
             format_item = item.replace(" ", "")  # For percent good
             varid[i] = outnc.createVariable(
-                format_item, "i2", ("ensemble", "cell", "beam")
+                format_item, "i2", (primary_axis, "cell", "beam")
             )
             datatype = getattr(rd, format_item)
             var = np.array(datatype(infile).data, dtype="int16")
@@ -137,22 +162,100 @@ def main(infile, outfile, attributes=None):
 
         vshape = var.T.shape
         if i == 0:
-            ensemble[:] = np.arange(1, vshape[0] + 1, 1)
+            if primary_axis == "ensemble":
+                ensemble[:] = np.arange(1, vshape[0] + 1, 1)
+
         varid[i][0 : vshape[0], 0 : vshape[1], 0 : vshape[2]] = var.T
-        
+
     # Add global attributes if provided
     if attributes:
         for key, value in attributes.items():
-            setattr(outnc, key, str(value))  # Convert to string to store in NetCDF metadata
+            setattr(
+                outnc, key, str(value)
+            )  # Convert to string to store in NetCDF metadata
 
     # outnc.history = "Created " + time.ctime(time.time())
     flead_ncatt(flead, outnc)
-    
 
     outnc.close()
 
+def flead_nc(
+    infile,
+    outfile,
+    time,
+    axis_option=None,
+    attributes=None,
+    t0="hours since 2000-01-01",
+):
+    """
+    Function to create ncfile containing Variable Leader.
+
+    Args:
+        infile (string): Input file path including filename
+        outfile (string): Output file path including filename
+    """
+    outnc = nc4.Dataset(outfile, "w", format="NETCDF4")
+
+    # Dimensions
+    # Define the primary axis based on axis_option
+    if axis_option == "ensemble":
+        outnc.createDimension("ensemble", None)
+        primary_axis = "ensemble"
+        ensemble = outnc.createVariable("ensemble", "i4", ("ensemble",))
+        ensemble.axis = "T"
+    elif axis_option == "time":
+        tsize = len(time)
+        outnc.createDimension("time", tsize)
+        primary_axis = "time"
+        time_var = outnc.createVariable("time", "i4", ("time",))
+        time_var.axis = "T"
+        time_var.units = t0
+        time_var.long_name = "time"
+
+        # Convert time_data to numerical format
+        nctime = pd2nctime(time, t0)
+        time_var[:] = nctime
+
+    else:
+        raise ValueError(f"Invalid axis_option: {axis_option}.")
+
+    # Variables
+
+    flead = rd.FixedLeader(infile)
+    fdict = flead.fleader
+    varid = [0] * len(fdict)
+
+    i = 0
+
+    for key, values in fdict.items():
+        format_item = key.replace(" ", "_")
+        varid[i] = outnc.createVariable(
+            format_item, "i4", primary_axis, fill_value=-32768
+        )
+        var = values
+        vshape = var.shape
+        if i == 0:
+            if primary_axis == "ensemble":
+                ensemble[:] = np.arange(1, vshape[0] + 1, 1)
+
+        varid[i][0 : vshape[0]] = var
+        i += 1
+
+    # Add global attributes if provided
+    if attributes:
+        for key, value in attributes.items():
+            setattr(outnc, key, str(value))  # Store attributes as strings
+
+    outnc.close()
 
-def vlead_nc(infile, outfile, attributes=None):
+def vlead_nc(
+    infile,
+    outfile,
+    time,
+    axis_option=None,
+    attributes=None,
+    t0="hours since 2000-01-01",
+):
     """
     Function to create ncfile containing Variable Leader.
 
@@ -163,12 +266,29 @@ def vlead_nc(infile, outfile, attributes=None):
     outnc = nc4.Dataset(outfile, "w", format="NETCDF4")
 
     # Dimensions
-    outnc.createDimension("ensemble", None)
+    # Define the primary axis based on axis_option
+    if axis_option == "ensemble":
+        outnc.createDimension("ensemble", None)
+        primary_axis = "ensemble"
+        ensemble = outnc.createVariable("ensemble", "i4", ("ensemble",))
+        ensemble.axis = "T"
+    elif axis_option == "time":
+        tsize = len(time)
+        outnc.createDimension("time", tsize)
+        primary_axis = "time"
+        time_var = outnc.createVariable("time", "i4", ("time",))
+        time_var.axis = "T"
+        time_var.units = t0
+        time_var.long_name = "time"
+
+        # Convert time_data to numerical format
+        nctime = pd2nctime(time, t0)
+        time_var[:] = nctime
+
+    else:
+        raise ValueError(f"Invalid axis_option: {axis_option}.")
 
     # Variables
-    # Dimension Variables
-    ensemble = outnc.createVariable("ensemble", "i4", ("ensemble",))
-    ensemble.axis = "T"
 
     vlead = rd.VariableLeader(infile)
     vdict = vlead.vleader
@@ -179,16 +299,17 @@ def vlead_nc(infile, outfile, attributes=None):
     for key, values in vdict.items():
         format_item = key.replace(" ", "_")
         varid[i] = outnc.createVariable(
-            format_item, "i4", "ensemble", fill_value=-32768
+            format_item, "i4", primary_axis, fill_value=-32768
         )
         var = values
         vshape = var.shape
         if i == 0:
-            ensemble[:] = np.arange(1, vshape[0] + 1, 1)
+            if primary_axis == "ensemble":
+                ensemble[:] = np.arange(1, vshape[0] + 1, 1)
 
         varid[i][0 : vshape[0]] = var
         i += 1
-        
+
     # Add global attributes if provided
     if attributes:
         for key, value in attributes.items():
@@ -197,7 +318,9 @@ def vlead_nc(infile, outfile, attributes=None):
     outnc.close()
 
 
-def finalnc(outfile, depth, time, data, t0="hours since 2000-01-01", attributes=None):
+def finalnc(
+    outfile, depth, final_mask, final_echo, final_corr , final_pgood, time, data, t0="hours since 2000-01-01", attributes=None
+):
     """
     Function to create the processed NetCDF file.
 
@@ -208,6 +331,24 @@ def finalnc(outfile, depth, time, data, t0="hours since 2000-01-01", attributes=
         data (numpy array): Velocity (beam, depth, time)
         t0 (string): Time unit and origin
     """
+    fill = -32768
+
+    # Change velocity to cm/s
+    data = data.astype(np.float64)
+    data[data > fill] /= 10
+
+    # Change depth to positive
+    # depth = abs(depth)
+
+    # Reverse the arrays if depth in descending order
+    if np.all(depth[:-1] >= depth[1:]):
+        depth = depth[::-1]
+        data = data[:, ::-1, :]
+        final_mask = final_mask[::-1, :]
+        final_echo = final_echo[:,::-1, :]
+        final_corr = final_corr[:,::-1, :]
+        final_pgood = final_pgood[:,::-1, :]
+
     ncfile = nc4.Dataset(outfile, mode="w", format="NETCDF4")
     # Check if depth is scalar or array
     if np.isscalar(depth):
@@ -221,21 +362,22 @@ def finalnc(outfile, depth, time, data, t0="hours since 2000-01-01", attributes=
     z = ncfile.createVariable("depth", np.float32, ("depth"))
     z.units = "m"
     z.long_name = "depth"
+    z.positive = "down"
 
     t = ncfile.createVariable("time", np.float32, ("time"))
     t.units = t0
     t.long_name = "time"
 
     # Create 2D variables
-    uvel = ncfile.createVariable("u", np.float32, ("time", "depth"), fill_value=-32768)
+    uvel = ncfile.createVariable("u", np.float32, ("time", "depth"), fill_value=fill)
     uvel.units = "cm/s"
     uvel.long_name = "zonal_velocity"
 
-    vvel = ncfile.createVariable("v", np.float32, ("time", "depth"), fill_value=-32768)
+    vvel = ncfile.createVariable("v", np.float32, ("time", "depth"), fill_value=fill)
     vvel.units = "cm/s"
     vvel.long_name = "meridional_velocity"
 
-    wvel = ncfile.createVariable("w", np.float32, ("time", "depth"), fill_value=-32768)
+    wvel = ncfile.createVariable("w", np.float32, ("time", "depth"), fill_value=fill)
     wvel.units = "cm/s"
     wvel.long_name = "vertical_velocity"
 
@@ -245,18 +387,72 @@ def finalnc(outfile, depth, time, data, t0="hours since 2000-01-01", attributes=
     evel.units = "cm/s"
     evel.long_name = "error_velocity"
 
+    mvel = ncfile.createVariable("mask", np.float32, ("time", "depth"), fill_value=fill)
+    mvel.long_name = "Velocity Mask (1: bad value, 0: good value)"
+
+    echo1 = ncfile.createVariable("echo1", np.float32, ("time", "depth"), fill_value=-32768)
+    echo1.long_name = "Echo intensity Beam 1"
+
+    echo2 = ncfile.createVariable("echo2", np.float32, ("time", "depth"), fill_value=-32768)
+    echo2.long_name = "Echo intensity Beam 2"
+
+    echo3 = ncfile.createVariable("echo3", np.float32, ("time", "depth"), fill_value=-32768)
+    echo3.long_name = "Echo intensity Beam 3"
+
+    echo4 = ncfile.createVariable("echo4", np.float32, ("time", "depth"), fill_value=-32768)
+    echo4.long_name = "Echo intensity Beam 4"
+
+    corr1 = ncfile.createVariable("corr1", np.float32, ("time", "depth"), fill_value=-32768)
+    corr1.long_name = "Beam 1 correlation"
+
+    corr2 = ncfile.createVariable("corr2", np.float32, ("time", "depth"), fill_value=-32768)
+    corr2.long_name = "Beam 2 correlation"
+
+    corr3 = ncfile.createVariable("corr3", np.float32, ("time", "depth"), fill_value=-32768)
+    corr3.long_name = "Beam 3 correlation"
+
+    corr4 = ncfile.createVariable("corr4", np.float32, ("time", "depth"), fill_value=-32768)
+    corr4.long_name = "Beam 4 correlation"  
+
+    pgd1 = ncfile.createVariable("pgd1", np.float32, ("time", "depth"), fill_value=-32768)
+    pgd1.long_name = "Percent Good Beam 1"
+
+    pgd2 = ncfile.createVariable("pgd2", np.float32, ("time", "depth"), fill_value=-32768)
+    pgd2.long_name = "Percent Good Beam 2"
+
+    pgd3 = ncfile.createVariable("pgd3", np.float32, ("time", "depth"), fill_value=-32768)
+    pgd3.long_name = "Percent Good Beam 3"
+
+    pgd4 = ncfile.createVariable("pgd4", np.float32, ("time", "depth"), fill_value=-32768)
+    pgd4.long_name = "Percent Good Beam 4"   
+
     nctime = pd2nctime(time, t0)
     # write data
-    z[:] = depth * -1
+    z[:] = depth
     t[:] = nctime
     uvel[:, :] = data[0, :, :].T
     vvel[:, :] = data[1, :, :].T
     wvel[:, :] = data[2, :, :].T
     evel[:, :] = data[3, :, :].T
-    
+    mvel[:, :] = final_mask.T
+    echo1[:, :] = final_echo[0, :, :].T
+    echo2[:, :] = final_echo[1, :, :].T
+    echo3[:, :] = final_echo[2, :, :].T
+    echo4[:, :] = final_echo[3, :, :].T
+    corr1[:, :] = final_corr[0, :, :].T
+    corr2[:, :] = final_corr[1, :, :].T
+    corr3[:, :] = final_corr[2, :, :].T
+    corr4[:, :] = final_corr[3, :, :].T
+    pgd1[:, :] = final_pgood[0, :, :].T
+    pgd2[:, :] = final_pgood[1, :, :].T
+    pgd3[:, :] = final_pgood[2, :, :].T
+    pgd4[:, :] = final_pgood[3, :, :].T
+
     # Add global attributes if provided
     if attributes:
         for key, value in attributes.items():
             setattr(ncfile, key, str(value))  # Store attributes as strings
 
+    ncfile.mask_applied = "True"
+
     ncfile.close()

{pyadps-0.1.0b0.dist-info → pyadps-0.1.2.dist-info}/METADATA

@@ -1,8 +1,8 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: pyadps
-Version: 0.1.0b0
+Version: 0.1.2
 Summary: A Python package for ADCP data processing
-Home-page: https://example.com
+Home-page: https://pyadps.readthedocs.io/en/latest/index.html
 License: MIT
 Keywords: adcp,data-processing,oceanography
 Author: P. Amol
@@ -12,6 +12,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: tests
 Requires-Dist: cmake (>=3.30.2)
 Requires-Dist: matplotlib (>=3.8.4)
@@ -21,18 +22,30 @@ Requires-Dist: numpy (>=1.26.4)
 Requires-Dist: pandas (>=2.2.2)
 Requires-Dist: plotly (>=5.22.0)
 Requires-Dist: plotly-resampler (>=0.10.0)
+Requires-Dist: pygeomag (>=1.1.0,<2.0.0)
 Requires-Dist: scipy (>=1.14.0)
 Requires-Dist: streamlit (>=1.36.0)
-Requires-Dist: wmm2020 (>=1.1.1)
-Project-URL: Documentation, https://example.com/docs
+Project-URL: Documentation, https://pyadps.readthedocs.io/en/latest/index.html
 Project-URL: Repository, https://github.com/p-amol/pyadps
 Description-Content-Type: text/markdown
 
 # pyadps
 
-`pyadps` is a Python package for processing moored Acoustic Doppler Current Profiler (ADCP) data. It provides various functionalities such as data reading, quality control tests, NetCDF file creation, and visualization.
+`pyadps` is a Python package for processing moored Acoustic Doppler
+Current Profiler (ADCP) data. It provides various functionalities
+such as data reading, quality control tests, NetCDF file creation,
+and visualization.
 
-This software offers both a graphical interface (`Streamlit`) for those new to Python and direct Python package access for experienced users. Please note that `pyadps` is primarily designed for Teledyne RDI workhorse ADCPs. Other company's ADCP files are not compatible, and while some other RDI models may work, they might require additional considerations.
+This software offers both a graphical interface (`Streamlit`) for
+those new to Python and direct Python package access for experienced
+users. Please note that `pyadps` is primarily designed for Teledyne
+RDI workhorse ADCPs. Other company's ADCP files are not compatible,
+and while some other RDI models may work, they might require additional
+considerations.
+
+- Documentation: <https://pyadps.readthedocs.io>
+- Source code: <https://github.com/p-amol/pyadps>
+- Bug reports: <https://github.com/p-amol/pyadps/issues>
 
 ## Table of Contents
 
@@ -42,37 +55,49 @@ This software offers both a graphical interface (`Streamlit`) for those new to P
 
 ## Installation
 
-We recommend installing the package within a virtual environment. At present, the package is compatible exclusively with Python version 3.12.
-You can create a Python environment using tools like `venv` or `conda`. Below are instructions for both methods.
+We recommend installing the package within a virtual environment.
+At present, the package is compatible exclusively with Python version 3.12.
+You can create a Python environment using tools like `venv` or `conda`.
+Below are instructions for both methods.
 
 ### 1. Using `venv` (Built-in Python Tool)
 
 #### Step 1: Install Python version 3.12 (if not already installed)
+
 Ensure you have Python installed. You can download the latest version from [python.org](https://www.python.org/downloads/).
 
-#### Step 2: Create a Virtual Environment 
+#### Step 2: Create a Virtual Environment
+
 - Open your terminal or command prompt.
 - Navigate to your project folder:
+
 ```bash
 cd /path/to/your/project
 ```
-- Run the following command to create a virtual environment (replace adpsenv with your preferred environment name):
+
+- Run the following command to create a virtual environment
+(replace adpsenv with your preferred environment name):
 
 ```bash
 python -m venv adpsenv
 ```
 
 #### Step 3: Activate the Environment
+
 - On Windows:
+
 ```bash
 adpsenv\Scripts\activate
 ```
 
 - On macOS/Linux:
+
 ```bash
 source adpsenv/bin/activate
 ```
-You’ll see the environment name in your terminal prompt indicating the environment is active.
+
+You’ll see the environment name in your terminal prompt
+indicating the environment is active.
 
 #### Step 4: Install Dependencies
 
@@ -83,44 +108,51 @@ pip install pyadps
 ```
 
 #### Step 5: Deactivate the Environment
+
 When you’re done working in the environment, deactivate it by running:
 
 ```bash
 deactivate
 ```
 
-
-
-
-### 2. Using `conda` (Anaconda/Miniconda):
+### 2. Using `conda` (Anaconda/Miniconda)
 
 #### Step 1: Install Conda
+
 First, you need to have Conda installed on your system. You can either install:
 
 - [Anaconda (Full Distribution)](https://www.anaconda.com/products/individual)
 - [Miniconda (Lightweight Version)](https://docs.conda.io/en/latest/miniconda.html)
 
 #### Step 2: Create a Conda Environment with Python 3.12
-Once Conda is installed, open a terminal or command prompt and run the following to create a new environment (replace `adpsenv` with your preferred environment name):
+
+Once Conda is installed, open a terminal or command prompt and run
+the following to create a new environment (replace `adpsenv` with
+your preferred environment name):
 
 ```bash
 conda create --name adpsenv python=3.12
 ```
 
-#### Step 3: Activate the Environment
+#### Step 3: Activate the Conda Environment
+
 ```bash
 conda activate adpsenv
 ```
 
-#### Step 4: Install Dependencies
-You can install packages with pip inside Conda environments. 
+#### Step 4: Install pyadps Dependencies
+
+You can install packages with pip inside Conda environments.
+
 ```bash
 pip install pyadps
 ```
 
-#### Step 5: Deactivate the Environment
-When done, deactivate the environment by running:
-```
+#### Step 5: Deactivate the Conda Environment
+
+When done working in the environment, deactivate the environment by running:
+
+```bash
 conda deactivate
 ```
 
@@ -129,11 +161,11 @@ conda deactivate
 ### Streamlit web interface
 
 Open a terminal or command prompt, activate the environment, and run the command.
+
 ```bash
 run-pyadps
 ```
 
-
 ## License
 
 This project is licensed under the MIT License. See the LICENSE file for details.

pyadps-0.1.2.dist-info/RECORD

@@ -0,0 +1,33 @@
+pyadps/Home_Page.py,sha256=j_-3fsp1hkhpNEl5jE-CEQvClDGpMi1H3ZQPXfuKWBg,1782
+pyadps/__init__.py,sha256=bNCm6_WIhiwvaUeOZhRkyLZyzzUKfSH80Fslg0JPJyk,232
+pyadps/__main__.py,sha256=cIFUayxPnKl00oIR99L6IUEvc8trW7dijtfBQCAen5c,356
+pyadps/pages/01_Read_File.py,sha256=swujYGZvQX30zcccWhn5MiFVY_MBUYXuZ9_8GtvpQI4,14421
+pyadps/pages/02_View_Raw_Data.py,sha256=AhT7gvDbcMRPf-WIBzTQ0o-nn9_q7NH6plTlpMtgzaY,6170
+pyadps/pages/03_Download_Raw_File.py,sha256=XF25xog8bkdsm3s1MFA10ZxbvqgDmvxBDOo6OPBHQwQ,12382
+pyadps/pages/04_Sensor_Health.py,sha256=2Qnwl7D46H-f8LmXLVZj5X36h8MjRwmVRK6Bs_wuB_k,33905
+pyadps/pages/05_QC_Test.py,sha256=8wt7h-RHLOf3GZ8-B_kXA0IqzHTBwW_H7YQFEk5EM6E,15904
+pyadps/pages/06_Profile_Test.py,sha256=Vir91oRIWApbO2elBm4I59rdf83NtspUmtzAyWdsIiY,34891
+pyadps/pages/07_Velocity_Test.py,sha256=K4vEiLPMXrU4JMLj-mIA1G4H5ORozMbHMiMov3ZZXP0,23008
+pyadps/pages/08_Write_File.py,sha256=SUHGvOTN2hnwhxGucmTtclU6BhaJKWO2qGV4zS-JsPU,22954
+pyadps/pages/09_Auto_process.py,sha256=SRtQVD9_kodlSvYdF9-02ur6EaWG2zMvN6-BcWdzYV8,1874
+pyadps/pages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyadps/utils/__init__.py,sha256=nCqRp-OT_1BC7RnL3ARUIldlw9sWyr1XqQvQid-B4ts,407
+pyadps/utils/autoprocess.py,sha256=8KAg5-7uC7dsMHrCPfvM5icPzle3MU1gpFNcC-eZrkM,20086
+pyadps/utils/metadata/config.ini,sha256=TC7htzGwUukIXt_u3JR5ycyvOoDj_JxWgGY6khjNeck,2154
+pyadps/utils/metadata/demo.000,sha256=qxB3sgjABrpv4DNXkwjpbSxk5sc4UwAI8kgQX0--PM8,234468
+pyadps/utils/metadata/flmeta.json,sha256=diIB9nht_0uw9YJNSFGdZYGzeVbR-07zIZS9Nf4VPSE,14245
+pyadps/utils/metadata/vlmeta.json,sha256=_dkQlGkkUvpAIM7S6kEUenSaiCpOrwXg8n1aU3dDF3s,22535
+pyadps/utils/plotgen.py,sha256=-A5fN2WoCZevt_SLT5OKSeYCzfv3rGG4tw7p1qzFjeA,26344
+pyadps/utils/profile_test.py,sha256=gnbS6ZsqKvv2tcHTj-Fi_VNOszbxDcPxl77_n4dLzSo,29237
+pyadps/utils/pyreadrdi.py,sha256=2xBg9v7wvxywfvJK1E0hrjR9XSqiiNwpA9ELfcSsuhM,35303
+pyadps/utils/readrdi.py,sha256=ullqqWL-tvK3V9fjX8kpPwRpWhmRZy-CyA240gmcdr4,50012
+pyadps/utils/script.py,sha256=TKMCYe0HEz-2GFpNxKVzpg0p4MM-Cu2rcMZc51GgLn4,6534
+pyadps/utils/sensor_health.py,sha256=aHRaU4kMJZ9dGmYypKpCCgq-owWoNjvcl1I_9I7dG68,3973
+pyadps/utils/signal_quality.py,sha256=dohaMtJT_MCeyxF__zMRy36_rMmVZqU5vCdW1AYH35s,16239
+pyadps/utils/velocity_test.py,sha256=O8dgjv_5pxhJq6QuWHxysMjNzxSnob_2KPLInmO1kHI,6112
+pyadps/utils/writenc.py,sha256=fgE0qpxCy_uk5hsYCeN5l77jWgj-vLxpjx-4hEJDJU0,13955
+pyadps-0.1.2.dist-info/LICENSE,sha256=sfY_7DzQF5FxnO2T6ek74dfm5uBmwEp1oEg_WlzNsb8,1092
+pyadps-0.1.2.dist-info/METADATA,sha256=h4npMIrAf5Tngry5d_wZPiW0Bpq-zizzLmSsfAGl_Vk,4518
+pyadps-0.1.2.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+pyadps-0.1.2.dist-info/entry_points.txt,sha256=-oZhbbJq8Q29uNVh5SmzOLp9OeFM9VUzHVxovfI4LXA,126
+pyadps-0.1.2.dist-info/RECORD,,

{pyadps-0.1.0b0.dist-info → pyadps-0.1.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 2.0.0
 Root-Is-Purelib: true
 Tag: py3-none-any

pyadps-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+run-auto=pyadps.utils.autoprocess:main
+run-pyadps=pyadps.__main__:main
+run-script=pyadps.utils.script:main
+