legend-pydataobj 1.9.0__py3-none-any.whl → 1.10.1__py3-none-any.whl

lgdo/lh5/store.py

@@ -5,13 +5,17 @@ HDF5 files.
 
 from __future__ import annotations
 
+import bisect
 import logging
 import os
 import sys
+from collections import OrderedDict
 from collections.abc import Mapping, Sequence
+from inspect import signature
 from typing import Any
 
 import h5py
+import numpy as np
 from numpy.typing import ArrayLike
 
 from .. import types
@@ -34,7 +38,9 @@ class LH5Store:
     lgdo.waveformtable.WaveformTable
     """
 
-    def __init__(self, base_path: str = "", keep_open: bool = False) -> None:
+    def __init__(
+        self, base_path: str = "", keep_open: bool = False, locking: bool = False
+    ) -> None:
         """
         Parameters
         ----------
@@ -42,13 +48,23 @@ class LH5Store:
             directory path to prepend to LH5 files.
         keep_open
             whether to keep files open by storing the :mod:`h5py` objects as
-            class attributes.
+            class attributes. If ``keep_open`` is an ``int``, keep only the
+            ``n`` most recently opened files; if ``True``, no limit
+        locking
+            whether to lock files when reading
         """
         self.base_path = "" if base_path == "" else utils.expand_path(base_path)
         self.keep_open = keep_open
-        self.files = {}
+        self.locking = locking
+        self.files = OrderedDict()
 
-    def gimme_file(self, lh5_file: str | h5py.File, mode: str = "r") -> h5py.File:
+    def gimme_file(
+        self,
+        lh5_file: str | h5py.File,
+        mode: str = "r",
+        page_buffer: int = 0,
+        **file_kwargs,
+    ) -> h5py.File:
         """Returns a :mod:`h5py` file object from the store or creates a new one.
 
         Parameters
@@ -57,14 +73,23 @@ class LH5Store:
             LH5 file name.
         mode
             mode in which to open file. See :class:`h5py.File` documentation.
+        page_buffer
+            enable paged aggregation with a buffer of this size in bytes
+            Only used when creating a new file. Useful when writing a file
+            with a large number of small datasets. This is a short-hand for
+            ``(fs_stragety="page", fs_pagesize=[page_buffer])``
+        file_kwargs
+            Keyword arguments for :class:`h5py.File`
         """
         if isinstance(lh5_file, h5py.File):
             return lh5_file
 
         if mode == "r":
             lh5_file = utils.expand_path(lh5_file, base_path=self.base_path)
+            file_kwargs["locking"] = self.locking
 
         if lh5_file in self.files:
+            self.files.move_to_end(lh5_file)
             return self.files[lh5_file]
 
         if self.base_path != "":
@@ -72,22 +97,34 @@ class LH5Store:
         else:
             full_path = lh5_file
 
+        file_exists = os.path.exists(full_path)
         if mode != "r":
             directory = os.path.dirname(full_path)
             if directory != "" and not os.path.exists(directory):
                 log.debug(f"making path {directory}")
                 os.makedirs(directory)
 
-        if mode == "r" and not os.path.exists(full_path):
+        if mode == "r" and not file_exists:
             msg = f"file {full_path} not found"
             raise FileNotFoundError(msg)
+        if not file_exists:
+            mode = "w"
 
-        if mode != "r" and os.path.exists(full_path):
+        if mode != "r" and file_exists:
             log.debug(f"opening existing file {full_path} in mode '{mode}'")
 
-        h5f = h5py.File(full_path, mode)
+        if mode == "w":
+            file_kwargs.update(
+                {
+                    "fs_strategy": "page",
+                    "fs_page_size": page_buffer,
+                }
+            )
+        h5f = h5py.File(full_path, mode, **file_kwargs)
 
         if self.keep_open:
+            if isinstance(self.keep_open, int) and len(self.files) >= self.keep_open:
+                self.files.popitem(last=False)
             self.files[lh5_file] = h5f
 
         return h5f
@@ -135,6 +172,7 @@ class LH5Store:
         obj_buf: types.LGDO = None,
         obj_buf_start: int = 0,
         decompress: bool = True,
+        **file_kwargs,
     ) -> tuple[types.LGDO, int]:
         """Read LH5 object data from a file in the store.
 
