Add exception when trying to write an index or a column with a boolean name (#2667)

#### Reference Issues/PRs
Monday ref: 9911125848

#### What does this implement or fix?

#### Any other comments?

#### Checklist

<details>
  <summary>
   Checklist for code changes...
  </summary>
 
- [ ] Have you updated the relevant docstrings, documentation and
copyright notice?
- [ ] Is this contribution tested against [all ArcticDB's
features](../docs/mkdocs/docs/technical/contributing.md)?
- [ ] Do all exceptions introduced raise appropriate [error
messages](https://docs.arcticdb.io/error_messages/)?
 - [ ] Are API changes highlighted in the PR description?
- [ ] Is the PR labelled as enhancement or bug so it appears in
autogenerated release notes?
</details>

<!--
Thanks for contributing a Pull Request to ArcticDB! Please ensure you
have taken a look at:
- ArcticDB's Code of Conduct:
https://github.com/man-group/ArcticDB/blob/master/CODE_OF_CONDUCT.md
- ArcticDB's Contribution Licensing:
https://github.com/man-group/ArcticDB/blob/master/docs/mkdocs/docs/technical/contributing.md#contribution-licensing
-->

Author: G-D-Petrov

python/arcticdb/version_store/_normalization.py

@@ -361,10 +361,7 @@ def _normalize_single_index(
         return [], []
     elif isinstance(index, RangeIndex):
         if index.name:
-            if not isinstance(index.name, int) and not isinstance(index.name, str):
-                raise NormalizationException(
-                    f"Index name must be a string or an int, received {index.name} of type {type(index.name)}"
-                )
+            _check_valid_name(index.name)
             if isinstance(index.name, int):
                 index_norm.is_int = True
             index_norm.name = str(index.name)
@@ -400,10 +397,7 @@ def _normalize_single_index(
         if index_tz is not None:
             index_norm.tz = _ensure_str_timezone(index_tz)
 
-        if not isinstance(index_names[0], int) and not isinstance(index_names[0], str):
-            raise NormalizationException(
-                f"Index name must be a string or an int, received {index_names[0]} of type {type(index_names[0])}"
-            )
+        _check_valid_name(index_names[0])
         # Currently, we only support a single index column
         # when we support multi-index, we will need to implement a similar logic to the one in _normalize_columns_names
         # in the mean time, we will cast all other index names to string, so we don't crash in the cpp layer
@@ -498,6 +492,14 @@ def _denormalize_columns(item, norm_meta, idx_type, n_indexes):
     return columns, denormed_columns, data
 
 
+def _check_valid_name(name):
+    # bools are a subclass of int, so we need to check for them explicitly
+    if isinstance(name, bool) or not isinstance(name, (str, int)):
+        raise NormalizationException(
+            f"Column and index names must be of type str or int, received {name} of type {type(name)}"
+        )
+
+
 def _normalize_columns_names(columns_names, index_names, norm_meta, dynamic_schema=False):
     counter = Counter(columns_names)
     for idx in range(len(columns_names)):
@@ -510,10 +512,7 @@ def _normalize_columns_names(columns_names, index_names, norm_meta, dynamic_sche
             columns_names[idx] = new_name
             continue
 
-        if not isinstance(col, str) and not isinstance(col, int):
-            raise NormalizationException(
-                f"Column names must be of type str or int, received {col} of type {type(col)} on column number {idx}"
-            )
+        _check_valid_name(col)
 
         col_str = str(col)
         columns_names[idx] = col_str

python/tests/hypothesis/arcticdb/test_append.py

@@ -3,10 +3,7 @@
 import numpy as np
 import pytest
 from arcticdb.version_store import NativeVersionStore
-from arcticdb_ext.exceptions import (
-    InternalException,
-    NormalizationException,
-)
+from arcticdb_ext.exceptions import InternalException, NormalizationException, ArcticException as ArcticNativeException
 from arcticdb_ext.version_store import StreamDescriptorMismatch
 from arcticdb_ext import set_config_int
 from hypothesis import given, assume, settings, strategies as st
@@ -287,3 +284,21 @@ def test_regular_append_dynamic_schema_named_index(
         lib.append(sym, df_1)
 
     assert "date" in str(exception_info.value)
+
+
+@pytest.mark.parametrize(
+    "idx", [pd.date_range(pd.Timestamp("2020-01-01"), periods=3), pd.RangeIndex(start=0, stop=3, step=1)]
+)
+def test_append_bool_named_col(lmdb_version_store_dynamic_schema, idx):
+    symbol = "bad_append"
+
+    initial = pd.DataFrame({"col": [1, 2, 3]}, index=idx)
+    lmdb_version_store_dynamic_schema.write(symbol, initial)
+
+    bad_df = pd.DataFrame({True: [4, 5, 6]}, index=idx)
+
+    # The normalization exception is getting reraised as an ArcticNativeException so we check for that
+    with pytest.raises(ArcticNativeException):
+        lmdb_version_store_dynamic_schema.append(symbol, bad_df)
+
+    assert_frame_equal(lmdb_version_store_dynamic_schema.read(symbol).data, initial)

python/tests/integration/arcticdb/test_update.py

@@ -18,6 +18,8 @@
 import numpy as np
 import string
 
+from arcticdb_ext.exceptions import ArcticException as ArcticNativeException
+
 from arcticdb.options import LibraryOptions
 from arcticdb.util._versions import IS_PANDAS_ONE
 from arcticdb.util.arctic_simulator import ArcticSymbolSimulator
@@ -555,3 +557,21 @@ def test_update_batch_different_updates_dynamic_schema(custom_library):
         ArcticSymbolSimulator.assert_frame_equal_rebuild_index_first(
             expected_results[result.symbol], read_data[result.symbol].data
         )
+
+
+@pytest.mark.parametrize(
+    "idx", [pd.date_range(pd.Timestamp("2020-01-01"), periods=3), pd.RangeIndex(start=0, stop=3, step=1)]
+)
+def test_update_bool_named_col(lmdb_version_store_dynamic_schema, idx):
+    symbol = "bad_append"
+
+    initial = pd.DataFrame({"col": [1, 2, 3]}, index=idx)
+    lmdb_version_store_dynamic_schema.write(symbol, initial)
+
+    bad_df = pd.DataFrame({True: [4, 5, 6]}, index=idx)
+
+    # The normalization exception is getting reraised as an ArcticNativeException so we check for that
+    with pytest.raises(ArcticNativeException):
+        lmdb_version_store_dynamic_schema.update(symbol, bad_df)
+
+    assert_frame_equal(lmdb_version_store_dynamic_schema.read(symbol).data, initial)

python/tests/unit/arcticdb/version_store/test_recursive_normalizers.py

@@ -15,7 +15,11 @@
 from arcticdb.exceptions import ArcticDbNotYetImplemented
 from arcticdb.util.venv import CompatLibrary
 from arcticdb.util.test import assert_frame_equal
-from arcticdb.exceptions import DataTooNestedException, UnsupportedKeyInDictionary
+from arcticdb.exceptions import (
+    DataTooNestedException,
+    UnsupportedKeyInDictionary,
+    ArcticException as ArcticNativeException,
+)
 from arcticdb_ext.storage import KeyType
 from arcticdb_ext.version_store import NoSuchVersionException
 import arcticdb_ext.stream as adb_stream
@@ -909,3 +913,52 @@ def test_write_new_read_old(self, old_venv_and_arctic_uri, lib_name):
                 ],
                 dfs=dfs,
             )
+
+
+def test_write_recursive_norm_bool_named_key(lmdb_version_store):
+    symbol = "bad_write"
+    ts = pd.Timestamp("2020-01-01")
+
+    df = pd.DataFrame({"col": [1, 2, 3]}, index=pd.date_range(ts, periods=3))
+
+    data = {True: df, "l": [1, 2, 3], "m": {"n": "o", "p": df}, "p": df}
+
+    lmdb_version_store.write(symbol, data, recursive_normalizers=True)
+
+    res = lmdb_version_store.read(symbol).data
+    assert_frame_equal(res["True"], df)
+
+
+def test_write_recursive_norm_bool_named_columns(lmdb_version_store):
+    symbol = "bad_write"
+    ts = pd.Timestamp("2020-01-01")
+
+    df = pd.DataFrame({True: [1, 2, 3]}, index=pd.date_range(ts, periods=3))
+
+    data = {"c": df, "l": [1, 2, 3], "m": {"n": "o", "p": df}, "p": df}
+
+    # The normalization exception is getting reraised as an ArcticNativeException so we check for that
+    with pytest.raises(ArcticNativeException):
+        lmdb_version_store.write(symbol, data, recursive_normalizers=True)
+
+    assert lmdb_version_store.list_symbols() == []
+    assert lmdb_version_store.has_symbol(symbol) is False
+
+
+@pytest.mark.parametrize(
+    "idx", [pd.date_range(pd.Timestamp("2020-01-01"), periods=3), pd.RangeIndex(start=0, stop=3, step=1)]
+)
+def test_write_recursive_norm_bool_named_index(lmdb_version_store, idx):
+    symbol = "bad_write"
+
+    df = pd.DataFrame({"col": [1, 2, 3]}, index=idx)
+    df.index.name = True
+
+    data = {"col": df, "l": [1, 2, 3], "m": {"n": "o", "p": df}, "p": df}
+
+    # The normalization exception is getting reraised as an ArcticNativeException so we check for that
+    with pytest.raises(ArcticNativeException):
+        lmdb_version_store.write(symbol, data, recursive_normalizers=True)
+
+    assert lmdb_version_store.list_symbols() == []
+    assert lmdb_version_store.has_symbol(symbol) is False

python/tests/unit/arcticdb/version_store/test_write.py

@@ -9,7 +9,7 @@
 import numpy as np
 import pandas as pd
 import pytest
-from arcticdb.exceptions import SortingException
+from arcticdb_ext.exceptions import SortingException, ArcticException as ArcticNativeException
 from arcticdb.util._versions import IS_PANDAS_TWO
 from arcticdb.util.test import assert_frame_equal
 from pandas import MultiIndex
@@ -160,3 +160,52 @@ def test_write_only_nan_column(self, lmdb_version_store, dtype):
         lib.write(sym, pd.DataFrame({"a": [np.nan]}, dtype=dtype))
         data = lib.read(sym).data
         assert_frame_equal(data, pd.DataFrame({"a": [np.nan]}, dtype=dtype))
+
+
+def test_write_bool_named_columns(lmdb_version_store):
+    symbol = "bad_write"
+    ts = pd.Timestamp("2020-01-01")
+
+    df = pd.DataFrame({True: [1, 2, 3]}, index=pd.date_range(ts, periods=3))
+
+    # The normalization exception is getting reraised as an ArcticNativeException so we check for that
+    with pytest.raises(ArcticNativeException):
+        lmdb_version_store.write(symbol, df)
+
+    assert lmdb_version_store.list_symbols() == []
+    assert lmdb_version_store.has_symbol(symbol) is False
+
+
+@pytest.mark.parametrize(
+    "idx", [pd.date_range(pd.Timestamp("2020-01-01"), periods=3), pd.RangeIndex(start=0, stop=3, step=1)]
+)
+def test_write_bool_named_index(lmdb_version_store, idx):
+    symbol = "bad_write"
+
+    df = pd.DataFrame({"col": [1, 2, 3]}, index=idx)
+    df.index.name = True
+
+    # The normalization exception is getting reraised as an ArcticNativeException so we check for that
+    with pytest.raises(ArcticNativeException):
+        lmdb_version_store.write(symbol, df)
+
+    assert lmdb_version_store.list_symbols() == []
+    assert lmdb_version_store.has_symbol(symbol) is False
+
+
+@pytest.mark.parametrize(
+    "idx", [pd.date_range(pd.Timestamp("2020-01-01"), periods=3), pd.RangeIndex(start=0, stop=3, step=1)]
+)
+@pytest.mark.parametrize("idx_names", [["index", True], [True, "index"]])
+def test_write_bool_named_multi_index(lmdb_version_store, idx, idx_names):
+    symbol = "bad_write"
+
+    df = pd.DataFrame({"col": [1, 2, 3]}, index=pd.MultiIndex.from_arrays([idx, idx], names=idx_names))
+
+    lmdb_version_store.write(symbol, df)
+
+    # We do allow for the boolean index names in multiindex and they get normalized to strings
+    # so this just tests the current behaviour and that we can read back the data correctly
+    df.index.names = [str(n) for n in idx_names]
+
+    assert_frame_equal(lmdb_version_store.read(symbol).data, df)