DASPy-toolbox 1.1.5__tar.gz → 1.1.6__tar.gz

{daspy_toolbox-1.1.5 → daspy_toolbox-1.1.6}/DASPy_toolbox.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DASPy-toolbox
-Version: 1.1.5
+Version: 1.1.6
 Summary: DASPy is an open-source project dedicated to provide a python package for DAS (Distributed Acoustic Sensing) data processing, which comprises classic seismic data processing techniques and Specialized algorithms for DAS applications.
 Home-page: https://github.com/HMZ-03/DASPy
 Author: Minzhe Hu, Zefeng Li

{daspy_toolbox-1.1.5 → daspy_toolbox-1.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DASPy-toolbox
-Version: 1.1.5
+Version: 1.1.6
 Summary: DASPy is an open-source project dedicated to provide a python package for DAS (Distributed Acoustic Sensing) data processing, which comprises classic seismic data processing techniques and Specialized algorithms for DAS applications.
 Home-page: https://github.com/HMZ-03/DASPy
 Author: Minzhe Hu, Zefeng Li

{daspy_toolbox-1.1.5 → daspy_toolbox-1.1.6}/daspy/advanced_tools/channel.py

@@ -365,24 +365,6 @@ def turning_points(data, data_type='coordinate', thresh=5, depth_info=False,
         raise ValueError('Data_type should be \'coordinate\' or \'waveform\'.')
 
 
-def _equally_spacing(dist, dx):
-    index = [[], []]
-    residual = [0, abs(dist[0]-dx)]
-    for i in range(2, len(dist)+1):
-        res = []
-        for j in range(i):
-            res.append(residual[j] + abs(dx - sum(dist[j:i])))
-        residual.append(min(res))
-        k = np.argmin(res)
-        if k > 0:
-            index.append(index[k] + [k])
-        else:
-            index.append(index[k])
-        # print(index, residual)
-    
-    return index[-1]
-
-
 def channel_spacing(geometry, depth_info=False):
     nch = len(geometry)
     dist = np.zeros(nch - 1)
@@ -456,6 +438,23 @@ def closest_channel_to_point(geometry, points, verbose=False):
     return channels[closest_index]
 
 
+def _equally_spacing(dist, dx):
+    index = [[], []]
+    residual = [0, abs(dist[0]-dx)]
+    for i in range(2, len(dist)+1):
+        res = []
+        for j in range(i):
+            res.append(residual[j] + abs(dx - sum(dist[j:i])))
+        residual.append(min(res))
+        k = np.argmin(res)
+        if k > 0:
+            index.append(index[k] + [k])
+        else:
+            index.append(index[k])
+    
+    return index[-1]
+
+
 def equally_spaced_channels(geometry, dx, depth_info=False, verbose=False):
     """
     Find equally spaced channel numbers based on known DAS latitude and

{daspy_toolbox-1.1.5 → daspy_toolbox-1.1.6}/daspy/basic_tools/preprocessing.py

@@ -145,14 +145,14 @@ def downsampling(data, xint=None, tint=None, stack=True, lowpass_filter=True):
         if stack:
             data_ds = stacking(data, xint)
         else:
-            data_ds = data_ds[::xint]
+            data_ds = data_ds[::xint].copy()
     if tint and tint > 1:
         if lowpass_filter:
             data_ds = lowpass_cheby_2(data_ds, 1, 1 / 2 / tint)
         if len(data_ds.shape) == 1:
-            data_ds = data_ds[::tint]
+            data_ds = data_ds[::tint].copy()
         else:
-            data_ds = data_ds[:, ::tint]
+            data_ds = data_ds[:, ::tint].copy()
     return data_ds
 
 

{daspy_toolbox-1.1.5 → daspy_toolbox-1.1.6}/daspy/basic_tools/visualization.py

@@ -1,6 +1,6 @@
 # Purpose: Plot data
 # Author: Minzhe Hu
-# Date: 2025.1.6
+# Date: 2025.5.20
 # Email: hmz2018@mail.ustc.edu.cn
 import numpy as np
 import matplotlib.pyplot as plt
@@ -9,11 +9,11 @@ from collections.abc import Sequence
 
 def plot(data: np.ndarray, dx=None, fs=None, ax=None, obj='waveform', dpi=300,
          title=None, transpose=False, t0=0, x0=0, pick=None, f=None, k=None,
-         t=None, c=None, cmap=None, vmin=None, vmax=None, dB=False,
-         xmode='distance', tmode='time', xlim=None, ylim=None, xlog=False,
-         ylog=False, xinv=False, yinv=False, xlabel=True, ylabel=True,
-         xticklabels=True, yticklabels=True, colorbar=True, colorbar_label=None,
-         savefig=None):
+         t=None, c=None, cmap=None, vmin=None, vmin_per=None, vmax=None,
+         vmax_per=None, dB=False, xmode='distance', tmode='time', xlim=None,
+         ylim=None, xlog=False, ylog=False, xinv=False, yinv=False, xlabel=True,
+         ylabel=True, xticklabels=True, yticklabels=True, colorbar=True,
+         colorbar_label=None, savefig=None):
     """
     Plot several types of 2-D seismological data.
 
@@ -40,6 +40,8 @@ def plot(data: np.ndarray, dx=None, fs=None, ax=None, obj='waveform', dpi=300,
     :param cmap: str or Colormap. The Colormap instance or registered colormap
         name used to map scalar data to colors.
     :param vmin, vmax: Define the data range that the colormap covers.
+    :param vmin_per, vmax_per: float. Define the data range that the colormap
+        covers by percentile.
     :param dB: bool. Transfer data unit to dB and take 1 as the reference value.
     :param xmode: str. 'distance' or 'channel'.
     :param tmode: str. 'time' or 'sampling'.
@@ -67,7 +69,9 @@ def plot(data: np.ndarray, dx=None, fs=None, ax=None, obj='waveform', dpi=300,
 
     if obj in ['waveform', 'phasepick']:
         cmap = 'RdBu' if cmap is None else cmap
-        vmax = np.percentile(abs(data), 80) if vmax is None else vmax
+        if vmax is None:
+            vmax_per = 80 if vmax_per is None else vmax_per
+            vmax = np.percentile(data, vmax_per)
         vmin = -vmax if vmin is None else vmin
         origin = 'upper'
         if fs is None or tmode == 'sampling':
@@ -98,13 +102,19 @@ def plot(data: np.ndarray, dx=None, fs=None, ax=None, obj='waveform', dpi=300,
                             c=pick_color[phase])
 
     elif obj in ['spectrum', 'spectrogram', 'fk', 'dispersion']:
-        if isinstance(data[0,0], (complex, np.complex64)):
+        if np.iscomplex(data).any():
             data = abs(data)
         if dB:
             data = 20 * np.log10(data)
         cmap = 'jet' if cmap is None else cmap
-        vmax = np.percentile(abs(data), 80) if vmax is None else vmax
-        vmin = np.percentile(abs(data), 20) if vmin is None else vmin
+
+        if vmax is None:
+            vmax_per = 80 if vmax_per is None else vmax_per
+            vmax = np.percentile(data, vmax_per)
+        if vmin is None:
+            vmin_per = 20 if vmin_per is None else vmin_per
+            vmin = np.percentile(data, vmin_per)
+
         if obj == 'spectrum':
             origin = 'lower'
             if dx is None or xmode.lower() == 'channel':

{daspy_toolbox-1.1.5 → daspy_toolbox-1.1.6}/daspy/core/collection.py

@@ -1,8 +1,9 @@
 # Purpose: Module for handling Collection objects.
 # Author: Minzhe Hu
-# Date: 2025.3.30
+# Date: 2025.5.21
 # Email: hmz2018@mail.ustc.edu.cn
 import os
+import gc
 import warnings
 import numpy as np
 from copy import deepcopy
@@ -12,10 +13,6 @@ from daspy.core.read import read
 from daspy.core.dasdatetime import DASDateTime
 
 
-cascade_method = ['time_integration', 'time_differential', 'downsampling',
-                  'bandpass', 'bandstop', 'lowpass', 'highpass',
-                  'lowpass_cheby_2']
-
 class Collection(object):
     def __init__(self, fpath, ftype=None, flength=None, meta_from_file=True,
                  timeinfo_slice=slice(None), timeinfo_format=None, 
@@ -265,8 +262,18 @@ class Collection(object):
                 kwargs_list.append(kwargs)
         return method_list, kwargs_list
 
+    def _kwargs_initialization(method_list, kwargs_list):
+        for j, method in enumerate(method_list):
+            if method == 'time_integration':
+                kwargs_list[j]['c'] = 0
+            elif method == 'time_differential':
+                kwargs_list[j]['prepend'] = 0
+            elif method in ['bandpass', 'bandstop', 'lowpass',
+                            'highpass', 'lowpass_cheby_2']:
+                kwargs_list[j]['zi'] = 0
+
     def process(self, operations, savepath='./processed', merge=1,
-                suffix='_pro', ftype=None, **read_kwargs):
+                suffix='_pro', ftype=None, dtype=None, **read_kwargs):
         """
         :param operations: list. Each element of operations list should be [str
             of method name, dict of kwargs].
@@ -274,8 +281,10 @@ class Collection(object):
         :param merge: int or str. int for merge several processed files into 1.
             'all' for merge all files.
         :param suffix: str. Suffix for processed files.
-        :param ftype: None or str. None for automatic detection, or 'pkl',
-            'pickle', 'tdms', 'h5', 'hdf5', 'segy', 'sgy', 'npy'.
+        :param ftype: None or str. File format for saving. None for automatic
+            detection, or 'pkl', 'pickle', 'tdms', 'h5', 'hdf5', 'segy', 'sgy',
+            'npy'.
+        :param dtype: str. The data type of the saved data.
         :param read_kwargs: dict. Paramters for read function.
         """
         if not os.path.exists(savepath):
@@ -283,36 +292,35 @@ class Collection(object):
         method_list, kwargs_list = self._optimize_for_continuity(operations)
         if merge == 'all' or merge > len(self):
             merge = len(self)
-        for i in tqdm(range(0, len(self))):
+        for i in tqdm(range(len(self))):
             f = self[i]
             if os.path.getsize(f) == 0:
-                for j, method in enumerate(method_list):
-                    if method == 'time_integration':
-                        kwargs_list[j]['c'] = 0
-                    elif method == 'time_differential':
-                        kwargs_list[j]['prepend'] = 0
-                    elif method in ['bandpass', 'bandstop', 'lowpass',
-                                    'highpass', 'lowpass_cheby_2']:
-                        kwargs_list[j]['zi'] = 0
+                self._kwargs_initialization(method_list, kwargs_list)
+                continue
+            try:
+                sec = read(f, ftype=self.ftype, **read_kwargs)
+            except Exception as e:
+                warnings.warn(f'Error reading {f}: {e}')
+                self._kwargs_initialization(method_list, kwargs_list)
                 continue
-            sec = read(f, ftype=self.ftype, **read_kwargs)
             for j, method in enumerate(method_list):
                 if method in ['taper', 'cosine_taper']:
-                    if not ((i==0 and kwargs_list[j] != 'right') or
-                             (i == len(self) - 1 and kwargs_list[j] != 'left')):
+                    if not ((i==0 and kwargs_list[j]['side'] != 'right') or
+                             (i == len(self) - 1 and kwargs_list[j]['side'] !=
+                              'left')):
                         continue
-                out = eval(f'sec.{method}')(**kwargs_list[j])
+                out = getattr(sec, method)(**kwargs_list[j])
                 if method == 'time_integration':
-                    kwargs_list[j]['c'] = sec.data[:, -1]
+                    kwargs_list[j]['c'] = sec.data[:, -1].copy()
                 elif method == 'time_differential':
-                    kwargs_list[j]['prepend'] = sec.data[:, -1]
+                    kwargs_list[j]['prepend'] = sec.data[:, -1].copy()
                 elif method in ['bandpass', 'bandstop', 'lowpass', 'highpass',
                                 'lowpass_cheby_2']:
                     kwargs_list[j]['zi'] = out
             
-            if i % merge == 0: 
+            if i % merge == 0:
                 if i != 0:
-                    sec_merge.save(filepath)
+                    sec_merge.save(filepath, dtype=dtype)
                 sec_merge = sec
                 f0, f1 = os.path.splitext(os.path.basename(f))
                 if ftype is not None:
@@ -320,4 +328,35 @@ class Collection(object):
                 filepath = os.path.join(savepath, f0+suffix+f1)
             else:
                 sec_merge += sec
-        sec_merge.save(filepath)
+            del sec
+            gc.collect()
+        sec_merge.save(filepath, dtype=dtype)
+
+# Dynamically add methods for cascade_methods
+def _create_cascade_method(method_name):
+    def cascade_method(self, savepath='./processed', merge=1,
+                       suffix=f'_{method_name}', ftype=None, dtype=None,
+                       **kwargs):
+        """
+        Automatically generated method for {method_name}.
+        Applies the {method_name} operation to the data and saves the result.
+
+        :param savepath: str. Path to save processed files.
+        :param merge: int or str. int for merge several processed files into 1.
+            'all' for merge all files.
+        :param suffix: str. Suffix for processed files.
+        :param ftype: None or str. None for automatic detection, or 'pkl',
+            'pickle', 'tdms', 'h5', 'hdf5', 'segy', 'sgy', 'npy'.
+        :param kwargs: dict. Parameters for the {method_name} operation.
+        :param dtype: str. The data type of the saved data.
+        """
+        operations = [[method_name, kwargs]]
+        self.process(operations, savepath=savepath, merge=merge, suffix=suffix,
+                     ftype=ftype, dtype=dtype)
+    return cascade_method
+
+
+for method in ['time_integration', 'time_differential', 'downsampling',
+               'bandpass', 'bandstop', 'lowpass', 'highpass',
+               'lowpass_cheby_2']:
+    setattr(Collection, method, _create_cascade_method(method))

{daspy_toolbox-1.1.5 → daspy_toolbox-1.1.6}/daspy/core/read.py

@@ -1,6 +1,6 @@
 # Purpose: Module for reading DAS data.
 # Author: Minzhe Hu
-# Date: 2024.11.20
+# Date: 2025.5.21
 # Email: hmz2018@mail.ustc.edu.cn
 # Partially modified from
 # https://github.com/RobbinLuo/das-toolkit/blob/main/DasTools/DasPrep.py
@@ -10,6 +10,7 @@ import pickle
 import numpy as np
 import h5py
 import segyio
+from typing import Union
 from pathlib import Path
 from nptdms import TdmsFile
 from daspy.core.section import Section
@@ -17,7 +18,7 @@ from daspy.core.dasdatetime import DASDateTime, utc
 
 
 def read(fname=None, output_type='section', ftype=None, headonly=False,
-         **kwargs):
+         dtype=None, **kwargs) -> Union[Section, tuple]:
     """
     Read a .pkl/.pickle, .tdms, .h5/.hdf5, .segy/.sgy file.
 
@@ -34,6 +35,7 @@ def read(fname=None, output_type='section', ftype=None, headonly=False,
     :param ch1: int. The first channel required.
     :param ch2: int. The last channel required (not included).
     :param dch: int. Channel step.
+    :param dtype: str. The data type of the returned data.
     :return: An instance of daspy.Section, or numpy.array for data and a
         dictionary for metadata.
     """
@@ -55,10 +57,13 @@ def read(fname=None, output_type='section', ftype=None, headonly=False,
             ftype = ftype.replace(*rtp)
         data, metadata = fun_map[ftype](fname, headonly=headonly, **kwargs)
 
+    if dtype is not None:
+        data = data.astype(dtype)
     if output_type.lower() == 'section':
         metadata['source'] = Path(fname)
         metadata['source_type'] = ftype
-        return Section(data.astype(float), **metadata)
+        data[np.isnan(data)] = 0
+        return Section(data, **metadata)
     elif output_type.lower() == 'array':
         return data, metadata
 
@@ -184,6 +189,22 @@ def _read_h5(fname, headonly=False, **kwargs):
                         'dx': dx * dch, 'start_channel': ch1,
                         'start_distance': ch1 * dx,
                         'gauge_length': h5_file.get('GaugeLength')[()]}
+        elif len(h5_file.keys()) == 3: # OpataSense
+            nch = h5_file['data'].shape[1]
+            ch1 = kwargs.pop('ch1', 0)
+            ch2 = kwargs.pop('ch2', nch)
+            dch = kwargs.pop('dch', 1)
+            if headonly:
+                data = np.zeros_like(h5_file['data'])
+            else:
+                data = h5_file['data'][ch1:ch2:dch, :]
+            dx = (h5_file['x_axis'][-1] - h5_file['x_axis'][0]) / \
+                (len(h5_file['x_axis']) - 1)
+            fs = (len(h5_file['t_axis']) - 1) / (h5_file['t_axis'][-1] -
+                                                 h5_file['t_axis'][0])
+            metadata = {'dx': dx, 'fs': fs, 'start_channel': ch1,
+                        'start_distance': h5_file['x_axis'][0] + dx * ch1,
+                        'start_time': h5_file['t_axis'][0]}
         elif set(h5_file.keys()) == {'Mapping', 'Acquisition'}: # Silixa/iDAS
             nch = h5_file['Acquisition/Raw[0]'].attrs['NumberOfLoci']
             ch1 = kwargs.pop('ch1', 0)
@@ -274,7 +295,7 @@ def _read_h5(fname, headonly=False, **kwargs):
             ch2 = kwargs.pop('ch2', nch)
             dch = kwargs.pop('dch', 1)
             if headonly:
-                data = np.zeros_like(h5_file['raw_data'])
+                data = np.zeros_like(h5_file['data'])
             else:
                 data = h5_file['data'][ch1:ch2:dch, :]
             attr = h5_file['data'].attrs
@@ -340,7 +361,7 @@ def _read_h5(fname, headonly=False, **kwargs):
             else:
                 if len(dataset.shape) == 3: # Febus A1-R
                     data = dataset[:, :, ch1 - start_channel:ch2 - start_channel
-                                   :dch].T.reshape(((ch2 - ch1) // dch, -1))
+                                   :dch].reshape((-1, (ch2 - ch1) // dch)).T
                 elif len(dataset.shape) == 2: # Febus A1
                     data = dataset[:, ch1 - start_channel:ch2 - start_channel:
                                    dch].T

{daspy_toolbox-1.1.5 → daspy_toolbox-1.1.6}/daspy/core/section.py

@@ -1,6 +1,6 @@
 # Purpose: Module for handling Section objects.
 # Author: Minzhe Hu
-# Date: 2025.4.2
+# Date: 2025.5.15
 # Email: hmz2018@mail.ustc.edu.cn
 import warnings
 import os
@@ -162,6 +162,10 @@ class Section(object):
     def nt(self):
         return self.data.shape[1]
 
+    @property
+    def channel_number(self):
+        return np.arange(self.nch).astype(int) + self.start_channel
+
     @property
     def end_channel(self):
         return self.start_channel + self.nch - 1
@@ -172,7 +176,7 @@ class Section(object):
     
     @property
     def channel_distance(self):
-        return self.dx * np.arange(self.nch) + self.start_channel
+        return self.dx * np.arange(self.nch) + self.start_distance
 
     @property
     def end_distance(self):
@@ -232,10 +236,10 @@ class Section(object):
         data = np.zeros((max(channel_no) + 1, nt))
         for i, tr in enumerate(st):
             data[channel_no[i]] = tr.data
-
+        # data = data.astype(float)
         warnings.warn('obspy.core.stream.Stream doesn\'t include channel '
                       'interval. Please set dx manually.')
-        return cls(data.astype(float), None, fs, start_channel=start_channel,
+        return cls(data, None, fs, start_channel=start_channel,
                    start_time=start_time, scale=scale, source=source)
 
     @classmethod
@@ -418,7 +422,7 @@ class Section(object):
                      start_channel=self.start_channel, channel_spacing=self.dx,
                      unit=unit)
 
-    def save(self, fname=None, ftype=None, keep_format=False):
+    def save(self, fname=None, ftype=None, keep_format=False, dtype=None):
         """
         Save the instance as a pickle file or update the raw file and resave as
         new file.
@@ -430,6 +434,7 @@ class Section(object):
         :param keep_format: bool. If True, we will make a copy of the
             self.source file and make changes to it. This will strictly preserve
             the original format, but will cost more IO resources.
+        :param dtype: str. The data type of the saved data.
         """
         if fname is None:
             if hasattr(self, 'source'):
@@ -452,9 +457,36 @@ class Section(object):
                 raise ValueError('self.source is not a file.')
             if ftype != self.source_type:
                 raise ValueError('self.source_type is different from ftype.')
-            write(self, fname, ftype=ftype, raw_fname=self.source)
+            write(self, fname, ftype=ftype, raw_fname=self.source, dtype=dtype)
+        else:
+            write(self, fname, ftype=ftype, dtype=dtype)
+
+        return self
+
+    def concat(self, other, reverse=True):
+        """
+        Concatenate two sections in space.
+
+        :param other: Section. Another section to concatenate.
+        :param reverse: bool. If True, the start channels of the two are
+            connected, and the channel numbers of the original Section instances
+            becomes a negative number.
+        """
+        if isinstance(other, Section):
+            assert self.fs == other.fs, 'The sampling rate of the two ' \
+                'sections should be the same.'
+            assert self.dx == other.dx, 'The channel interval of the two ' \
+                'sections should be the same.'
+            assert self.duration == other.duration, 'The duration of the two ' \
+                'sections should be the same.'
+            if reverse:
+                self.start_channel = -self.end_channel
+                self.start_distance = -self.end_distance
+                self.data = np.vstack((self.data[::-1], other.data))
+            else:
+                self.data = np.vstack((self.data, other.data))
         else:
-            write(self, fname, ftype=ftype)
+            raise TypeError('The input should be Section.')
 
         return self
 
@@ -495,6 +527,8 @@ class Section(object):
         :param cmap: str or Colormap. The Colormap instance or registered
             colormap name used to map scalar data to colors.
         :param vmin, vmax: Define the data range that the colormap covers.
+        :param vmin_per, vmax_per: float. Define the data range that the
+            colormap covers by percentile.
         :param xlim, ylim: Set the x-axis and y-axis view limits.
         :param dB: bool. Transfer data unit to dB and take 1 as the reference
             value.

{daspy_toolbox-1.1.5 → daspy_toolbox-1.1.6}/daspy/core/write.py

@@ -1,6 +1,6 @@
 # Purpose: Module for writing DAS data.
 # Author: Minzhe Hu
-# Date: 2024.11.20
+# Date: 2025.5.21
 # Email: hmz2018@mail.ustc.edu.cn
 import os
 import warnings
@@ -13,12 +13,15 @@ from nptdms import TdmsFile, TdmsWriter, RootObject, GroupObject, ChannelObject
 from datetime import datetime
 
 
-def write(sec, fname, ftype=None, raw_fname=None):
+def write(sec, fname, ftype=None, raw_fname=None, dtype=None):
     fun_map = {'tdms': _write_tdms, 'h5': _write_h5, 'sgy': _write_segy}
     if ftype is None:
         ftype = str(fname).lower().split('.')[-1]
     ftype.replace('hdf5', 'h5')
     ftype.replace('segy', 'sgy')
+    if dtype is not None:
+        sec = sec.copy()
+        sec.data = sec.data.astype(dtype)
     if ftype == 'pkl':
         write_pkl(sec, fname)
     elif ftype == 'npy':
@@ -175,6 +178,12 @@ def _write_h5(sec, fname, raw_fname=None):
                 if hasattr(sec, 'gauge_length'):
                     _update_h5_dataset(h5_file, '/', 'GaugeLength',
                                        sec.gauge_length)
+            elif len(h5_file.keys()) == 3:
+                _update_h5_dataset(h5_file, '/', 'data', sec.data)
+                _update_h5_dataset(h5_file, '/', 'x_axis',
+                    sec.start_distance + np.arange(sec.nch) * sec.dx)
+                _update_h5_dataset(h5_file, '/', 't_axis',
+                                   sec.start_time + np.arange(sec.nt) * sec.dt)
             elif group == 'Acquisition':
                 h5_file['Acquisition'].attrs['NumberOfLoci'] = sec.nch
                 _update_h5_dataset(h5_file, 'Acquisition/Raw[0]/', 'RawData',
@@ -279,7 +288,7 @@ def _write_segy(sec, fname, raw_fname=None):
         with segyio.create(fname, spec) as new_file:
             new_file.header.length = sec.nch
             new_file.header.segy._filename = fname
-            new_file.trace = sec.data.astype(np.float32)
+            new_file.trace = sec.data # .astype(np.float32)
     else:
         with segyio.open(raw_fname, ignore_geometry=True) as raw_file:
             spec.sorting = raw_file.sorting

{daspy_toolbox-1.1.5 → daspy_toolbox-1.1.6}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 
 setup(
-    name='DASPy-toolbox', version='1.1.5',
+    name='DASPy-toolbox', version='1.1.6',
     description=(
         'DASPy is an open-source project dedicated to provide a python package '
         'for DAS (Distributed Acoustic Sensing) data processing, which '