testbed/TileDB-Inc__TileDB-Py/tiledb/tests/test_enumeration.py

import re

import numpy as np
import pytest
from numpy.testing import assert_array_equal

import tiledb

from .common import DiskTestCase, has_pandas, has_pyarrow


class EnumerationTest(DiskTestCase):
    @pytest.mark.parametrize(
        "name,data",
        (
            ("int", np.array([0])),
            ("float", np.array([1.0, 2.2, 5.8234, 94.23])),
            ("str", np.array(["abc", "defghi", "jk"])),
            ("utf8", np.array(["abc", "defghi", "jk"], dtype=np.str_)),
            ("ascii", np.array([b"abc", b"defghi", b"jk"], dtype=np.bytes_)),
        ),
    )
    @pytest.mark.parametrize("ordered", [True, False])
    def test_enumeration_basic(self, name, ordered, data):
        enmr = tiledb.Enumeration(name, ordered, data)

        assert enmr.name == name
        assert enmr.ordered == ordered
        assert_array_equal(enmr.values(), data)
        if name in ("str", "utf8", "ascii"):
            assert enmr.cell_val_num == tiledb.cc.TILEDB_VAR_NUM()
            assert enmr.dtype.kind == data.dtype.kind
        else:
            assert enmr.cell_val_num == 1
            assert enmr.dtype.kind == data.dtype.kind

    def test_attribute_enumeration(self):
        attr = tiledb.Attr()
        attr.enum = "enum"
        assert attr.enum == "enum"

    def test_enumeration_repr(self):
        """Doesn't check exact string, just makes sure each component is matched, in case order is changed in the future."""
        enmr = tiledb.Enumeration("e", False, [1, 2, 3])
        # Get its string representation
        repr_str = repr(enmr)

        # Define patterns to match each component in the representation
        patterns = {
            "Enumeration": r"Enumeration",
            "name": r"name='e'",
            # use regex because it is depending on platform
            "dtype": r"dtype=int\d+",
            "dtype_name": r"dtype_name='int\d+'",
            "cell_val_num": r"cell_val_num=1",
            "ordered": r"ordered=False",
            "values": r"values=\[1, 2, 3\]",
        }

        # Check that each pattern is found in the representation string
        for key, pattern in patterns.items():
            assert re.search(pattern, repr_str), f"{key} not found or incorrect in repr"

    def test_array_schema_enumeration(self):
        uri = self.path("test_array_schema_enumeration")
        dom = tiledb.Domain(tiledb.Dim(domain=(1, 8), tile=1))
        enum1 = tiledb.Enumeration("enmr1", False, np.arange(3) * 10)
        enum2 = tiledb.Enumeration("enmr2", False, ["a", "bb", "ccc"])
        attr1 = tiledb.Attr("attr1", dtype=np.int32, enum_label="enmr1")
        attr2 = tiledb.Attr("attr2", dtype=np.int32, enum_label="enmr2")
        attr3 = tiledb.Attr("attr3", dtype=np.int32)
        schema = tiledb.ArraySchema(
            domain=dom, attrs=(attr1, attr2, attr3), enums=(enum1, enum2)
        )
        tiledb.Array.create(uri, schema)

        data1 = np.random.randint(0, 3, 8)
        data2 = np.random.randint(0, 3, 8)
        data3 = np.random.randint(0, 3, 8)

        with tiledb.open(uri, "w") as A:
            A[:] = {"attr1": data1, "attr2": data2, "attr3": data3}

        with tiledb.open(uri, "r") as A:
            assert A.enum("enmr1") == enum1
            assert attr1.enum_label == "enmr1"
            assert A.attr("attr1").enum_label == "enmr1"

            assert A.enum("enmr2") == enum2
            assert attr2.enum_label == "enmr2"
            assert A.attr("attr2").enum_label == "enmr2"

            with self.assertRaises(tiledb.TileDBError) as excinfo:
                assert A.enum("enmr3") == []
            assert (
                "ArraySchema: Unable to check if unknown enumeration is loaded. No enumeration named 'enmr3'."
                == str(excinfo.value)
            )
            assert attr3.enum_label is None
            assert A.attr("attr3").enum_label is None

            if has_pandas():
                assert_array_equal(A.df[:]["attr1"].cat.codes, data1)
                assert_array_equal(A.df[:]["attr2"].cat.codes, data2)

                assert_array_equal(A.df[:]["attr1"], A.multi_index[:]["attr1"])
                assert_array_equal(A.df[:]["attr2"], A.multi_index[:]["attr2"])

                assert_array_equal(A.df[:]["attr1"], A[:]["attr1"])
                assert_array_equal(A.df[:]["attr2"], A[:]["attr2"])

    @pytest.mark.skipif(
        not has_pyarrow() or not has_pandas(),
        reason="pyarrow>=1.0 and/or pandas>=1.0,<3.0 not installed",
    )
    @pytest.mark.parametrize("sparse", [True, False])
    @pytest.mark.parametrize("pass_df", [True, False])
    def test_array_schema_enumeration_nullable(self, sparse, pass_df):
        import pyarrow as pa

        uri = self.path("test_array_schema_enumeration_nullable")
        enmr = tiledb.Enumeration("e", False, ["alpha", "beta", "gamma"])
        dom = tiledb.Domain(tiledb.Dim("d", domain=(1, 5), dtype="int64"))
        att = tiledb.Attr("a", dtype="int8", nullable=True, enum_label="e")
        schema = tiledb.ArraySchema(
            domain=dom, attrs=[att], enums=[enmr], sparse=sparse
        )
        tiledb.Array.create(uri, schema)

        with tiledb.open(uri, "w") as A:
            dims = pa.array([1, 2, 3, 4, 5])
            data = pa.array([1.0, 2.0, None, 0, 1.0])
            if pass_df:
                dims = dims.to_pandas()
                data = data.to_pandas()

            if sparse:
                A[dims] = data
            else:
                A[:] = data

        with tiledb.open(uri, "r") as A:
            expected_validity = [False, False, True, False, False]
            assert_array_equal(A[:]["a"].mask, expected_validity)
            assert_array_equal(A.df[:]["a"].isna(), expected_validity)
            assert_array_equal(A.query(attrs=["a"])[:]["a"].mask, expected_validity)

    @pytest.mark.parametrize(
        "dtype, values",
        [
            (np.int8, np.array([1, 2, 3], np.int8)),
            (np.uint8, np.array([1, 2, 3], np.uint8)),
            (np.int16, np.array([1, 2, 3], np.int16)),
            (np.uint16, np.array([1, 2, 3], np.uint16)),
            (np.int32, np.array([1, 2, 3], np.int32)),
            (np.uint32, np.array([1, 2, 3], np.uint32)),
            (np.int64, np.array([1, 2, 3], np.int64)),
            (np.uint64, np.array([1, 2, 3], np.uint64)),
            (np.dtype("S"), np.array(["a", "b", "c"], np.dtype("S"))),
            (np.dtype("U"), np.array(["a", "b", "c"], np.dtype("U"))),
        ],
    )
    def test_enum_dtypes(self, dtype, values):
        # create empty
        enmr = tiledb.Enumeration("e", False, dtype=dtype)
        if dtype in (np.dtype("S"), np.dtype("U")):
            assert enmr.dtype.kind == enmr.values().dtype.kind == dtype.kind
        else:
            assert enmr.dtype == enmr.values().dtype == dtype
            assert_array_equal(enmr.values(), [])

        # then extend with values
        enmr = enmr.extend(values)
        if dtype in (np.dtype("S"), np.dtype("U")):
            assert enmr.dtype.kind == enmr.values().dtype.kind == dtype.kind
        else:
            assert enmr.dtype == enmr.values().dtype == dtype
            assert_array_equal(enmr.values(), values)

        # create with values
        enmr = tiledb.Enumeration("e", False, values=values)
        if dtype in (np.dtype("S"), np.dtype("U")):
            assert enmr.dtype.kind == enmr.values().dtype.kind == dtype.kind
        else:
            assert enmr.dtype == enmr.values().dtype == dtype
            assert_array_equal(enmr.values(), values)

    @pytest.mark.skipif(not has_pandas(), reason="pandas>=1.0,<3.0 not installed")
    def test_from_pandas_dtype_mismatch(self):
        import pandas as pd

        schema = tiledb.ArraySchema(
            enums=[
                tiledb.Enumeration(name="enum1", values=["a", "b", "c"], ordered=False)
            ],
            domain=tiledb.Domain(
                tiledb.Dim(name="dim1", dtype=np.int32, domain=(0, 1))
            ),
            attrs=[tiledb.Attr(name="attr1", dtype=np.int32, enum_label="enum1")],
            sparse=True,
        )

        # Pandas category's categories matches the TileDB enumeration's values
        df1 = pd.DataFrame(data={"dim1": [0, 1], "attr1": ["b", "c"]})
        df1["attr1"] = pd.Categorical(values=df1.attr1, categories=["a", "b", "c"])

        array_path = self.path("arr1")
        tiledb.Array.create(array_path, schema)
        tiledb.from_pandas(array_path, df1, schema=schema, mode="append")

        actual_values = tiledb.open(array_path).df[:]["attr1"].values.tolist()
        assert actual_values == ["b", "c"]

        # Pandas category's categories does not match the TileDB enumeration's values
        df2 = pd.DataFrame(data={"dim1": [0, 1], "attr1": ["b", "c"]})
        df2["attr1"] = df2["attr1"].astype("category")

        array_path = self.path("arr2")
        tiledb.Array.create(array_path, schema)
        tiledb.from_pandas(array_path, df2, schema=schema, mode="append")

        actual_values = tiledb.open(array_path).df[:]["attr1"].values.tolist()
        assert actual_values == ["b", "c"]