Key access for Named Attributes on a BlenderObject (#49)

* add string key access for attributes

* refactor and remove ColumnAccessor

* better setting of new attribute using key

* delete comments

Author: BradyAJohnston

databpy/array.py

@@ -3,71 +3,6 @@
 import bpy
 
 
-class ColumnAccessor:
-    """
-    Helper class to handle column operations on AttributeArray.
-
-    This provides a clean way to handle operations like pos[:, 2] += 1.0
-    without the complexity of numpy array views.
-    """
-
-    def __init__(self, parent, column_idx):
-        self.parent = parent
-        self.column_idx = column_idx
-        self.parent_array = np.asarray(parent).view(np.ndarray)
-
-    def _apply_operation(self, operation, value):
-        """Common method for all in-place operations."""
-        operation(self.parent_array[:, self.column_idx], value)
-        self.parent._sync_to_blender()
-        return self
-
-    def __iadd__(self, value):
-        return self._apply_operation(lambda arr, val: arr.__iadd__(val), value)
-
-    def __isub__(self, value):
-        return self._apply_operation(lambda arr, val: arr.__isub__(val), value)
-
-    def __imul__(self, value):
-        return self._apply_operation(lambda arr, val: arr.__imul__(val), value)
-
-    def __itruediv__(self, value):
-        return self._apply_operation(lambda arr, val: arr.__itruediv__(val), value)
-
-    def __array__(self, dtype=None):
-        """Convert to array, handling optional dtype argument."""
-        column_data = self.parent_array[:, self.column_idx]
-        return column_data.astype(dtype) if dtype is not None else column_data
-
-    def __eq__(self, other):
-        """Handle equality comparison."""
-        column_data = self.parent_array[:, self.column_idx]
-
-        if hasattr(other, "__array__"):
-            return np.array_equal(column_data, np.asarray(other))
-        return column_data == other
-
-    def __array_wrap__(self, out_arr, context=None):
-        """Handle the output of NumPy ufuncs and other functions."""
-        self.parent_array[:, self.column_idx] = out_arr
-        self.parent._sync_to_blender()
-        return self
-
-    @property
-    def column_data(self):
-        """Get the column data."""
-        return self.parent_array[:, self.column_idx]
-
-    def __getattr__(self, name):
-        """Delegate attribute access to the column data."""
-        column_data = self.parent_array[:, self.column_idx]
-        if hasattr(column_data, name):
-            return getattr(column_data, name)
-        raise AttributeError(
-            f"'{self.__class__.__name__}' object has no attribute '{name}'"
-        )
-
-
 class AttributeArray(np.ndarray):
     """
     A numpy array subclass that automatically syncs changes back to the Blender object.
@@ -109,6 +44,8 @@ def __new__(cls, obj: bpy.types.Object, name: str) -> "AttributeArray":
         arr._blender_object = obj
         arr._attribute = attr
         arr._attr_name = name
+        # Track the root array so that views can sync the full data
+        arr._root = arr
         return arr
 
     def __array_finalize__(self, obj):
@@ -119,72 +56,11 @@ def __array_finalize__(self, obj):
         self._blender_object = getattr(obj, "_blender_object", None)
         self._attribute = getattr(obj, "_attribute", None)
         self._attr_name = getattr(obj, "_attr_name", None)
-
-    def __eq__(self, other):
-        """Handle equality comparison for array objects."""
-        self_arr = np.asarray(self).view(np.ndarray)
-
-        if isinstance(other, AttributeArray):
-            other_arr = np.asarray(other).view(np.ndarray)
-            return np.array_equal(self_arr, other_arr)
-
-        if isinstance(other, ColumnAccessor):
-            return np.array_equal(self_arr, other.parent_array)
-
-        if hasattr(other, "__array__"):
-            other_arr = np.asarray(other)
-
-            # Handle shape differences for column comparisons
-            if (
-                self_arr.shape != other_arr.shape
-                and other_arr.ndim == 1
-                and self_arr.ndim == 2
-                and other_arr.shape[0] == self_arr.shape[0]
-            ):
-                return any(
-                    np.array_equal(self_arr[:, i], other_arr)
-                    for i in range(self_arr.shape[1])
-                )
-
-            return np.array_equal(self_arr, other_arr)
-
-        return self_arr == other
-
-    def __getitem__(self, key):
-        """Get item with special handling for column operations."""
-        # Handle column operations: pos[:, 2]
-        if (
-            isinstance(key, tuple)
-            and len(key) == 2
-            and isinstance(key[0], slice)
-            and key[0] == slice(None)
-            and isinstance(key[1], int)
-        ):
-            return ColumnAccessor(self, key[1])
-
-        return super().__getitem__(key)
+        # Preserve reference to the root array for syncing
+        self._root = getattr(obj, "_root", self)
 
     def __setitem__(self, key, value):
         """Set item and sync changes back to Blender."""
-        # Handle column operations: pos[:, 2] = value
-        if (
-            isinstance(key, tuple)
-            and len(key) == 2
-            and isinstance(key[0], slice)
-            and key[0] == slice(None)
-            and isinstance(key[1], int)
-        ):
-            arr_view = np.asarray(self).view(np.ndarray)
-            col_idx = key[1]
-
-            if isinstance(value, ColumnAccessor):
-                arr_view[:, col_idx] = value.column_data
-            else:
-                arr_view[:, col_idx] = value
-
-            self._sync_to_blender()
-            return
-
         super().__setitem__(key, value)
         self._sync_to_blender()
 
@@ -224,7 +100,9 @@ def _sync_to_blender(self):
         if self._blender_object is None:
             return
 
-        data_to_sync = np.asarray(self).view(np.ndarray)
+        # Always sync using the root array to ensure full shape
+        root = getattr(self, "_root", self)
+        data_to_sync = np.asarray(root).view(np.ndarray)
         data_to_sync = self._ensure_correct_shape(data_to_sync)
 
         # Ensure float32 dtype

databpy/object.py

@@ -16,6 +16,7 @@
     list_attributes,
     _check_obj_attributes,
     evaluate_object,
+    Attribute,
 )
 from .collection import create_collection
 
@@ -179,6 +180,23 @@ def __init__(self, obj: Object | str | None = None):
         elif obj is None:
             self._object_name = ""
 
+    def _ipython_key_completions_(self) -> list[str]:
+        """Return possible named attirbutes"""
+        return self.list_attributes()
+
+    def __getitem__(self, name: str) -> AttributeArray:
+        if not isinstance(name, str):
+            raise ValueError("Attribute name must be a string")
+        return AttributeArray(self.object, name)
+
+    def __setitem__(self, name: str, data: np.ndarray) -> None:
+        if name in self.list_attributes():
+            att = Attribute(self.attributes()[name])
+            self.store_named_attribute(
+                data=data, name=name, domain=att.domain, atype=att.atype
+            )
+        self.store_named_attribute(data=data, name=name)
+
     def _check_obj(self) -> None:
         _check_obj_attributes(self.object)
 

tests/test_array_print_methods.py

@@ -1,7 +1,7 @@
 import pytest
 import numpy as np
 from databpy import create_object
-from databpy.array import AttributeArray, ColumnAccessor, Attribute
+from databpy.array import AttributeArray, Attribute
 
 
 class TestAttributeArrayPrintMethods:
@@ -116,8 +116,8 @@ def test_str_method_with_large_array(self):
         assert "..." in result or len(result.split("\n")) > 1
 
 
-class TestColumnAccessorPrintMethods:
-    """Test print behavior of ColumnAccessor objects."""
+class TestColumnSlicePrintMethods:
+    """Test print behavior of column slice views."""
 
     @pytest.fixture
     def parent_array_and_data(self):
@@ -131,30 +131,30 @@ def parent_array_and_data(self):
 
         return parent_array, parent_data
 
-    def test_column_accessor_str_delegation(self, parent_array_and_data):
-        """Test that ColumnAccessor properly delegates string operations."""
+    def test_column_slice_str_delegation(self, parent_array_and_data):
+        """Test that a column slice delegates to numpy string formatting."""
         parent_array, parent_data = parent_array_and_data
 
-        # Create ColumnAccessor
-        col_accessor = ColumnAccessor(parent_array, 1)  # Second column
+        # Create column view
+        col_view = parent_array[:, 1]  # Second column
 
         # The string representation should come from the column data
         expected_column = parent_data[:, 1]  # [2.0, 5.0]
 
         # Test that we can convert to string (should use numpy's default)
-        result = str(np.asarray(col_accessor))
+        result = str(np.asarray(col_view))
         expected = str(expected_column)
 
         assert result == expected
 
-    def test_column_accessor_array_conversion(self, parent_array_and_data):
-        """Test that ColumnAccessor converts to array properly for printing."""
+    def test_column_slice_array_conversion(self, parent_array_and_data):
+        """Test that a column slice converts to array properly for printing."""
         parent_array, parent_data = parent_array_and_data
 
-        col_accessor = ColumnAccessor(parent_array, 0)  # First column
+        col_view = parent_array[:, 0]  # First column
 
         # Convert to array and check it matches expected column
-        as_array = np.asarray(col_accessor)
+        as_array = np.asarray(col_view)
         expected_column = parent_data[:, 0]  # [1.0, 4.0]
 
         np.testing.assert_array_equal(as_array, expected_column)