@@ -143,13 +181,65 @@ class LH5Store:
         .lh5.core.read
         """
         # grab files from store
-        if not isinstance(lh5_file, (str, h5py.File)):
-            lh5_obj = [self.gimme_file(f, "r")[name] for f in list(lh5_file)]
+        if isinstance(lh5_file, (str, h5py.File)):
+            lh5_obj = self.gimme_file(lh5_file, "r", **file_kwargs)[name]
         else:
-            lh5_obj = self.gimme_file(lh5_file, "r")[name]
+            lh5_files = list(lh5_file)
+            n_rows_read = 0
+
+            for i, h5f in enumerate(lh5_files):
+                if (
+                    isinstance(idx, (list, tuple))
+                    and len(idx) > 0
+                    and not np.isscalar(idx[0])
+                ):
+                    # a list of lists: must be one per file
+                    idx_i = idx[i]
+                elif idx is not None:
+                    # make idx a proper tuple if it's not one already
+                    if not (isinstance(idx, tuple) and len(idx) == 1):
+                        idx = (idx,)
+                    # idx is a long continuous array
+                    n_rows_i = utils.read_n_rows(name, h5f)
+                    # find the length of the subset of idx that contains indices
+                    # that are less than n_rows_i
+                    n_rows_to_read_i = bisect.bisect_left(idx[0], n_rows_i)
+                    # now split idx into idx_i and the remainder
+                    idx_i = np.array(idx[0])[:n_rows_to_read_i]
+                    idx = np.array(idx[0])[n_rows_to_read_i:] - n_rows_i
+                else:
+                    idx_i = None
+                n_rows_i = n_rows - n_rows_read
+
+                obj_buf, n_rows_read_i = self.read(
+                    name,
+                    h5f,
+                    start_row,
+                    n_rows_i,
+                    idx_i,
+                    use_h5idx,
+                    field_mask,
+                    obj_buf,
+                    obj_buf_start,
+                    decompress,
+                )
+
+                n_rows_read += n_rows_read_i
+                if n_rows_read >= n_rows or obj_buf is None:
+                    return obj_buf, n_rows_read
+                start_row = 0
+                obj_buf_start += n_rows_read_i
+            return obj_buf, n_rows_read
+
+        if isinstance(idx, (list, tuple)) and len(idx) > 0 and not np.isscalar(idx[0]):
+            idx = idx[0]
+        if isinstance(idx, np.ndarray) and idx.dtype == np.dtype("?"):
+            idx = np.where(idx)[0]
 
         return _serializers._h5_read_lgdo(
-            lh5_obj,
+            lh5_obj.id,
+            lh5_obj.file.filename,
+            lh5_obj.name,
             start_row=start_row,
             n_rows=n_rows,
             idx=idx,
@@ -170,6 +260,7 @@ class LH5Store:
         n_rows: int | None = None,
         wo_mode: str = "append",
         write_start: int = 0,
+        page_buffer: int = 0,
         **h5py_kwargs,
     ) -> None:
         """Write an LGDO into an LH5 file.
@@ -199,10 +290,17 @@ class LH5Store:
         # write_object:overwrite.
         mode = "w" if wo_mode == "of" else "a"
 
