fixed formatting

Author: prasad-sawantdesai

imas/ids_slice.py

@@ -100,20 +100,20 @@ def shape(self) -> Tuple[int, ...]:
         array, based on the hierarchy of slicing operations performed.
 
         Raises:
-            ValueError: The underlying data is ragged (non-rectangular). Use 
-                .is_ragged to check first, or use .values() to extract values
-                as a flat list.
+            ValueError: The underlying data is ragged (non-rectangular).
+                Use .is_ragged to check first, or use .values() to extract
+                values as a flat list.
 
         Returns:
             Tuple of dimensions.
         """
         if self.is_ragged:
             raise ValueError(
-                f"Cannot get shape of ragged array: dimensions have varying sizes. "
-                f"Use .is_ragged to check if data is ragged, or .values() to "
-                f"get a flat list of elements."
+                "Cannot get shape of ragged array: dimensions have varying "
+                "sizes. Use .is_ragged to check if data is ragged, or .values() "
+                "to get a flat list of elements."
             )
-        
+
         # Build shape from hierarchy
         shape = []
         for i, hierarchy_level in enumerate(self._element_hierarchy):
@@ -129,7 +129,7 @@ def shape(self) -> Tuple[int, ...]:
             else:
                 # This is a single count
                 shape.append(hierarchy_level)
-        
+
         return tuple(shape)
 
     def __len__(self) -> int:
@@ -211,13 +211,15 @@ def _handle_list_slice(self, item: slice) -> "IDSSlice":
             IDSSlice with updated shape and hierarchy
         """
         from imas.ids_struct_array import IDSStructArray
-        
+
         slice_str = self._format_slice(item)
         # Full path: current path + slice operation
         full_path = self._path + slice_str
 
         # Check if matched elements are IDSStructArray (nested arrays)
-        if self._matched_elements and isinstance(self._matched_elements[0], IDSStructArray):
+        if self._matched_elements and isinstance(
+            self._matched_elements[0], IDSStructArray
+        ):
             # When slicing nested arrays, apply slice to each array and then flatten
             flattened_elements = []
             new_hierarchy_values = []
@@ -227,25 +229,28 @@ def _handle_list_slice(self, item: slice) -> "IDSSlice":
                 # Flatten: add each element from the sliced array to flattened list
                 for element in sliced_array:
                     flattened_elements.append(element)
-            
+
             # Build new hierarchy
-            # The key is: if we have a multi-level grouped hierarchy (like [3, [2, 2, 2], ...]),
-            # we're dealing with a nested structure that's already been flattened.
-            # We should only update the innermost level, NOT create a new top-level grouping.
-            
+            # The key is: if we have a multi-level grouped hierarchy
+            # (like [3, [2, 2, 2], ...]), we're dealing with a nested
+            # structure that's already been flattened. We should only update
+            # the innermost level, NOT create a new top-level grouping.
+
             num_groups = len(self._matched_elements)
-            
-            if (len(self._element_hierarchy) >= 2 and 
-                isinstance(self._element_hierarchy[0], int) and
-                isinstance(self._element_hierarchy[1], list)):
+
+            if (
+                len(self._element_hierarchy) >= 2
+                and isinstance(self._element_hierarchy[0], int)
+                and isinstance(self._element_hierarchy[1], list)
+            ):
                 # Multi-level hierarchy like [3, [2, 2, 2], ...]
                 # The top level is the original grouping, so DON'T recreate it
                 # Just replace the last (innermost) level
                 new_hierarchy = self._element_hierarchy[:-1] + [new_hierarchy_values]
             else:
                 # Single level or not grouped yet - create new grouping
                 new_hierarchy = [num_groups, new_hierarchy_values]
-            
+
             return IDSSlice(
                 self.metadata,
                 flattened_elements,
@@ -257,7 +262,7 @@ def _handle_list_slice(self, item: slice) -> "IDSSlice":
         else:
             # Normal slice on outer list
             sliced_elements = self._matched_elements[item]
-            
+
             # Update shape to reflect the slice on first dimension
             new_virtual_shape = (len(sliced_elements),) + self._virtual_shape[1:]
             new_element_hierarchy = [len(sliced_elements)] + self._element_hierarchy[1:]
@@ -316,7 +321,9 @@ def __getattr__(self, name: str) -> "IDSSlice":
 
         # Get attributes from all non-empty matched elements
         # Special case: if matched_elements are IDSStructArray, keep them grouped
-        if self._matched_elements and isinstance(self._matched_elements[0], IDSStructArray):
+        if self._matched_elements and isinstance(
+            self._matched_elements[0], IDSStructArray
+        ):
             # For nested arrays, return the arrays themselves, not attributes from them
             # This allows chaining like .ion[:].element[:] to work
             child_elements = self._matched_elements
@@ -335,19 +342,21 @@ def __getattr__(self, name: str) -> "IDSSlice":
                 element_hierarchy=self._element_hierarchy,
             )
 
-        # If matched_elements are IDSStructArray and we're accessing an attribute on them,
-        # we need to get that attribute from each array's elements
+        # If matched_elements are IDSStructArray and we're accessing an
+        # attribute on them, we need to get that attribute from each
+        # array's elements
         if isinstance(self._matched_elements[0], IDSStructArray):
-            # Accessing attribute on nested arrays: need to get attr from each array's elements
+            # Accessing attribute on nested arrays: get attr from each
+            # array's elements
             flattened_elements = []
             for array in child_elements:
