legend-pydataobj 1.5.0a1__tar.gz → 1.5.0a3__tar.gz

{legend_pydataobj-1.5.0a1/src/legend_pydataobj.egg-info → legend_pydataobj-1.5.0a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: legend_pydataobj
-Version: 1.5.0a1
+Version: 1.5.0a3
 Summary: LEGEND Python Data Objects
 Home-page: https://github.com/legend-exp/legend-pydataobj
 Author: The LEGEND Collaboration

{legend_pydataobj-1.5.0a1 → legend_pydataobj-1.5.0a3/src/legend_pydataobj.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: legend_pydataobj
-Version: 1.5.0a1
+Version: 1.5.0a3
 Summary: LEGEND Python Data Objects
 Home-page: https://github.com/legend-exp/legend-pydataobj
 Author: The LEGEND Collaboration

{legend_pydataobj-1.5.0a1 → legend_pydataobj-1.5.0a3}/src/lgdo/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.5.0a1'
+__version__ = version = '1.5.0a3'
 __version_tuple__ = version_tuple = (1, 5, 0)

{legend_pydataobj-1.5.0a1 → legend_pydataobj-1.5.0a3}/src/lgdo/cli.py

@@ -5,7 +5,7 @@ import sys
 
 import lgdo
 import lgdo.logging
-from lgdo import show
+from lgdo.lh5 import show
 
 
 def lh5ls():
@@ -26,7 +26,6 @@ def lh5ls():
     )
     parser.add_argument(
         "--debug",
-        "-d",
         action="store_true",
         help="""Increase the program verbosity to maximum""",
     )
@@ -39,6 +38,13 @@ def lh5ls():
     parser.add_argument(
         "--attributes", "-a", action="store_true", help="""Print HDF5 attributes too"""
     )
+    parser.add_argument(
+        "--depth",
+        "-d",
+        type=int,
+        default=None,
+        help="""Maximum tree depth of groups to print""",
+    )
 
     args = parser.parse_args()
 
@@ -53,4 +59,4 @@ def lh5ls():
         print(lgdo.__version__)  # noqa: T201
         sys.exit()
 
-    show(args.lh5_file, args.lh5_group, attrs=args.attributes)
+    show(args.lh5_file, args.lh5_group, attrs=args.attributes, depth=args.depth)

{legend_pydataobj-1.5.0a1 → legend_pydataobj-1.5.0a3}/src/lgdo/lh5/store.py

@@ -12,6 +12,7 @@ import sys
 from bisect import bisect_left
 from collections import defaultdict
 from typing import Any, Union
+from warnings import warn
 
 import h5py
 import numba as nb
@@ -347,9 +348,7 @@ class LH5Store:
                     default = not field_mask[list(field_mask.keys())[0]]
                 field_mask = defaultdict(lambda: default, field_mask)
             elif isinstance(field_mask, (list, tuple)):
-                field_mask = defaultdict(
-                    lambda: False, {field: True for field in field_mask}
-                )
+                field_mask = defaultdict(bool, {field: True for field in field_mask})
             elif not isinstance(field_mask, defaultdict):
                 raise RuntimeError("bad field_mask of type", type(field_mask).__name__)
         elif field_mask is not None:
@@ -1337,6 +1336,7 @@ def show(
     attrs: bool = False,
     indent: str = "",
     header: bool = True,
+    depth: int | None = None,
 ) -> None:
     """Print a tree of LH5 file contents with LGDO datatype.
 
@@ -1352,6 +1352,8 @@ def show(
         indent the diagram with this string.
     header
         print `lh5_group` at the top of the diagram.
+    depth
+        maximum tree depth of groups to print
 
     Examples
     --------
@@ -1367,6 +1369,10 @@ def show(
     │   └── values · array_of_equalsized_arrays<1,1>{real}
     └── wf_std · array<1>{real}
     """
+    # check tree depth if we are using it
+    if depth is not None and depth <= 0:
+        return
+
     # open file
     if isinstance(lh5_file, str):
         lh5_file = h5py.File(expand_path(lh5_file), "r")
@@ -1422,6 +1428,7 @@ def show(
                 indent=indent + ("    " if killme else "│   "),
                 header=False,
                 attrs=attrs,
+                depth=depth - 1 if depth else None,
             )
 
         # break or move to next key
@@ -1461,6 +1468,14 @@ def load_nda(
         Each entry contains the data for the specified parameter concatenated
         over all files in `f_list`.
     """
+    warn(
+        "load_nda() is deprecated. "
+        "Please replace it with LH5Store.read(...).view_as('np'). "
+        "load_nda() will be removed in a future release.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
     if isinstance(f_list, str):
         f_list = [f_list]
         if idx_list is not None:
@@ -1515,6 +1530,13 @@ def load_dfs(
         all data for the associated parameters concatenated over all files in
         `f_list`.
     """
+    warn(
+        "load_dfs() is deprecated. "
+        "Please replace it with LH5Store.read(...).view_as('pd'). "
+        "load_dfs() will be removed in a future release.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
     return pd.DataFrame(
         load_nda(f_list, par_list, lh5_group=lh5_group, idx_list=idx_list)
     )

{legend_pydataobj-1.5.0a1 → legend_pydataobj-1.5.0a3}/src/lgdo/lh5_store.py

@@ -131,6 +131,37 @@ class LH5Store(lh5.LH5Store):
         )
         super().__init__(base_path, keep_open)
 
+    def read_object(
+        self,
+        name: str,
+        lh5_file: str | h5py.File | list[str | h5py.File],
+        **kwargs,
+    ) -> tuple[LGDO, int]:
+        warn(
+            "LH5Store.read_object() has been renamed to LH5Store.read(), "
+            "Please update your code."
+            "LH5Store.read_object() will be removed in a future release.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return super().read(self, name, lh5_file, **kwargs)
+
+    def write_object(
+        self,
+        obj: LGDO,
+        name: str,
+        lh5_file: str | h5py.File,
+        **kwargs,
+    ) -> tuple[LGDO, int]:
+        warn(
+            "LH5Store.write_object() has been renamed to LH5Store.write(), "
+            "Please update your code."
+            "LH5Store.write_object() will be removed in a future release.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return super().read(self, obj, name, lh5_file, **kwargs)
+
 
 def load_dfs(
     f_list: str | list[str],

{legend_pydataobj-1.5.0a1 → legend_pydataobj-1.5.0a3}/src/lgdo/types/arrayofequalsizedarrays.py

@@ -70,6 +70,8 @@ class ArrayOfEqualSizedArrays(Array):
             if nda is None:
                 s = shape
             else:
+                if not isinstance(nda, np.ndarray):
+                    nda = np.array(nda)
                 s = nda.shape
             self.dims = (1, len(s) - 1)
         else:

{legend_pydataobj-1.5.0a1 → legend_pydataobj-1.5.0a3}/src/lgdo/types/struct.py

@@ -60,7 +60,13 @@ class Struct(LGDO, dict):
         return self.add_field(name, obj)
 
     def __getattr__(self, name: str) -> LGDO:
-        return self.__getitem__(name)
+        if hasattr(super(), name):
+            return super().__getattr__(name)
+
+        if name in self.keys():
+            return super().__getitem__(name)
+
+        raise AttributeError(name)
 
     def remove_field(self, name: str | int, delete: bool = False) -> None:
         """Remove a field from the table.

{legend_pydataobj-1.5.0a1 → legend_pydataobj-1.5.0a3}/src/lgdo/types/table.py

@@ -5,8 +5,7 @@ equal length and corresponding utilities.
 from __future__ import annotations
 
 import logging
-import re
-from typing import Any
+from typing import Any, Mapping
 from warnings import warn
 
 import awkward as ak
@@ -18,6 +17,7 @@ from pandas.io.formats import format as fmt
 from .array import Array
 from .arrayofequalsizedarrays import ArrayOfEqualSizedArrays
 from .lgdo import LGDO
+from .scalar import Scalar
 from .struct import Struct
 from .vectorofvectors import VectorOfVectors
 
@@ -38,8 +38,6 @@ class Table(Struct):
     :meth:`__len__` to access valid data, which returns the ``size`` attribute.
     """
 
-    # TODO: overload getattr to allow access to fields as object attributes?
-
     def __init__(
         self,
         size: int = None,
@@ -217,102 +215,114 @@ class Table(Struct):
         )
         return self.view_as(library="pd", cols=cols, prefix=prefix)
 
-    def eval(self, expr_config: dict) -> Table:
-        """Apply column operations to the table and return a new table holding
-        the resulting columns.
+    def eval(
+        self,
+        expr: str,
+        parameters: Mapping[str, str] = None,
+    ) -> LGDO:
+        """Apply column operations to the table and return a new LGDO.
 
-        Currently defers all the job to :meth:`numexpr.evaluate`. This
-        might change in the future.
+        Internally uses :func:`numexpr.evaluate` if dealing with columns
+        representable as NumPy arrays or :func:`eval` if
+        :class:`.VectorOfVectors` are involved. In the latter case, the VoV
+        columns are viewed as :class:`ak.Array` and the respective routines are
+        therefore available.
 
         Parameters
         ----------
-        expr_config
-            dictionary that configures expressions according the following
-            specification:
-
-            .. code-block:: js
-
-                {
-                    "O1": {
-                        "expression": "p1 + p2 * a**2",
-                        "parameters": {
-                            "p1": 2,
-                            "p2": 3
-                        }
-                    },
-                    "O2": {
-                        "expression": "O1 - b"
-                    }
-                    // ...
-                }
-
-            where:
-
-            - ``expression`` is an expression string supported by
-              :meth:`numexpr.evaluate` (see also `here
-              <https://numexpr.readthedocs.io/projects/NumExpr3/en/latest/index.html>`_
-              for documentation). Note: because of internal limitations,
-              reduction operations must appear the last in the stack.
-            - ``parameters`` is a dictionary of function parameters. Passed to
-              :meth:`numexpr.evaluate`` as `local_dict` argument.
-
-
-        Warning
-        -------
-        Blocks in `expr_config` must be ordered according to mutual dependency.
+        expr
+            if the expression only involves non-:class:`.VectorOfVectors`
+            columns, the syntax is the one supported by
+            :func:`numexpr.evaluate` (see `here
+            <https://numexpr.readthedocs.io/projects/NumExpr3/en/latest/index.html>`_
+            for documentation). Note: because of internal limitations,
+            reduction operations must appear the last in the stack. If at least
+            one considered column is a :class:`.VectorOfVectors`, plain
+            :func:`eval` is used and :class:`ak.Array` transforms can be used
+            through the ``ak.`` prefix. (NumPy functions are analogously
+            accessible through ``np.``). See also examples below.
+        parameters
+            a dictionary of function parameters. Passed to
+            :func:`numexpr.evaluate`` as `local_dict` argument or to
+            :func:`eval` as `locals` argument.
+
+        Examples
+        --------
+        >>> import lgdo
+        >>> tbl = lgdo.Table(
+        ...   col_dict={
+        ...     "a": lgdo.Array([1, 2, 3]),
+        ...     "b": lgdo.VectorOfVectors([[5], [6, 7], [8, 9, 0]]),
+        ...   }
+        ... )
+        >>> print(tbl.eval("a + b"))
+        [[6],
+         [8 9],
+         [11 12  3],
+        ]
+        >>> print(tbl.eval("np.sum(a) + ak.sum(b)"))
+        41
         """
-        out_tbl = Table(size=self.size)
-        for out_var, spec in expr_config.items():
-            in_vars = {}
-            # Find all valid python variables in expression (e.g "a*b+sin(Cool)" --> ['a','b','sin','Cool'])
-            for elem in re.findall(r"\s*[A-Za-z_]\w*\s*", spec["expression"]):
-                elem = elem.strip()
-                if elem in self:  # check if the variable comes from dsp
-                    in_vars[elem] = self[elem]
-                elif (
-                    elem in out_tbl.keys()
-                ):  # if not try from previously processed data, else ignore since it is e.g sin func
-                    in_vars[elem] = out_tbl[elem]
-
+        if parameters is None:
+            parameters = {}
+
+        # get the valid python variable names in the expression
+        c = compile(expr, "0vbb is real!", "eval")
+
+        # make a dictionary of low-level objects (numpy or awkward)
+        # for later computation
+        self_unwrap = {}
+        has_ak = False
+        for obj in c.co_names:
+            if obj in self.keys():
+                if isinstance(self[obj], VectorOfVectors):
+                    self_unwrap[obj] = self[obj].view_as("ak", with_units=False)
+                    has_ak = True
                 else:
-                    continue
-                # get the nda if it is an Array instance
-                if isinstance(in_vars[elem], Array):
-                    in_vars[elem] = in_vars[elem].nda
-                # No vector of vectors support yet
-                elif isinstance(in_vars[elem], VectorOfVectors):
-                    raise TypeError("Data of type VectorOfVectors not supported (yet)")
+                    self_unwrap[obj] = self[obj].view_as("np", with_units=False)
 
+        # use numexpr if we are only dealing with numpy data types
+        if not has_ak:
             out_data = ne.evaluate(
-                f"{spec['expression']}",
-                local_dict=dict(in_vars, **spec["parameters"])
-                if "parameters" in spec
-                else in_vars,
-            )  # Division is chosen by __future__.division in the interpreter
-
-            # smart way to find right LGDO data type:
-
-            # out_data has one row and this row has a scalar (eg scalar product of two rows)
-            if len(np.shape(out_data)) == 0:
-                out_data = Array(nda=out_data)
-
-            # out_data has scalar in each row
-            elif len(np.shape(out_data)) == 1:
-                out_data = Array(nda=out_data)
-
-            # out_data is  like
-            elif len(np.shape(out_data)) == 2:
-                out_data = ArrayOfEqualSizedArrays(nda=out_data)
-
-            # higher order data (eg matrix product of ArrayOfEqualSizedArrays) not supported yet
+                expr,
+                local_dict=(self_unwrap | parameters),
+            )
+
+            # need to convert back to LGDO
+            # np.evaluate should always return a numpy thing?
+            if out_data.ndim == 0:
+                return Scalar(out_data.item())
+            elif out_data.ndim == 1:
+                return Array(out_data)
+            elif out_data.ndim == 2:
+                return ArrayOfEqualSizedArrays(nda=out_data)
             else:
-                ValueError(
-                    f"Calculation resulted in {len(np.shape(out_data))-1}-D row which is not supported yet"
+                msg = (
+                    f"evaluation resulted in {out_data.ndim}-dimensional data, "
+                    "I don't know which LGDO this corresponds to"
                 )
+                raise RuntimeError(msg)
 
-            out_tbl.add_column(out_var, out_data)
+        else:
+            # resort to good ol' eval()
+            globs = {"ak": ak, "np": np}
+            out_data = eval(expr, globs, (self_unwrap | parameters))
+
+            # need to convert back to LGDO
+            if isinstance(out_data, ak.Array):
+                if out_data.ndim == 1:
+                    return Array(out_data.to_numpy())
+                else:
+                    return VectorOfVectors(out_data)
 
-        return out_tbl
+            if np.isscalar(out_data):
+                return Scalar(out_data)
+            else:
+                msg = (
+                    f"evaluation resulted in a {type(out_data)} object, "
+                    "I don't know which LGDO this corresponds to"
+                )
+                raise RuntimeError(msg)
 
     def __str__(self):
         opts = fmt.get_dataframe_repr_params()

{legend_pydataobj-1.5.0a1 → legend_pydataobj-1.5.0a3}/src/lgdo/types/vectorofvectors.py

@@ -35,7 +35,7 @@ class VectorOfVectors(LGDO):
 
     def __init__(
         self,
-        listoflists: list[list[int | float]] = None,
+        array: ak.Array | list[list[int | float]] = None,
         flattened_data: Array | NDArray = None,
         cumulative_length: Array | NDArray = None,
         shape_guess: tuple[int, int] = None,
@@ -46,9 +46,10 @@ class VectorOfVectors(LGDO):
         """
         Parameters
         ----------
-        listoflists
-            create a VectorOfVectors out of a Python list of lists. Takes
-            priority over `flattened_data` and `cumulative_length`.
+        array
+            create a ``VectorOfVectors`` out of a Python list of lists or an
+            :class:`ak.Array`. Takes priority over `flattened_data` and
+            `cumulative_length`.
         flattened_data
             if not ``None``, used as the internal array for
             `self.flattened_data`.  Otherwise, an internal `flattened_data` is
@@ -67,30 +68,43 @@ class VectorOfVectors(LGDO):
             of `flattened_data` if it was not supplied.
         dtype
             sets the type of data stored in `flattened_data`. Required if
-            `flattened_data` and `listoflists` are ``None``.
+            `flattened_data` and `array` are ``None``.
         fill_val
             fill all of `self.flattened_data` with this value.
         attrs
             a set of user attributes to be carried along with this LGDO.
         """
-        if listoflists is not None:
-            cl_nda = np.cumsum([len(ll) for ll in listoflists])
-            if dtype is None:
-                if len(cl_nda) == 0 or cl_nda[-1] == 0:
-                    raise ValueError("listoflists can't be empty with dtype=None!")
-                else:
-                    # Set dtype from the first element in the list
-                    # Find it efficiently, allowing for zero-length lists as some of the entries
-                    first_element = next(itertools.chain.from_iterable(listoflists))
-                    dtype = type(first_element)
+        if array is not None:
+            if isinstance(array, ak.Array):
+                if array.ndim != 2:
+                    raise ValueError(
+                        "cannot initialize a VectorOfVectors with "
+                        f"{array.ndim}-dimensional data"
+                    )
 
-            self.dtype = np.dtype(dtype)
-            self.cumulative_length = Array(cl_nda)
-            self.flattened_data = Array(
-                np.fromiter(
-                    itertools.chain.from_iterable(listoflists), dtype=self.dtype
+                form, length, container = ak.to_buffers(array)
+
+                return self.__init__(
+                    flattened_data=container["node1-data"],
+                    cumulative_length=container["node0-offsets"][1:],
+                )
+
+            else:
+                cl_nda = np.cumsum([len(ll) for ll in array])
+                if dtype is None:
+                    if len(cl_nda) == 0 or cl_nda[-1] == 0:
+                        raise ValueError("array can't be empty with dtype=None!")
+                    else:
+                        # Set dtype from the first element in the list
+                        # Find it efficiently, allowing for zero-length lists as some of the entries
+                        first_element = next(itertools.chain.from_iterable(array))
+                        dtype = type(first_element)
+
+                self.dtype = np.dtype(dtype)
+                self.cumulative_length = Array(cl_nda)
+                self.flattened_data = Array(
+                    np.fromiter(itertools.chain.from_iterable(array), dtype=self.dtype)
                 )
-            )
 
         else:
             if cumulative_length is None:

{legend_pydataobj-1.5.0a1 → legend_pydataobj-1.5.0a3}/tests/lh5/test_lh5_store.py

@@ -3,7 +3,6 @@ import os
 
 import h5py
 import numpy as np
-import pandas as pd
 import pytest
 
 import lgdo
@@ -69,21 +68,6 @@ def test_show(lgnd_file):
     lh5.show(lgnd_file, "geds/raw")
 
 
-def test_load_nda(lgnd_file):
-    nda = lh5.load_nda(
-        [lgnd_file, lgnd_file],
-        ["baseline", "waveform/values"],
-        lh5_group="/geds/raw",
-        idx_list=[[1, 3, 5], [2, 6, 7]],
-    )
-
-    assert isinstance(nda, dict)
-    assert isinstance(nda["baseline"], np.ndarray)
-    assert nda["baseline"].shape == (6,)
-    assert isinstance(nda["waveform/values"], np.ndarray)
-    assert nda["waveform/values"].shape == (6, 5592)
-
-
 @pytest.fixture(scope="module")
 def lh5_file(tmptestdir):
     store = lh5.LH5Store()
@@ -780,8 +764,8 @@ def test_write_object_overwrite_lgdo(caplog, tmptestdir):
     assert scalar_dat.value == 1
 
     # Finally, try overwriting a vector of vectors
-    vov1 = types.VectorOfVectors(listoflists=[np.zeros(1), np.ones(2), np.zeros(3)])
-    vov2 = types.VectorOfVectors(listoflists=[np.ones(1), np.zeros(2), np.ones(3)])
+    vov1 = types.VectorOfVectors([np.zeros(1), np.ones(2), np.zeros(3)])
+    vov2 = types.VectorOfVectors([np.ones(1), np.zeros(2), np.ones(3)])
     store = lh5.LH5Store()
     store.write(vov1, "my_vector", f"{tmptestdir}/write_object_overwrite_test.lh5")
     store.write(
@@ -906,14 +890,3 @@ def test_write_object_append_column(tmptestdir):
     assert isinstance(tb_dat, types.Table)
     assert np.array_equal(tb_dat["dset1"].nda, np.zeros(10))
     assert np.array_equal(tb_dat["dset2"].nda, np.ones(10))
-
-
-def test_load_dfs(lgnd_file):
-    dfs = lh5.load_dfs(
-        [lgnd_file, lgnd_file],
-        ["baseline", "waveform/t0"],
-        lh5_group="/geds/raw",
-        idx_list=[[1, 3, 5], [2, 6, 7]],
-    )
-
-    assert isinstance(dfs, pd.DataFrame)

legend_pydataobj-1.5.0a3/tests/types/test_table_eval.py

@@ -0,0 +1,62 @@
+import numpy as np
+
+import lgdo
+
+
+def test_eval_dependency():
+    obj = lgdo.Table(
+        col_dict={
+            "a": lgdo.Array([1, 2, 3, 4], attrs={"units": "s"}),
+            "b": lgdo.Array([5, 6, 7, 8]),
+            "c": lgdo.ArrayOfEqualSizedArrays(
+                nda=[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
+            ),
+            "d": lgdo.ArrayOfEqualSizedArrays(
+                nda=[
+                    [21, 22, 23, 24],
+                    [25, 26, 27, 8],
+                    [29, 210, 211, 212],
+                    [213, 214, 215, 216],
+                ],
+            ),
+            "e": lgdo.VectorOfVectors([[1, 2, 3], [4], [], [8, 6]]),
+        }
+    )
+    r = obj.eval("sum(a)")
+    assert isinstance(r, lgdo.Scalar)
+
+    r = obj.eval("a + b")
+    assert isinstance(r, lgdo.Array)
+    assert np.array_equal(r.nda, obj.a.nda + obj.b.nda)
+
+    r = obj.eval("((a - b) > 1) & ((b - a) < -1)")
+    assert isinstance(r, lgdo.Array)
+    assert r.dtype == "bool"
+
+    r = obj.eval("a + d")
+    assert isinstance(r, lgdo.ArrayOfEqualSizedArrays)
+
+    assert obj.eval("a**2")
+    assert obj.eval("sin(a)")
+    assert obj.eval("log(d)")
+
+    r = obj.eval("a + e")
+    assert isinstance(r, lgdo.VectorOfVectors)
+    assert r == lgdo.VectorOfVectors([[2, 3, 4], [6], [], [12, 10]])
+
+    r = obj.eval("2*e + 1")
+    assert isinstance(r, lgdo.VectorOfVectors)
+    assert r == lgdo.VectorOfVectors([[3, 5, 7], [9], [], [17, 13]])
+
+    r = obj.eval("e > 2")
+    assert isinstance(r, lgdo.VectorOfVectors)
+    assert r == lgdo.VectorOfVectors([[False, False, True], [True], [], [True, True]])
+    assert r.dtype == "bool"
+
+    r = obj.eval("ak.sum(e, axis=-1)")
+    assert isinstance(r, lgdo.Array)
+
+    r = obj.eval("ak.sum(e)")
+    assert isinstance(r, lgdo.Scalar)
+
+    assert obj.eval("np.sum(a) + ak.sum(e)")

{legend_pydataobj-1.5.0a1 → legend_pydataobj-1.5.0a3}/tests/types/test_vectorofvectors.py

@@ -48,6 +48,9 @@ def test_init(lgdo_vov):
     v = VectorOfVectors(shape_guess=(5, 0), dtype="int32")
     assert v.cumulative_length == lgdo.Array([0, 0, 0, 0, 0])
 
+    v = VectorOfVectors(ak.Array([[1, 2], [3, 4, 5], [2], [4, 8, 9, 7], [5, 3, 1]]))
+    assert v == test
+
 
 def test_datatype_name(lgdo_vov):
     assert lgdo_vov.datatype_name() == "array"

legend_pydataobj-1.5.0a1/tests/types/test_table_eval.py

@@ -1,96 +0,0 @@
-import numpy as np
-
-from lgdo import Array, ArrayOfEqualSizedArrays, Table
-
-
-def test_eval_dependency():
-    obj = Table(
-        col_dict={
-            "a": Array(nda=np.array([1, 2, 3, 4], dtype=np.float32)),
-            "b": Array(nda=np.array([5, 6, 7, 8], dtype=np.float32)),
-            "c": ArrayOfEqualSizedArrays(
-                nda=np.array(
-                    [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]],
-                    dtype=np.float32,
-                )
-            ),
-            "d": ArrayOfEqualSizedArrays(
-                nda=np.array(
-                    [
-                        [21, 22, 23, 24],
-                        [25, 26, 27, 8],
-                        [29, 210, 211, 212],
-                        [213, 214, 215, 216],
-                    ],
-                    dtype=np.float32,
-                )
-            ),
-        }
-    )
-
-    expr_config = {
-        "O1": {"expression": "p1 + p2 * a**2", "parameters": {"p1": 2, "p2": 3}},
-        "O2": {"expression": "O1 - b"},
-        "O3": {"expression": "p1 + p2 * c", "parameters": {"p1": 2, "p2": 3}},
-        "O4": {"expression": "O3 - d", "parameters": {"p1": 2, "p2": 3}},
-        "O5": {"expression": "sum(c,axis=1)"},
-        "O6": {"expression": "a>p1", "parameters": {"p1": 2}},
-        "O7": {"expression": "c>p1", "parameters": {"p1": 2}},
-    }
-
-    out_tbl = obj.eval(expr_config)
-    assert list(out_tbl.keys()) == ["O1", "O2", "O3", "O4", "O5", "O6", "O7"]
-    assert (out_tbl["O1"].nda == [5, 14, 29, 50]).all()
-    assert (out_tbl["O2"].nda == [0, 8, 22, 42]).all()
-    assert (
-        out_tbl["O3"].nda
-        == [[5, 8, 11, 14], [17, 20, 23, 26], [29, 32, 35, 38], [41, 44, 47, 50]]
-    ).all()
-    assert (
-        out_tbl["O4"].nda
-        == [
-            [-16.0, -14.0, -12.0, -10.0],
-            [-8.0, -6.0, -4.0, 18.0],
-            [0.0, -178.0, -176.0, -174.0],
-            [-172.0, -170.0, -168.0, -166.0],
-        ]
-    ).all()
-    assert (out_tbl["O5"].nda == [10.0, 26.0, 42.0, 58.0]).all()
-    assert (out_tbl["O6"].nda == [False, False, True, True]).all()
-    assert (
-        out_tbl["O7"].nda
-        == [
-            [False, False, True, True],
-            [True, True, True, True],
-            [True, True, True, True],
-            [True, True, True, True],
-        ]
-    ).all()
-
-
-def test_eval_math_functions():
-    obj = Table(
-        col_dict={
-            "a": Array(nda=np.array([1, 2, 3, 4], dtype=np.float32)),
-            "b": Array(nda=np.array([5, 6, 7, 8], dtype=np.float32)),
-            "c": ArrayOfEqualSizedArrays(
-                nda=np.array(
-                    [[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]],
-                    dtype=np.float32,
-                )
-            ),
-        }
-    )
-
-    expr_config = {
-        "O1": {"expression": "exp(log(a))"},
-        "O2": {"expression": "exp(log(c))"},
-    }
-
-    out_tbl = obj.eval(expr_config)
-    assert list(out_tbl.keys()) == ["O1", "O2"]
-    assert (out_tbl["O1"].nda == [1, 2, 3, 4]).all()
-    assert (
-        out_tbl["O2"].nda
-        == np.array([[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]])
-    ).all()