dbdreader 0.6.0.dev1__tar.gz → 0.6.1__tar.gz

{dbdreader-0.6.0.dev1 → dbdreader-0.6.1}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: dbdreader
-Version: 0.6.0.dev1
+Version: 0.6.1
 Summary: A python module to access binary data files generated by Teledyne WebbResearch gliders
 Author-email: Lucas Merckelbach <lucas.merckelbach@hereon.de>
-License: GPL-3.0
+License: GPL-3.0-or-later
 Project-URL: Homepage, https://dbdreader.readthedocs.io/en/latest/
 Classifier: Programming Language :: Python :: 3
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: POSIX
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -15,7 +15,6 @@ License-File: LICENSE
 License-File: COPYING
 Requires-Dist: lz4>=4.4.5
 Requires-Dist: numpy>=2.2.6
-Requires-Dist: scipy>=1.15.3
 Dynamic: license-file
 
 [![PyPI version](https://badgen.net/pypi/v/dbdreader)](https://pypi.org/project/dbdreader)
@@ -34,6 +33,22 @@ binary files, so that they can be further analysed.
 
 ## Change log
 
+### Version 6.0.1
+
+* Drops dependency on scipy.
+
+### Version 6.0.0
+
+* Offers a python only implementation, alongside the C-extension to
+  read the binary files. At the expense of processing speed, no
+  compiler is required to use this package.
+  
+* A github workflow is implemented that generates pre-compiled wheels
+  for linux and windows platforms for python version 3.10, 3.11, 3.12
+  and 3.13.
+  
+* Some speed improvements of the C-extenstion
+
 ### version 0.5.9
 
 * Handles reading errors that can occur when a compressed file turns

{dbdreader-0.6.0.dev1 → dbdreader-0.6.1}/README.md

@@ -14,6 +14,22 @@ binary files, so that they can be further analysed.
 
 ## Change log
 
+### Version 6.0.1
+
+* Drops dependency on scipy.
+
+### Version 6.0.0
+
+* Offers a python only implementation, alongside the C-extension to
+  read the binary files. At the expense of processing speed, no
+  compiler is required to use this package.
+  
+* A github workflow is implemented that generates pre-compiled wheels
+  for linux and windows platforms for python version 3.10, 3.11, 3.12
+  and 3.13.
+  
+* Some speed improvements of the C-extenstion
+
 ### version 0.5.9
 
 * Handles reading errors that can occur when a compressed file turns

dbdreader-0.6.1/dbdreader/_dbdreader.py

@@ -0,0 +1,294 @@
+"""
+Pure Python/NumPy replacement for the _dbdreader C extension.
+
+Reads Slocum glider binary DBD/SBD/MBD/etc. files.  The public API is a
+single function ``get()`` whose signature matches the C extension exactly.
+
+Binary format recap
+-------------------
+After the ASCII header there is a "known cycle" (17 bytes) that the glider
+always writes with fixed values so the reader can detect byte order:
+
+    [0]     's'            cycle-tag byte
+    [1]     <1-byte int>
+    [2:4]   0x1234         two-byte uint  (little-endian if == 4660 decimal)
+    [4:8]   123.456        four-byte float
+    [8:16]  123456789...   eight-byte double
+    [16]    'd'            separator before first real cycle
+
+Every subsequent cycle looks like:
+
+    <n_state_bytes>   2-bit-packed state fields (4 fields/byte, MSB first)
+                      each field: UPDATED=2, SAME=1, NOTSET=0
+    <data bytes>      concatenated raw values for UPDATED sensors only,
+                      in ascending sensor-index order
+    'd' (0x64)        separator before the next cycle's state bytes
+
+Performance strategy
+--------------------
+Two-pass approach to minimise Python overhead:
+
+Pass 1  – cheap Python loop over cycles to locate cycle boundaries.
+          Uses a pre-built per-byte-position lookup table so each cycle
+          costs only n_state_bytes Python ops (not n_sensors).
+
+Pass 2  – batch numpy operations over ALL cycles at once:
+          • extract state bytes for every cycle in one fancy-index read
+          • decode fields and compute chunk offsets with vectorised ops
+          • read sensor values for wanted sensors with vectorised byte extraction
+
+This replaces the original approach of ~8 numpy array allocations per cycle
+inside a Python loop, which dominated runtime for files with many cycles.
+"""
+
+import struct
+import numpy as np
+
+
+# ── constants (mirror dbdreader.h) ───────────────────────────────────────────
+FILLVALUE = 1e9
+UPDATED   = 2
+SAME      = 1
+NOTSET    = 0
+_FMT_CHAR = {2: 'h', 4: 'f', 8: 'd'}   # byte-size → struct char
+
+# Shift amounts to extract 4 × 2-bit fields from one byte (MSB first)
+_SHIFTS = np.array([6, 4, 2, 0], dtype=np.int32)
+
+
+# ── helpers ──────────────────────────────────────────────────────────────────
+
+def _read_file(filename: str) -> bytes:
+    """Return raw decompressed bytes for *filename* (handles .?cd/.?cg files)."""
+    from dbdreader.decompress import is_compressed, Decompressor
+    if is_compressed(filename):
+        with Decompressor(filename) as d:
+            return d.decompress()
+    with open(filename, 'rb') as fh:
+        return fh.read()
+
+
+def _insert_ti(vi_list: list, ti: int):
+    """
+    Insert *ti* into sorted *vi_list* before the first element > ti,
+    replicating the C code in get_variable().
+
+    Returns (vit, nti) where vit is the extended list and nti is the index
+    of ti within vit.
+    """
+    vit = []
+    i   = 0
+    while i < len(vi_list):
+        if vi_list[i] > ti:
+            break
+        vit.append(vi_list[i])
+        i += 1
+    vit.append(ti)
+    nti = i
+    for j in range(i, len(vi_list)):
+        vit.append(vi_list[j])
+    return vit, nti
+
+
+def _build_chunk_lut(n_state_bytes: int, n_sensors: int, bs_list: list) -> list:
+    """
+    Build a lookup table: lut[byte_pos][byte_value] = total data bytes
+    contributed to the chunk by the four sensors encoded in that state byte.
+
+    Used in Pass 1 to compute chunksize per cycle in O(n_state_bytes) ops.
+    """
+    byte_vals = np.arange(256, dtype=np.int32)
+    lut = np.zeros((n_state_bytes, 256), dtype=np.int32)
+    for bpos in range(n_state_bytes):
+        for slot in range(4):
+            sidx = bpos * 4 + slot
+            if sidx >= n_sensors:
+                break
+            shift = 6 - slot * 2          # 6, 4, 2, 0
+            states = (byte_vals >> shift) & 3          # (256,)
+            lut[bpos] += (states == UPDATED) * bs_list[sidx]
+    return lut.tolist()                    # nested Python list for fast indexing
+
+
+# ── public API ───────────────────────────────────────────────────────────────
+
+def get(n_state_bytes, n_sensors, bin_offset, byte_sizes,
+        filename, ti, vi, return_nans, skip_initial_line, max_values_to_read):
+    """
+    Read one or more sensor time-series from a glider binary data file.
+
+    Parameters match the C extension exactly:
+
+    n_state_bytes      : int   – number of state bytes per cycle
+    n_sensors          : int   – total sensors in the file
+    bin_offset         : int   – byte offset to the start of binary data
+    byte_sizes         : tuple – byte size for each of the n_sensors sensors
+    filename           : str   – path to the data file (compressed or not)
+    ti                 : int   – sensor index of the time variable
+    vi                 : tuple – sorted sensor indices to retrieve
+    return_nans        : int   – 1 → include NOTSET slots as FILLVALUE rows
+    skip_initial_line  : int   – 1 → discard first data cycle
+    max_values_to_read : int   – stop after this many rows (0 = unlimited)
+
+    Returns
+    -------
+    (error_no, result) where error_no is 0 on success and result is a
+    list of 2*nv lists:
+        [t_0, t_1, …, t_{nv-1}, v_0, v_1, …, v_{nv-1}]
+    where each t_i / v_i is a Python list of floats.
+    """
+
+    try:
+        data = _read_file(filename)
+    except FileNotFoundError:
+        return 2, []   # ERROR_FILE_NOT_FOUND
+    except Exception:
+        return 1, []   # ERROR_UNEXPECTED_END_OF_FILE
+    nv       = len(vi)
+    bs_list  = list(byte_sizes)
+    vit, nti = _insert_ti(list(vi), ti)
+    nvt      = len(vit)          # = nv + 1
+
+    # ── byte-order detection ─────────────────────────────────────────────────
+    endian = '<' if struct.unpack_from('<H', data, bin_offset + 2)[0] == 4660 else '>'
+
+    # ── numpy array of byte sizes (used in vectorised pass 2) ────────────────
+    bs_arr = np.array(bs_list, dtype=np.int32)    # (n_sensors,)
+    vit_arr = np.array(vit,    dtype=np.intp)     # (nvt,)
+
+    # ── chunk-size lookup table (for pass 1) ─────────────────────────────────
+    chunk_lut = _build_chunk_lut(n_state_bytes, n_sensors, bs_list)
+
+    # ── PASS 1: locate cycle boundaries ──────────────────────────────────────
+    # For each cycle record (state_bytes + data_chunk + separator):
+    #   * record the file position of the state bytes
+    #   * compute the data-chunk size using the lookup table
+    # Cost: O(n_cycles × n_state_bytes) pure-Python ops — cheap.
+
+    min_offset_value = -2 if return_nans else -1
+    file_size        = len(data)
+    pos              = bin_offset + 17      # skip known cycle
+    write_data       = not bool(skip_initial_line)
+
+    state_positions = []    # file pos of state bytes for each cycle
+    chunk_sizes     = []    # data-chunk byte count for each cycle
+    write_flags     = []    # whether to emit output for each cycle
+
+    while pos < file_size:
+        if pos + n_state_bytes > file_size:
+            break
+
+        # Chunksize via LUT: O(n_state_bytes) lookups
+        chunksize = 0
+        for bpos in range(n_state_bytes):
+            chunksize += chunk_lut[bpos][data[pos + bpos]]
+
+        state_positions.append(pos)
+        chunk_sizes.append(chunksize)
+        write_flags.append(write_data)
+
+        pos        += n_state_bytes + chunksize + 1
+        write_data  = True
+
+    n_cycles = len(state_positions)
+    if n_cycles == 0:
+        return 0, [[] for _ in range(nv)] + [[] for _ in range(nv)]
+
+    # ── PASS 2: vectorised processing of all cycles at once ──────────────────
+    data_u8   = np.frombuffer(data, dtype=np.uint8)
+    sp_arr    = np.array(state_positions, dtype=np.intp)   # (n_cycles,)
+    cstart    = sp_arr + n_state_bytes                      # chunk start positions
+
+    # Extract state bytes for ALL cycles: shape (n_cycles, n_state_bytes)
+    sb_idx   = sp_arr[:, np.newaxis] + np.arange(n_state_bytes, dtype=np.intp)
+    all_sb   = data_u8[sb_idx]          # uint8, (n_cycles, n_state_bytes)
+
+    # Decode 2-bit fields: (n_cycles, n_state_bytes, 4) → (n_cycles, n_sensors)
+    all_fields = ((all_sb[:, :, np.newaxis] >> _SHIFTS) & 3)   # int, (n_cycles, n_state_bytes, 4)
+    all_fields = all_fields.reshape(n_cycles, n_state_bytes * 4)[:, :n_sensors]
+
+    # Compute byte offsets within the data chunk for every sensor in every cycle.
+    # UPDATED → cumulative offset; SAME → -1; NOTSET → -2.
+    upd_mask  = (all_fields == UPDATED)                             # bool, (n_cycles, n_sensors)
+    w_bs      = np.where(upd_mask, bs_arr[np.newaxis, :], 0)       # int32, (n_cycles, n_sensors)
+    cum_bs    = np.cumsum(w_bs, axis=1)                             # int32, (n_cycles, n_sensors)
+    all_off   = np.where(upd_mask, cum_bs - w_bs, np.int32(-1))    # (n_cycles, n_sensors)
+    all_off   = np.where(all_fields == NOTSET, np.int32(-2), all_off)
+
+    # Offsets for only the wanted sensors: (n_cycles, nvt)
+    wanted_off = all_off[:, vit_arr]    # int32, (n_cycles, nvt)
+
+    # ── helper: read all values for one column of wanted_off ─────────────────
+    def _read_col(col: int) -> np.ndarray:
+        """
+        Return float64 array (n_cycles,) for wanted sensor at column *col*.
+        UPDATED cycles → actual data value.
+        SAME cycles    → carry-forward of last UPDATED value (numpy ffill).
+        NOTSET cycles  → NaN (or FILLVALUE if return_nans).
+        """
+        sidx    = vit[col]
+        bs      = bs_list[sidx]
+        offsets = wanted_off[:, col]            # int32, (n_cycles,)
+        vals    = np.full(n_cycles, np.nan, dtype=np.float64)
+
+        upd = np.where(offsets >= 0)[0]        # indices of UPDATED cycles
+        if upd.size:
+            abs_pos = cstart[upd] + offsets[upd].astype(np.intp)
+
+            if bs == 1:
+                raw = data_u8[abs_pos].view(np.int8).astype(np.float64)
+                vals[upd] = raw
+            else:
+                # Gather bs consecutive bytes for each updated cycle,
+                # reinterpret as the sensor's native type.
+                bidx = abs_pos[:, np.newaxis] + np.arange(bs, dtype=np.intp)
+                raw  = data_u8[bidx].tobytes()          # flat byte buffer
+                dt   = np.dtype(endian + _FMT_CHAR[bs])
+                vals[upd] = np.frombuffer(raw, dtype=dt)
+
+        # Forward-fill: propagate each UPDATED value into subsequent SAME slots.
+        # Classic numpy trick: build an index array that "sticks" at the last
+        # non-NaN position, then use it to index vals.
+        has_val = ~np.isnan(vals)
+        ff_idx  = np.where(has_val, np.arange(n_cycles, dtype=np.intp), np.intp(0))
+        np.maximum.accumulate(ff_idx, out=ff_idx)
+        vals = vals[ff_idx]
+
+        # NOTSET cycles: mark as FILLVALUE (if return_nans) or leave as
+        # carried-forward value (which will be excluded by the mask below).
+        if return_nans:
+            vals[offsets == np.int32(-2)] = FILLVALUE
+
+        return vals
+
+    # ── read time and sensor values ───────────────────────────────────────────
+    t_vals = _read_col(nti)                     # (n_cycles,) float64
+    write_arr = np.array(write_flags, dtype=bool)
+
+    result_t = [None] * nv
+    result_v = [None] * nv
+
+    for col in range(nvt):
+        if col == nti:
+            continue
+        j = col - (1 if col > nti else 0)      # output index in result_t/v
+
+        v_vals   = _read_col(col)
+        v_off    = wanted_off[:, col]
+
+        # Include this cycle in output if:
+        #   • write_flags says so (skip_initial_line handling)
+        #   • sensor has a valid offset (UPDATED or SAME; also NOTSET if return_nans)
+        include  = (v_off >= min_offset_value)
+        mask     = write_arr & include
+
+        if max_values_to_read > 0:
+            keep = np.where(mask)[0]
+            if keep.size > max_values_to_read:
+                mask          = np.zeros(n_cycles, dtype=bool)
+                mask[keep[:max_values_to_read]] = True
+
+        result_t[j] = t_vals[mask].tolist()
+        result_v[j] = v_vals[mask].tolist()
+
+    return 0, [result_t[j] for j in range(nv)] + [result_v[j] for j in range(nv)]

{dbdreader-0.6.0.dev1 → dbdreader-0.6.1}/dbdreader/dbdreader.py

@@ -4,7 +4,6 @@ import os
 import struct
 import time
 import numpy
-from scipy.interpolate import interp1d as si_interp1d
 import glob
 import sys
 import re
@@ -183,6 +182,20 @@ DBD_ERROR_DECOMPRESSION_ERROR = 15
 
 
 class DbdError(Exception):
+    '''Exception raised for all dbdreader errors.
+
+    Parameters
+    ----------
+    value: int, optional
+        one of the DBD_ERROR_* constants defined in this module,
+        identifying the kind of error that occurred.
+    mesg: str or None, optional
+        additional, free-form message appended to the standard
+        message associated with ``value``.
+    data: object or None, optional
+        optional payload with extra information about the error, for
+        example a :class:`DbdError.MissingCacheFileData` namedtuple.
+    '''
     MissingCacheFileData = namedtuple('MissingCacheFileData',
                                       'missing_cache_files cache_dir')
 
@@ -294,6 +307,32 @@ def heading_interpolating_function_factory(t, v):
     return lambda _t: numpy.arctan2(yi(_t), xi(_t)) % (2*numpy.pi)
 
 
+def _default_interp1d_factory(x, y):
+    '''Default linear interpolating function factory used by get_sync()
+    and get_CTD_sync().
+
+    Equivalent to scipy.interpolate.interp1d(x, y, bounds_error=False,
+    fill_value=numpy.nan), implemented with numpy.interp instead so that
+    dbdreader does not require scipy as a runtime dependency. Callers that
+    want other interpolation schemes (e.g. cubic splines) can still pass
+    their own interpolating_function_factory, importing scipy themselves
+    if needed.
+
+    numpy.interp requires x to be sorted (non-decreasing); scipy's interp1d
+    sorts internally by default (assume_sorted=False), so we do the same
+    here rather than assume the caller's x is already ordered.
+    '''
+    if len(x) < 1:
+        raise ValueError("Interpolation requires at least one data point.")
+    x = numpy.asarray(x)
+    y = numpy.asarray(y)
+    if numpy.any(numpy.diff(x) < 0):
+        idx = numpy.argsort(x)
+        x = x[idx]
+        y = y[idx]
+    return partial(numpy.interp, xp=x, fp=y, left=numpy.nan, right=numpy.nan)
+
+
 class DBDCache(object):
 
     '''DBDCache manager
@@ -420,6 +459,8 @@ class DBDPatternSelect(object):
     ----------
     date_format : str, optional
          date format used to interpret date strings.
+    cacheDir : str or None, optional
+         path to CAC file cache directory. If None, the default path is used.
 
     Note
     ----
@@ -442,9 +483,6 @@ class DBDPatternSelect(object):
         date_format: str
             format to interpret date strings. Example "%H %d %m %Y"
 
-        cachedDir: str or None, optional
-            path to CAC file cache directory. If None, the default path is used.
-
         '''
         self.date_format=date_format
 
@@ -638,6 +676,13 @@ class DBDHeader(object):
 
     @property
     def factored(self):
+        ''' Value of the sensor_list_factored header field, or None if
+        the header has not been read yet.
+
+        Returns
+        -------
+        int or None
+        '''
         try:
             r = self.info['sensor_list_factored']
         except KeyError:
@@ -686,9 +731,23 @@ class DBDHeader(object):
         self.info['parameter_list'] = all_parameter_names
         return parameter
 
-    # private methods
     def parse(self,line):
-        # parses a binary datastream. So, first decode it to ascii.
+        ''' Parses a single header line.
+
+        Decodes a binary header line and, if it names a recognised
+        header keyword, stores the corresponding value in ``self.info``.
+
+        Parameters
+        ----------
+        line : bytes
+            single header line, as read from the binary file.
+
+        Returns
+        -------
+        str
+            the keyword parsed from the line. If the keyword is
+            recognised, its value is also stored in ``self.info``.
+        '''
         words=line.decode('ascii').rstrip().split(":")
         param=words[0]
         if param in self.keywords.keys():
@@ -709,7 +768,7 @@ class DBD(object):
     filename: str
         dbd filename
 
-    cachedDir: str or None, optional
+    cacheDir: str or None, optional
         path to CAC file cache directory. If None, the default path is used.
 
     skip_initial_line : bool, default: True
@@ -1292,7 +1351,7 @@ class MultiDBD(object):
     missions: list of str
         List of missions names that should be considered only.
 
-    maxfiles: int
+    max_files: int
        maximum number of files to be read, where
         >0: the first n files are read
         <0: the last n files are read.
@@ -1597,7 +1656,7 @@ class MultiDBD(object):
         tv = self.get(*parameters, decimalLatLon=decimalLatLon, discardBadLatLon=discardBadLatLon,
                       return_nans=False)
         
-        default_interpolating_function_factory = partial(si_interp1d, bounds_error=False, fill_value=numpy.nan)
+        default_interpolating_function_factory = _default_interp1d_factory
         
         t = tv[0][0]
         r = []

{dbdreader-0.6.0.dev1 → dbdreader-0.6.1}/dbdreader/decompress.py

@@ -163,6 +163,19 @@ def decompress_file(filename):
     return FileDecompressor().decompress(filename)
 
 def is_compressed(filename):
+    ''' Checks whether a filename indicates an lz4-compressed glider data file.
+
+    Parameters
+    ----------
+    filename : str
+        filename to check
+
+    Returns
+    -------
+    bool
+        True if the file extension indicates a compressed
+        [demnst]bd/[demnst]cg file, False otherwise.
+    '''
     [basename,ext]=os.path.splitext(filename)
     # all compressed [demnst]bd files end in [demnst]cd
     return bool(re_match("[demnst]c[dg]$", ext))
@@ -172,21 +185,45 @@ class BytesIORW:
     ''' Helper class implementing a BytesIO buffer that can be written to and read from.
 
     Note that the methods write() and readline() are implemented only.
+
+    Parameters
+    ----------
+    source : iterator of bytes
+        iterator (typically a decompressed-blocks generator) that
+        readline() draws from once the buffer is exhausted.
     '''
     def __init__(self, source):
         self.bytesIO = ioBytesIO()
         self.pointer_start = 0
         self.pointer_end = 0
         self.source = source
-        
+
     def write(self, b):
+        ''' Writes bytes to the buffer.
+
+        Parameters
+        ----------
+        b : bytes
+            data to append to the buffer. The read pointer is reset to
+            the start of the newly written data.
+        '''
         self.pointer_start = self.bytesIO.tell()
         self.bytesIO.write(b)
         self.pointer_end = self.bytesIO.tell()
         self.bytesIO.seek(self.pointer_start)
         self.is_exhausted = False
-        
+
     def readline(self):
+        ''' Reads a single line from the buffer.
+
+        If the buffer is exhausted, the next block is pulled from
+        ``source`` and appended before returning.
+
+        Returns
+        -------
+        bytes
+            a single line, or an empty bytes object if source is exhausted.
+        '''
         line = self.bytesIO.readline()
         pointer = self.bytesIO.tell()
         if pointer == self.pointer_end:
@@ -207,8 +244,14 @@ class CompressedFile:
 
     The main reason for the class is to be able to read the header of a compressed
     glider data file.
+
+    Parameters
+    ----------
+    filename : str
+        name of the compressed file to read. This class is designed to
+        be used within a context manager, which opens the file.
     '''
-    
+
 
     def __init__(self, filename):
         self.filename = filename
@@ -221,15 +264,29 @@ class CompressedFile:
         self.bytesIO = BytesIORW(source)
         return self
 
-    
+
     def __exit__(self, *p, **kwds):
         self.fp.close()
 
     def readline(self):
+        ''' Reads and decompresses a single line from the file.
+
+        Returns
+        -------
+        bytes
+            a single decompressed line, or an empty bytes object at end of file.
+        '''
         line = self.bytesIO.readline()
         return line
-    
+
     def readlines(self):
+        ''' Generator that reads and decompresses the file line by line.
+
+        Yields
+        ------
+        bytes
+            a single decompressed line.
+        '''
         while True:
             line = self.readline()
             if not line:
@@ -237,11 +294,25 @@ class CompressedFile:
             yield line
 
     def seek(self, offset):
+        ''' Sets the read position in the (decompressed, buffered) data.
+
+        Parameters
+        ----------
+        offset : int
+            absolute byte position to seek to.
+        '''
         return self.bytesIO.bytesIO.seek(offset)
 
     def tell(self):
+        ''' Returns the current read position in the (decompressed, buffered) data.
+
+        Returns
+        -------
+        int
+        '''
         return self.bytesIO.bytesIO.tell()
-    
+
 
     def close(self):
+        ''' Closes the underlying compressed file. '''
         self.fp.close()

{dbdreader-0.6.0.dev1 → dbdreader-0.6.1}/dbdreader.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: dbdreader
-Version: 0.6.0.dev1
+Version: 0.6.1
 Summary: A python module to access binary data files generated by Teledyne WebbResearch gliders
 Author-email: Lucas Merckelbach <lucas.merckelbach@hereon.de>
-License: GPL-3.0
+License: GPL-3.0-or-later
 Project-URL: Homepage, https://dbdreader.readthedocs.io/en/latest/
 Classifier: Programming Language :: Python :: 3
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: POSIX
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -15,7 +15,6 @@ License-File: LICENSE
 License-File: COPYING
 Requires-Dist: lz4>=4.4.5
 Requires-Dist: numpy>=2.2.6
-Requires-Dist: scipy>=1.15.3
 Dynamic: license-file
 
 [![PyPI version](https://badgen.net/pypi/v/dbdreader)](https://pypi.org/project/dbdreader)
@@ -34,6 +33,22 @@ binary files, so that they can be further analysed.
 
 ## Change log
 
+### Version 6.0.1
+
+* Drops dependency on scipy.
+
+### Version 6.0.0
+
+* Offers a python only implementation, alongside the C-extension to
+  read the binary files. At the expense of processing speed, no
+  compiler is required to use this package.
+  
+* A github workflow is implemented that generates pre-compiled wheels
+  for linux and windows platforms for python version 3.10, 3.11, 3.12
+  and 3.13.
+  
+* Some speed improvements of the C-extenstion
+
 ### version 0.5.9
 
 * Handles reading errors that can occur when a compressed file turns

{dbdreader-0.6.0.dev1 → dbdreader-0.6.1}/dbdreader.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ pyproject.toml
 requirements.txt
 setup.py
 dbdreader/__init__.py
+dbdreader/_dbdreader.py
 dbdreader/dbdreader.py
 dbdreader/decompress.py
 dbdreader/scripts.py

{dbdreader-0.6.0.dev1 → dbdreader-0.6.1}/dbdreader.egg-info/requires.txt

@@ -1,3 +1,2 @@
 lz4>=4.4.5
 numpy>=2.2.6
-scipy>=1.15.3

{dbdreader-0.6.0.dev1 → dbdreader-0.6.1}/pyproject.toml

@@ -1,23 +1,22 @@
 [project]
 name = "dbdreader"
-version = "0.6.0dev1"
+version = "0.6.1"
 description = "A python module to access binary data files generated by Teledyne WebbResearch gliders"
 readme = "README.md"
 requires-python = ">=3.10"
 authors = [
     {name = "Lucas Merckelbach", email = "lucas.merckelbach@hereon.de"}
 ]
-license = {text = "GPL-3.0"}
+license = {text = "GPL-3.0-or-later"}
 classifiers = [
     "Programming Language :: Python :: 3",
     "Intended Audience :: Science/Research",
-    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
     "Operating System :: POSIX",
 ]
 dependencies = [
     "lz4>=4.4.5",
     "numpy>=2.2.6",
-    "scipy>=1.15.3",
 ]
 
 
@@ -32,7 +31,9 @@ Homepage = "https://dbdreader.readthedocs.io/en/latest/"
 dev = [
     "black>=26.3.1",
     "ipython>=8.39.0",
+    "myst-parser>=4.0.1",
     "pytest>=9.0.2",
+    "sphinx-rtd-theme>=3.1.0",
 ]
 
 

{dbdreader-0.6.0.dev1 → dbdreader-0.6.1}/requirements.txt

@@ -1,5 +1,4 @@
 numpy
-scipy
 pytest
 lz4