feat(table) - Add fancy indexing

Author: protocolstardust

docs/docs/content/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to Rayforce-Py will be documented in this file.
 !!! note ""
     You can also subscribe for release notifications by joining our [:simple-zulip: Zulip](https://rayforcedb.zulipchat.com/#narrow/channel/549008-Discuss)!
 
+## **`0.6.1`**
+
+### New Features
+
+- **Fancy indexing for Tables**: `Table.__getitem__` now supports multiple indexing modes beyond column access:
+
+    - **Expression filter**: `table[Column("age") > 35]` — filter rows by condition. Supports `&` (and) and `|` (or) for combining expressions.
+    - **Integer row access**: `table[0]`, `table[-1]` — access a single row by index, returns a Dict.
+    - **Slicing**: `table[1:3]`, `table[:5]`, `table[-2:]` — row slicing backed by the C-level `TAKE` operation.
+    - **Index list**: `table[[0, 2, 5]]` — select specific rows by position.
+
+2026-02-23 | **[🔗 PyPI](https://pypi.org/project/rayforce-py/0.6.1/)** | **[🔗 GitHub](https://github.com/RayforceDB/rayforce-py/releases/tag/0.6.1)**
+
+
 ## **`0.6.0`**
 
 ### New Features

docs/docs/content/documentation/data-types/table/access-values.md

@@ -35,7 +35,47 @@ Vector([I64(29), I64(34), I64(41)])
 
 ```python
 >>> table[["id", "name"]]
-Table(columns=['id', 'name'])
+Table[Symbol('id'), Symbol('name')]
+```
+
+**Single row by index** - returns a [:material-code-braces: Dict](../dict.md):
+
+```python
+>>> table[0]
+Dict({'id': '001', 'name': 'alice', 'age': 29})
+
+>>> table[-1]  # last row
+Dict({'id': '003', 'name': 'charlie', 'age': 41})
+```
+
+**Row slicing** - returns a new [:octicons-table-24: Table](overview.md). Uses the C-level `TAKE` operation:
+
+```python
+>>> table[1:3]   # rows at index 1 and 2
+>>> table[:2]    # first 2 rows
+>>> table[-2:]   # last 2 rows
+>>> table[2:]    # from index 2 to end
+```
+
+**Filter by expression** - returns a new [:octicons-table-24: Table](overview.md) with matching rows:
+
+```python
+>>> from rayforce import Column
+
+>>> table[Column("age") > 35]
+```
+
+Expressions can be combined with `&` (and) and `|` (or):
+
+```python
+>>> table[(Column("age") > 30) & (Column("name") == "charlie")]
+>>> table[(Column("age") < 30) | (Column("age") > 40)]
+```
+
+**Select rows by index list** - returns a new [:octicons-table-24: Table](overview.md):
+
+```python
+>>> table[[0, 2]]  # rows at index 0 and 2
 ```
 
 ## Access a Specific Column

rayforce/types/table.py

@@ -403,13 +403,70 @@ def __len__(self) -> int:
         ).value
 
     @DestructiveOperationHandler()
-    def __getitem__(self, key: str | list[str]) -> Vector | List | Table:
+    def __getitem__(
+        self,
+        key: str | int | slice | list | Expression | Column,
+    ) -> Vector | List | Table | Dict:
         if isinstance(key, str):
             return self.at_column(key)
+
+        if isinstance(key, Expression):
+            return t.cast("Table", self).select("*").where(key).execute()
+
+        if isinstance(key, int):
+            return self.at_row(key)
+
+        if isinstance(key, slice):
+            if key.step is not None:
+                raise errors.RayforceIndexError("Slice step is not supported")
+
+            start, stop = key.start, key.stop
+
+            # table[-n:] → tail
+            if start is not None and start < 0 and stop is None:
+                return t.cast("Table", self).take(start)
+
+            # table[:n] → head
+            if start in (None, 0) and stop is not None and stop > 0:
+                return t.cast("Table", self).take(stop)
+
+            # table[a:b] → take with offset
+            if start is None:
+                start = 0
+            if stop is None:
+                stop = len(self)
+            if start < 0 or stop < 0:
+                length = len(self)
+                if start < 0:
+                    start = max(length + start, 0)
+                if stop < 0:
+                    stop = max(length + stop, 0)
+
+            return t.cast("Table", self).take(max(stop - start, 0), offset=start)
+
+        # List indexing: list[str] → column select, list[int] → row select
         if isinstance(key, list):
-            return t.cast("Table", self).select(*key).execute()
-        raise errors.RayforceConversionError(
-            f"Key must be a string or list of strings, got {type(key).__name__}"
+            if not key:
+                raise errors.RayforceIndexError("Cannot index with an empty list")
+            if isinstance(key[0], str):
+                return t.cast("Table", self).select(*key).execute()
+            if isinstance(key[0], int):
+                col_names = self.columns()
+                col_values = self.values()
+                new_data: dict[str, Vector] = {}
+                for i, name_sym in enumerate(col_names):
+                    name = name_sym.value if hasattr(name_sym, "value") else str(name_sym)
+                    new_data[name] = utils.eval_obj(
+                        List([Operation.AT, col_values[i], Vector(items=key, ray_type=I64)])
+                    )
+                return Table(new_data)
+            raise errors.RayforceTypeError(
+                f"List index elements must be str or int, got {type(key[0]).__name__}"
+            )
+
+        raise errors.RayforceTypeError(
+            f"Invalid index type: {type(key).__name__}. "
+            f"Use str, int, slice, list, Expression, Column, or boolean Vector."
         )
 
     @DestructiveOperationHandler()