-                # array is IDSStructArray, get the attribute from its elements
+                # array is IDSStructArray, get attribute from its elements
                 for element in array:
                     flattened_elements.append(getattr(element, name))
-            
+
             # Keep track of grouping for shape preservation
             child_sizes = [len(array) for array in child_elements]
-            
+
             return IDSSlice(
                 child_metadata,
                 flattened_elements,
@@ -417,21 +426,24 @@ def __repr__(self) -> str:
         """
         ids_name = self.metadata.ids_name
         item_word = "item" if len(self) == 1 else "items"
-        return f"<{type(self).__name__} (IDS:{ids_name}, {self._path} with {len(self)} {item_word})>"
+        return (
+            f"<{type(self).__name__} (IDS:{ids_name}, {self._path} with "
+            f"{len(self)} {item_word})>"
+        )
 
     def values(self) -> List[Any]:
         """Extract raw values from elements in this slice.
 
         For IDSPrimitive elements, this extracts the wrapped value.
         For other element types, returns them as-is.
 
-        Returns a flat list of extracted values. This is useful for getting 
-        the actual data without the IDS wrapper when accessing scalar fields 
-        through a slice, without requiring explicit looping through the 
+        Returns a flat list of extracted values. This is useful for getting
+        the actual data without the IDS wrapper when accessing scalar fields
+        through a slice, without requiring explicit looping through the
         original collection.
 
         For multi-dimensional access to values:
-        - Use direct indexing: ``ids_obj[i1].collection[i2].value`` for best 
+        - Use direct indexing: ``ids_obj[i1].collection[i2].value`` for best
           performance and clarity
         - Use ``.to_array()`` if you need numpy array integration
 
@@ -491,12 +503,14 @@ def to_array(self) -> np.ndarray:
             Tensorize a 1D slice of numeric data::
 
                 # Works: leaf nodes are numeric arrays
-                array = core_profiles.profiles_1d[:].te.to_array()  # Shape: (n_profiles,)
+                array = core_profiles.profiles_1d[:].te.to_array()
+                # Shape: (n_profiles,)
 
             Multi-dimensional tensorization::
 
                 # Works: accessing leaf nodes from nested structure
-                array = core_profiles.profiles_1d[:].te.to_array()  # Shape: (n_profiles,)
+                array = core_profiles.profiles_1d[:].te.to_array()
+                # Shape: (n_profiles,)
 
             Direct indexing for non-leaf nodes::
 
@@ -516,17 +530,17 @@ def to_array(self) -> np.ndarray:
             first = self._matched_elements[0]
             if isinstance(first, (IDSStructure, IDSStructArray)):
                 raise ValueError(
-                    f"Cannot tensorize {type(first).__name__} slice - only works for "
-                    f"leaf nodes (scalars, numeric arrays). Use direct indexing instead: "
-                    f"ids[i][j] to access structures."
+                    f"Cannot tensorize {type(first).__name__} slice - only "
+                    f"works for leaf nodes (scalars, numeric arrays). Use "
+                    f"direct indexing instead: ids[i][j] to access structures."
                 )
 
         # Validate: data must be rectangular (not ragged)
         if self.is_ragged:
             raise ValueError(
-                f"Cannot tensorize ragged array - dimensions have varying sizes. "
-                f"Use .values() to get a flat list, or use direct indexing for "
-                f"multi-dimensional access."
+                "Cannot tensorize ragged array - dimensions have varying "
+                "sizes. Use .values() to get a flat list, or use direct "
+                "indexing for multi-dimensional access."
             )
 
         # Get the target shape (we validated it's not ragged)
@@ -548,11 +562,11 @@ def to_array(self) -> np.ndarray:
 
         # Tensorize to target shape
         arr = np.array(flat_values)
-        
+
         # For 1D, no reshape needed
         if len(actual_shape) == 1:
             return arr
-        
+
         # For multi-dimensional, reshape to target shape
         try:
             return arr.reshape(actual_shape)

imas/test/test_multidim_slicing.py

@@ -85,11 +85,11 @@ def test_to_array_variable_size(self):
         cp.profiles_1d[2].grid.rho_tor_norm = np.array([0.0, 0.5, 1.0])
 
         result = cp.profiles_1d[:].grid.rho_tor_norm
-        
+
         # to_array() should raise ValueError for ragged data
         with pytest.raises(ValueError, match="Cannot tensorize ragged array"):
             result.to_array()
-        
+
         # But .values() should still work
         values = result.values()
         assert len(values) == 3
@@ -162,12 +162,12 @@ def test_integer_index_not_supported(self):
         # Option 1: Direct indexing (recommended)
         ion_0_from_first_profile = cp.profiles_1d[0].ion[:1]  # Use slice, not int index
         assert len(ion_0_from_first_profile) == 1
-        
+
         # Option 2: Convert to list
         ions_list = list(cp.profiles_1d[:].ion)
         ions_from_first_profile = ions_list[0]
         assert len(ions_from_first_profile) == 2
-        
+
         # Option 3: Extract values
         ions_values = cp.profiles_1d[:].ion.values()
         first_profile_ions = ions_values[0]
@@ -216,7 +216,7 @@ def test_negative_indexing_not_supported(self):
         # Get last ion from each profile using slice
         result = cp.profiles_1d[:].ion[2:3]  # Get last element with slice
         assert result.shape == (5, 1)
-        
+
         # Or better: direct indexing
         last_ions = [p.ion[-1] for p in cp.profiles_1d]
         assert len(last_ions) == 5