+        file_kwargs = {
+            k: h5py_kwargs[k]
+            for k in h5py_kwargs & signature(h5py.File).parameters.keys()
+        }
+
         return _serializers._h5_write_lgdo(
             obj,
             name,
-            self.gimme_file(lh5_file, mode=mode),
+            self.gimme_file(
+                lh5_file, mode=mode, page_buffer=page_buffer, **file_kwargs
+            ),
             group=group,
             start_row=start_row,
             n_rows=n_rows,
@@ -217,3 +315,9 @@ class LH5Store:
         Return ``None`` if it is a :class:`.Scalar` or a :class:`.Struct`.
         """
         return utils.read_n_rows(name, self.gimme_file(lh5_file, "r"))
+
+    def read_size_in_bytes(self, name: str, lh5_file: str | h5py.File) -> int:
+        """Look up the size (in B) of the object in memory. Will recursively
+        crawl through all objects in a Struct or Table
+        """
+        return utils.read_size_in_bytes(name, self.gimme_file(lh5_file, "r"))

lgdo/lh5/tools.py

@@ -128,7 +128,7 @@ def show(
 
     # open file
     if isinstance(lh5_file, str):
-        lh5_file = h5py.File(utils.expand_path(lh5_file), "r")
+        lh5_file = h5py.File(utils.expand_path(lh5_file), "r", locking=False)
 
     # go to group
     if lh5_group != "/":

lgdo/lh5/utils.py

@@ -12,7 +12,7 @@ from typing import Any
 import h5py
 
 from .. import types
-from . import _serializers, datatype
+from . import _serializers
 from .exceptions import LH5DecodeError
 
 log = logging.getLogger(__name__)
@@ -44,57 +44,31 @@ def read_n_rows(name: str, h5f: str | h5py.File) -> int | None:
     Return ``None`` if `name` is a :class:`.Scalar` or a :class:`.Struct`.
     """
     if not isinstance(h5f, h5py.File):
-        h5f = h5py.File(h5f, "r")
+        h5f = h5py.File(h5f, "r", locking=False)
 
     try:
-        attrs = h5f[name].attrs
+        h5o = h5f[name].id
     except KeyError as e:
         msg = "not found"
         raise LH5DecodeError(msg, h5f, name) from e
-    except AttributeError as e:
-        msg = "missing 'datatype' attribute"
-        raise LH5DecodeError(msg, h5f, name) from e
 
-    lgdotype = datatype.datatype(attrs["datatype"])
-
-    # scalars are dim-0 datasets
-    if lgdotype is types.Scalar:
-        return None
-
-    # structs don't have rows
-    if lgdotype is types.Struct:
-        return None
-
-    # tables should have elements with all the same length
-    if lgdotype is types.Table:
-        # read out each of the fields
-        rows_read = None
-        for field in datatype.get_struct_fields(attrs["datatype"]):
-            n_rows_read = read_n_rows(name + "/" + field, h5f)
-            if not rows_read:
-                rows_read = n_rows_read
-            elif rows_read != n_rows_read:
-                log.warning(
-                    f"'{field}' field in table '{name}' has {rows_read} rows, "
-                    f"{n_rows_read} was expected"
-                )
-        return rows_read
+    return _serializers.read.utils.read_n_rows(h5o, h5f.name, name)
 
-    # length of vector of vectors is the length of its cumulative_length
-    if lgdotype is types.VectorOfVectors:
-        return read_n_rows(f"{name}/cumulative_length", h5f)
 
-    # length of vector of encoded vectors is the length of its decoded_size
-    if lgdotype in (types.VectorOfEncodedVectors, types.ArrayOfEncodedEqualSizedArrays):
-        return read_n_rows(f"{name}/encoded_data", h5f)
+def read_size_in_bytes(name: str, h5f: str | h5py.File) -> int | None:
+    """Look up the size (in B) in an LGDO object in memory. Will crawl
+    recursively through members of a Struct or Table
+    """
+    if not isinstance(h5f, h5py.File):
+        h5f = h5py.File(h5f, "r", locking=False)
 
-    # return array length (without reading the array!)
-    if issubclass(lgdotype, types.Array):
-        # compute the number of rows to read
-        return h5f[name].shape[0]
+    try:
+        h5o = h5f[name].id
+    except KeyError as e:
+        msg = "not found"
+        raise LH5DecodeError(msg, h5f, name) from e
 
-    msg = f"don't know how to read rows of LGDO {lgdotype.__name__}"
-    raise LH5DecodeError(msg, h5f, name)
+    return _serializers.read.utils.read_size_in_bytes(h5o, h5f.name, name)
 
 
 def get_h5_group(
@@ -125,7 +99,12 @@ def get_h5_group(
         else:
             group = base_group.create_group(group)
             if grp_attrs is not None:
-                group.attrs.update(grp_attrs)
+                group.attrs.update(
+                    {
+                        k: v.encode("utf-8") if isinstance(v, str) else v
+                        for k, v in grp_attrs.items()
+                    }
+                )
             return group
     if (
         grp_attrs is not None
@@ -141,7 +120,13 @@ def get_h5_group(
         log.debug(f"overwriting {group}.attrs...")
         for key in group.attrs:
             group.attrs.pop(key)
-        group.attrs.update(grp_attrs)
+
+        group.attrs.update(
+            {
+                k: v.encode("utf-8") if isinstance(v, str) else v
+                for k, v in grp_attrs.items()
+            }
+        )
 
     return group
 

lgdo/types/histogram.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
-from collections.abc import Iterable
+import logging
+from collections.abc import Iterable, Mapping, Sequence
 from typing import Any
 
 import hist
 import numpy as np
+import pandas as pd
 from numpy.typing import NDArray
 
 from .array import Array
@@ -12,6 +14,8 @@ from .lgdo import LGDO
 from .scalar import Scalar
 from .struct import Struct
 
+log = logging.getLogger(__name__)
+
 
 class Histogram(Struct):
     class Axis(Struct):
@@ -197,6 +201,7 @@ class Histogram(Struct):
         isdensity: bool = False,
         attrs: dict[str, Any] | None = None,
         binedge_attrs: dict[str, Any] | None = None,
+        flow: bool = True,
     ) -> None:
         """A special struct to contain histogrammed data.
 
@@ -221,6 +226,16 @@ class Histogram(Struct):
             as binning.
         attrs
             a set of user attributes to be carried along with this LGDO.
+        flow
+            If ``False``, discard counts in over-/underflow bins of the passed
+            :class:`hist.Hist` instance. If ``True``, this data will also be discarded,
+            but a warning is emitted.
+
+            .. note ::
+
+                :class:`Histogram` does not support storing counts in overflow or
+                underflow bins. This parameter just controls, whether a warning will
+                be emitted.
         """
         if isinstance(weights, hist.Hist):
             if binning is not None:
@@ -230,9 +245,10 @@ class Histogram(Struct):
                 msg = "not allowed to pass isdensity=True if constructing from hist.Hist instance"
                 raise ValueError(msg)
 
-            if weights.sum(flow=True) != weights.sum(flow=False):
-                msg = "flow bins of hist.Hist cannot be represented"
-                raise ValueError(msg)
+            if weights.sum(flow=True) != weights.sum(flow=False) and flow:
+                log.warning(
+                    "flow bins of hist.Hist cannot be represented, their counts are discarded"
+                )
             weights_view = weights.view(flow=False)
             if type(weights_view) is not np.ndarray:
                 msg = "only simple numpy-backed storages can be used in a hist.Hist"
@@ -254,10 +270,10 @@ class Histogram(Struct):
                     b.append(Histogram.Axis.from_edges(ax.edges, binedge_attrs))
         else:
             if binning is None:
-                msg = "need to also pass binning if passing histogram as array"
+                msg = "need to pass binning to construct Histogram"
                 raise ValueError(msg)
-            w = weights if isinstance(weights, Array) else Array(weights)
 
+            # set up binning
             if all(isinstance(ax, Histogram.Axis) for ax in binning):
                 if binedge_attrs is not None:
                     msg = "passed both binedges as Axis instances and binedge_attrs"
@@ -271,6 +287,14 @@ class Histogram(Struct):
                 msg = "invalid binning object passed"
                 raise ValueError(msg)
 
+            # set up bin weights
+            if isinstance(weights, Array):
+                w = weights
+            elif weights is None:
+                w = Array(shape=[ax.nbins for ax in b], fill_val=0, dtype=np.float32)
+            else:
+                w = Array(weights)
+
             if len(binning) != len(w.nda.shape):
                 msg = "binning and weight dimensions do not match"
                 raise ValueError(msg)
@@ -300,6 +324,98 @@ class Histogram(Struct):
         assert all(isinstance(v, Histogram.Axis) for k, v in bins)
         return tuple(v for _, v in bins)
 
+    def fill(self, data, w: NDArray = None, keys: Sequence[str] = None) -> None:
+        """Fill histogram by incrementing bins with data points weighted by w
+
+        Parameters
+        ----------
+        data
+            a ndarray with inner dimension equal to number of axes, or a list
+            of equal-length 1d-arrays containing data for each axis, or a
+            Mapping to 1d-arrays containing data for each axis (requires keys),
+            or a Pandas dataframe (optionally takes a list of keys)
+        w
+            weight to use for incrementing data points. If None, use 1 for all
+        keys
+            list of keys to use if data is a pandas ''DataFrame'' or ''Mapping''
+        """
+        if keys is not None:
+            if isinstance(keys, str):
+                keys = [keys]
+            elif not isinstance(keys, list):
+                keys = list(keys)
+
+        if (
+            isinstance(data, np.ndarray)
+            and len(data.shape) == 1
+            and len(self.binning) == 1
+        ):
+            N = len(data)
+            data = [data]
+        elif (
+            isinstance(data, np.ndarray)
+            and len(data.shape) == 2
+            and data.shape[1] == len(self.binning)
+        ):
+            N = data.shape[0]
+            data = data.T
+        elif isinstance(data, pd.DataFrame) and (
+            (keys is not None and len(keys) == len(self.binning))
+            or data.ndim == len(self.binning)
+        ):
+            if keys is not None:
+                data = data[keys]
+            N = len(data)
+            data = data.values.T
+        elif isinstance(data, Sequence) and len(data) == len(self.binning):
+            data = [d if isinstance(d, np.ndarray) else np.array(d) for d in data]
+            N = len(data[0])
+            if not all(len(d) == N for d in data):
+                msg = "length of all data arrays must be equal"
+                raise ValueError(msg)
+        elif isinstance(data, Mapping):
+            if not isinstance(keys, Sequence) or len(keys) != len(self.binning):
+                msg = "filling hist with Mapping data requires a list of keys with same length as histogram rank"
+                raise ValueError(msg)
+            data = [
+                data[k] if isinstance(data[k], np.ndarray) else np.array(data[k])
+                for k in keys
+            ]
+            N = len(data[0])
+            if not all(len(d) == N for d in data):
+                msg = "length of all data arrays must be equal"
+                raise ValueError(msg)
+        else:
+            msg = "data must be 2D numpy array or list of 1D arrays with length equal to number of axes"
+            raise ValueError(msg)
+
+        idx = np.zeros(N, np.float64)  # bin indices for flattened array
+        oor_mask = np.ones(N, np.bool_)  # mask to remove out of range values
+        stride = [s // self.weights.dtype.itemsize for s in self.weights.nda.strides]
+        for col, ax, s in zip(data, self.binning, stride):
+            if ax.is_range:
+                idx += s * np.floor((col - ax.first) / ax.step - int(not ax.closedleft))
+                if ax.closedleft:
+                    oor_mask &= (ax.first <= col) & (col < ax.last)
+                else:
+                    oor_mask &= (ax.first < col) & (col <= ax.last)
+            else:
+                idx += s * (
+                    np.searchsorted(
+                        ax.edges, col, side=("right" if ax.closedleft else "left")
+                    )
+                    - 1
+                )
+                if ax.closedleft:
+                    oor_mask &= (ax.edges[0] <= col) & (col < ax.edges[-1])
+                else:
+                    oor_mask &= (ax.edges[0] < col) & (col <= ax.edges[-1])
+
+        # increment bin contents
+        idx = idx[oor_mask].astype(np.int64)
+        w = w[oor_mask] if w is not None else 1
+        np.add.at(self.weights.nda.reshape(-1), idx, w)
+
     def __setitem__(self, name: str, obj: LGDO) -> None:
         # do not allow for new attributes on this
         msg = "histogram fields cannot be mutated"

lgdo/types/table.py

@@ -450,7 +450,7 @@ class Table(Struct):
             cols = self.keys()
 
         if library == "pd":
-            df = pd.DataFrame()
+            df = {}
 
             for col in cols:
                 data = self[col]
@@ -470,7 +470,7 @@ class Table(Struct):
                     )
                     df[f"{prefix}{col}"] = data.view_as("pd", with_units=with_units)
 
-            return df
+            return pd.DataFrame(df, copy=False)
 
         if library == "np":
             msg = f"Format {library!r} is not supported for Tables."

lgdo/types/vectorofvectors.py

@@ -632,7 +632,7 @@ class VectorOfVectors(LGDO):
             offsets = np.empty(
                 len(self.cumulative_length) + 1, dtype=self.cumulative_length.dtype
             )
-            offsets[1:] = self.cumulative_length
+            offsets[1:] = self.cumulative_length.nda
             offsets[0] = 0
 
             content = (

legend_pydataobj-1.9.0.dist-info/RECORD

@@ -1,55 +0,0 @@
-lgdo/__init__.py,sha256=1YUuAFQHNrOOkr3ZfrtEJOpYqgzbHRYA81ssbQZitQE,3196
-lgdo/_version.py,sha256=Wi1Vgg8ccNVK7oIZNO8kmGhwjztIUyuzlku2tkT7820,411
-lgdo/cli.py,sha256=vB1Oj6kZ5gWaY9HBPBRRRyiepp72hm3bFvQeUUWeMYg,8214
-lgdo/lgdo_utils.py,sha256=6a2YWEwpyEMXlAyTHZMO01aqxy6SxJzPZkGNWKNWuS0,2567
-lgdo/lh5_store.py,sha256=5BzbJA9sLcqjp8bJDc2olwOiw0VS6rmfg3cfh1kQkRY,8512
-lgdo/logging.py,sha256=82wIOj7l7xr3WYyeHdpSXbbjzHJsy-uRyKYUYx2vMfQ,1003
-lgdo/units.py,sha256=VQYME86_ev9S7Fq8RyCOQNqYr29MphTTYemmEouZafk,161
-lgdo/utils.py,sha256=9t_GYdB8aQhZ4Vz6ujmASzwCgTuP7ZdINtPTVPyIR6E,3661
-lgdo/compression/__init__.py,sha256=gqbdx4NnpCcW-C7kUXV-hVUZFiNlbCwIbs3uzFe4AFE,1127
-lgdo/compression/base.py,sha256=82cQJujfvoAOKBFx761dEcx_xM02TBCBBuBo6i78tuI,838
-lgdo/compression/generic.py,sha256=tF3UhLJbUDcovLxpIzgQRxFSjZ5Fz3uDRy9kI4mFntQ,2515
-lgdo/compression/radware.py,sha256=VbKAvi18h48Fz-ZxMEg64yD1ezaw1NkMZazxurdyMmc,24015
-lgdo/compression/utils.py,sha256=W2RkBrxPpXlat84dnU9Ad7d_tTws0irtGl7O1dNWjnk,1140
-lgdo/compression/varlen.py,sha256=6ZZUItyoOfygDdE0DyoISeFZfqdbH6xl7T0eclfarzg,15127
-lgdo/lh5/__init__.py,sha256=KzWF6HI-6N1NqQUm8LAxMmDbg0rgRY4DAaJ2s7w2tLM,811
-lgdo/lh5/core.py,sha256=c94Er0F28y2shYp0Ti9Nvq8Z2QB5P4QSqixjzvtdslI,11153
-lgdo/lh5/datatype.py,sha256=O_7BqOlX8PFMyG0ppkfUT5aps5HEqX0bpuKcJO3jhu0,1691
-lgdo/lh5/exceptions.py,sha256=h0NyNM5EX8lgoK-JTnPlIhr7Jk-VKJzc1kd1IYTjhXw,985
-lgdo/lh5/iterator.py,sha256=eqH9a_ZjEhgqJUZbMj36jXK_1Xbx86450DVw7LHNB3Y,12369
-lgdo/lh5/store.py,sha256=5_ytoRtM2g3jVAPN3r02x3u-I1BNGI4lXMhwD2Gi-Eg,6661
-lgdo/lh5/tools.py,sha256=nb4zaBbVbQZTEzawi_faMhRvaPQf9Iea2xbuN6MPSQg,9922
-lgdo/lh5/utils.py,sha256=w0gGaYmP4HxoM6vCcku1m8qg06tawixQj6awuRIujXM,6984
-lgdo/lh5/_serializers/__init__.py,sha256=NSH8uOVY3r_Wn3t0nQHhEHhkHT7-GJYlxuS3YTDJa5Y,1263
-lgdo/lh5/_serializers/read/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lgdo/lh5/_serializers/read/array.py,sha256=V9a1E_yvBmpxMu1pqD7V3WTk2HpBg72jwiXNUvhMBjQ,879
-lgdo/lh5/_serializers/read/composite.py,sha256=tYhi6v_zbrO-ryTShWVFpo-vrRVlgiixcIqaCAcc3RY,13439
-lgdo/lh5/_serializers/read/encoded.py,sha256=g5_C1i2zXu02JE3ZNg9meeQ80y_5J-ZZNPFsGyGZdOA,3634
-lgdo/lh5/_serializers/read/ndarray.py,sha256=2Ov7YF92wHUt-Z0s0fjPxeJ_4S8w7DH61Ee4pxVBEK8,3417
-lgdo/lh5/_serializers/read/scalar.py,sha256=BFnGzgZvE9QPOutoe7vwlHTPpfGbATlScQc5fgGvTlg,731
-lgdo/lh5/_serializers/read/utils.py,sha256=gavB1v9njr7WFJf8KDsbYlXcJmeF_dTgsLgHN5LoyCo,411
-lgdo/lh5/_serializers/read/vector_of_vectors.py,sha256=kNoRFKA1inefZEgxkz6Paou2KnA7bA-ugK6HvSJSNR0,6567
-lgdo/lh5/_serializers/write/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lgdo/lh5/_serializers/write/array.py,sha256=Gosg8rOCH_2dRMj_oNSWyXuoYXDjy0OK--GCYWswR4U,2803
-lgdo/lh5/_serializers/write/composite.py,sha256=oyJ2ix0fO52ZtiI19KRanwt-9gn0TDVsAPaRAdUFn6Y,8901
-lgdo/lh5/_serializers/write/scalar.py,sha256=gkcF2WVBR3aQYl0EynbVUocx4y3r8tvPfQYQJjkPvP4,643
-lgdo/lh5/_serializers/write/vector_of_vectors.py,sha256=puGQX9XF5P_5DVbm_Cc6TvPrsDywgBLSYtkqFNltbB4,3493
-lgdo/types/__init__.py,sha256=B7qEdlD0yJ8IUHK8xUKSyhRTY5LD1B148DPXI6iaB7w,821
-lgdo/types/array.py,sha256=sUxh1CNCaefrnybt5qdjmmMpVQa_RqFxUv1tJ_pyBbc,6537
-lgdo/types/arrayofequalsizedarrays.py,sha256=DOGJiTmc1QCdm7vLbE6uIRXoMPtt8uuCfmwQawgWf5s,4949
-lgdo/types/encoded.py,sha256=JW4U5ow7KLMzhKnmhdnxbC3SZJAs4bOEDZWKG4KY1uU,15293
-lgdo/types/fixedsizearray.py,sha256=7RjUwTz1bW0pcrdy27JlfrXPAuOU89Kj7pOuSUCojK8,1527
-lgdo/types/histogram.py,sha256=3guFbj48cd9HudWxjyXXcNfNg3vp1Quz6YSuCq8FQpc,14949
-lgdo/types/lgdo.py,sha256=UnJDi1emQYVgH_H29Vipfs4LelPopxG5pgZUu1eKOlw,2761
-lgdo/types/scalar.py,sha256=c5Es2vyDqyWTPV6mujzfIzMpC1jNWkEIcvYyWQUxH3Q,1933
-lgdo/types/struct.py,sha256=Q0OWLVd4B0ciLb8t6VsxU3MPbmGLZ7WfQNno1lSQS0Q,4918
-lgdo/types/table.py,sha256=w6ESACX6TNvEGIUQfNBtn2ofPNPM-Tl-6m6SITGVvtI,17942
-lgdo/types/vectorofvectors.py,sha256=Q53K8wiHwRHpGw3ARqrLnOXu3kLHptTYMp0ay9KK1vs,24386
-lgdo/types/vovutils.py,sha256=7BWPP0BSj-92ifbCIUBcfqxG5-TS8uxujTyJJuDFI04,10302
-lgdo/types/waveformtable.py,sha256=f2tS4f1OEoYaTM5ldCX9zmw8iSISCT3t3wS1SrPdu_o,9901
-legend_pydataobj-1.9.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-legend_pydataobj-1.9.0.dist-info/METADATA,sha256=kLFP_xph3aEB1PCK_IXc1vchcZgE6GSwPTUsDV74jxQ,44379
-legend_pydataobj-1.9.0.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-legend_pydataobj-1.9.0.dist-info/entry_points.txt,sha256=Uu5MTlppBZxB4QGlLv-oX8FqACWjAZDNii__TBDJwLQ,72
-legend_pydataobj-1.9.0.dist-info/top_level.txt,sha256=KyR-EUloqiXcQ62IWnzBmtInDtvsHl4q2ZJAZgTcLXE,5
-legend_pydataobj-1.9.0.dist-info/RECORD,,