ruff style fixes

Author: gkiar

bids2table/pybids/__init__.py

@@ -1,14 +1,8 @@
-__all__ = [
-    "BIDSLayout",
-    "BIDSFile",
-    "Query",
-    "listify"
-]
+__all__ = ["BIDSLayout", "BIDSFile", "Query", "listify"]
 
-from ._layout import BIDSLayout
 from ._bidsfile import BIDSFile
+from ._layout import BIDSLayout
 from ._utils import (
     Query,
     listify,
 )
-

bids2table/pybids/_bidsfile.py

@@ -5,8 +5,7 @@
 BIDS entities from file paths.
 """
 
-from pathlib import Path
-from typing import Dict, Any, Optional
+from typing import Any, Dict, Optional
 
 from .._entities import parse_bids_entities
 

bids2table/pybids/_layout.py

@@ -5,9 +5,9 @@
 while leveraging bids2table's superior performance.
 """
 
-from pathlib import Path
-from typing import Union, Optional, List, Dict, Any
 import warnings
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
 
 import pandas as pd
 import pyarrow as pa
@@ -54,7 +54,7 @@ def __init__(
         cache_path: Optional[Path] = None,
         database_path: Optional[Path] = None,
         reset_database: bool = False,
-        **kwargs
+        **kwargs,
     ):
         # Initialize BIDSLayout with dataset indexing.
         self.root = Path(root).absolute()
@@ -66,12 +66,12 @@ def __init__(
                 "database_path is deprecated, use cache_path instead. "
                 "Note: cache uses parquet format, not SQLite.",
                 DeprecationWarning,
-                stacklevel=2
+                stacklevel=2,
             )
 
         # Set cache path
         if cache_path is None:
-            self.cache_path = self.root / '.bids2table_cache.parquet'
+            self.cache_path = self.root / ".bids2table_cache.parquet"
         else:
             self.cache_path = Path(cache_path)
 
@@ -106,7 +106,7 @@ def _load_or_create_index(self) -> pa.Table:
                     f"Failed to load cache from {self.cache_path}: {e}. "
                     "Re-indexing dataset.",
                     UserWarning,
-                    stacklevel=3
+                    stacklevel=3,
                 )
 
         # Create new index
@@ -121,7 +121,7 @@ def _load_or_create_index(self) -> pa.Table:
                 warnings.warn(
                     f"Failed to save cache to {self.cache_path}: {e}",
                     UserWarning,
-                    stacklevel=3
+                    stacklevel=3,
                 )
 
         return tab
@@ -145,7 +145,7 @@ def _add_derivatives(self, derivatives: Union[str, Path, List[Union[str, Path]]]
                 warnings.warn(
                     f"Derivative path does not exist: {deriv_path}",
                     UserWarning,
-                    stacklevel=3
+                    stacklevel=3,
                 )
                 continue
 
@@ -156,11 +156,7 @@ def _add_derivatives(self, derivatives: Union[str, Path, List[Union[str, Path]]]
         if deriv_tabs:
             self._tab = pa.concat_tables([self._tab] + deriv_tabs)
 
-    def get(
-        self,
-        return_type: str = 'file',
-        **entities
-    ) -> List[Union[str, BIDSFile]]:
+    def get(self, return_type: str = "file", **entities) -> List[Union[str, BIDSFile]]:
         """
         Query files by BIDS entities.
 
@@ -195,7 +191,7 @@ def get(
                 warnings.warn(
                     f"Unknown entity '{key}' (not in dataset columns)",
                     UserWarning,
-                    stacklevel=2
+                    stacklevel=2,
                 )
                 continue
 
@@ -217,14 +213,14 @@ def get(
                 result_df = result_df[result_df[key] == value]
 
         # Return based on return_type
-        if return_type == 'filename':
-            return result_df['path'].tolist()
-        elif return_type == 'file':
-            return [BIDSFile(p) for p in result_df['path'].tolist()]
-        elif return_type == 'id':
+        if return_type == "filename":
+            return result_df["path"].tolist()
+        elif return_type == "file":
+            return [BIDSFile(p) for p in result_df["path"].tolist()]
+        elif return_type == "id":
             return result_df.index.tolist()
-        elif return_type == 'dir':
-            dirs = result_df['path'].apply(lambda p: str(Path(p).parent))
+        elif return_type == "dir":
+            dirs = result_df["path"].apply(lambda p: str(Path(p).parent))
             return sorted(dirs.unique().tolist())
         else:
             raise ValueError(
@@ -244,11 +240,11 @@ def _map_entity_key(self, key: str) -> str:
         """
         # Common mappings
         mapping = {
-            'subject': 'sub',
-            'session': 'ses',
-            'extension': 'ext',
-            'datatype': 'datatype',
-            'suffix': 'suffix',
+            "subject": "sub",
+            "session": "ses",
+            "extension": "ext",
+            "datatype": "datatype",
+            "suffix": "suffix",
         }
         return mapping.get(key, key)
 
@@ -275,9 +271,9 @@ def get_subjects(self, **filters) -> List[str]:
                 key = self._map_entity_key(key)
                 if key in filtered_df.columns:
                     filtered_df = filtered_df[filtered_df[key] == value]
-            subjects = filtered_df['sub'].dropna().unique()
+            subjects = filtered_df["sub"].dropna().unique()
         else:
-            subjects = self.df['sub'].dropna().unique()
+            subjects = self.df["sub"].dropna().unique()
 
         return sorted(subjects.tolist())
 
@@ -302,15 +298,15 @@ def get_sessions(self, subject: Optional[str] = None, **filters) -> List[str]:
 
         # Filter by subject if provided
         if subject is not None:
-            result_df = result_df[result_df['sub'] == subject]
+            result_df = result_df[result_df["sub"] == subject]
 
         # Apply additional filters
         for key, value in filters.items():
             key = self._map_entity_key(key)
             if key in result_df.columns:
                 result_df = result_df[result_df[key] == value]
 
-        sessions = result_df['ses'].dropna().unique()
+        sessions = result_df["ses"].dropna().unique()
         return sorted(sessions.tolist())
 
     def get_metadata(self, path: str) -> Dict[str, Any]:
@@ -384,9 +380,30 @@ def get_entities(self, **filters) -> Dict[str, List[str]]:
 
         # Extract unique values for each entity column
         # Standard BIDS entities that might be present
-        entity_cols = ['sub', 'ses', 'task', 'acq', 'ce', 'rec', 'dir', 'run',
-                       'mod', 'echo', 'flip', 'inv', 'mt', 'part', 'recording',
-                       'suffix', 'space', 'res', 'den', 'label', 'desc', 'datatype']
+        entity_cols = [
+            "sub",
+            "ses",
+            "task",
+            "acq",
+            "ce",
+            "rec",
+            "dir",
+            "run",
+            "mod",
+            "echo",
+            "flip",
+            "inv",
+            "mt",
+            "part",
+            "recording",
+            "suffix",
+            "space",
+            "res",
+            "den",
+            "label",
+            "desc",
+            "datatype",
+        ]
 
         entities = {}
         for col in entity_cols:
@@ -398,10 +415,7 @@ def get_entities(self, **filters) -> Dict[str, List[str]]:
         return entities
 
     def add_custom_entity(
-        self,
-        name: str,
-        values: Union[List, Dict, Any],
-        overwrite: bool = False
+        self, name: str, values: Union[List, Dict, Any], overwrite: bool = False
     ):
         """
         Add a custom entity column to the layout.
@@ -446,20 +460,20 @@ def add_custom_entity(
         elif isinstance(values, dict):
             # Dict: map from key (assume subject or file path)
             # Try to detect if keys are subjects or paths
-            if values and list(values.keys())[0] in self.df['sub'].values:
+            if values and list(values.keys())[0] in self.df["sub"].values:
                 # Keys are subjects
-                self.df[name] = self.df['sub'].map(values)
+                self.df[name] = self.df["sub"].map(values)
             else:
                 # Keys are file paths or other
-                self.df[name] = self.df['path'].map(values)
+                self.df[name] = self.df["path"].map(values)
         else:
             # Scalar or array-like: assign directly
             self.df[name] = values
 
     def __repr__(self) -> str:
         """String representation of layout."""
-        n_subjects = self.df['sub'].nunique()
-        n_sessions = self.df['ses'].nunique()
+        n_subjects = self.df["sub"].nunique()
+        n_sessions = self.df["ses"].nunique()
         n_files = len(self.df)
 
         return (

bids2table/pybids/_utils.py

@@ -8,8 +8,8 @@ class Query:
 
     # Sentinel objects for special filtering behavior
     OPTIONAL = object()  # Allow missing or any value
-    NONE = object()      # Match explicit null/missing
-    ANY = object()       # Match any value (don't filter)
+    NONE = object()  # Match explicit null/missing
+    ANY = object()  # Match any value (don't filter)
 
     def __repr__(self):
         return "Query"

tests/pybids/test_bidsfile.py

@@ -1,31 +1,30 @@
 """Tests for BIDSFile class."""
 
-import pytest
 from bids2table.pybids import BIDSFile
 
 
 def test_bidsfile_init():
     """Test BIDSFile initialization."""
-    f = BIDSFile('sub-01/anat/sub-01_T1w.nii.gz')
-    assert f.path == 'sub-01/anat/sub-01_T1w.nii.gz'
+    f = BIDSFile("sub-01/anat/sub-01_T1w.nii.gz")
+    assert f.path == "sub-01/anat/sub-01_T1w.nii.gz"
     assert f._entities is None  # Not yet parsed
 
 
 def test_bidsfile_get_entities():
     """Test entity parsing from filename."""
-    f = BIDSFile('sub-01_ses-02_task-rest_bold.nii.gz')
+    f = BIDSFile("sub-01_ses-02_task-rest_bold.nii.gz")
     entities = f.get_entities()
 
     assert isinstance(entities, dict)
-    assert entities.get('sub') == '01'
-    assert entities.get('ses') == '02'
-    assert entities.get('task') == 'rest'
-    assert entities.get('suffix') == 'bold'
+    assert entities.get("sub") == "01"
+    assert entities.get("ses") == "02"
+    assert entities.get("task") == "rest"
+    assert entities.get("suffix") == "bold"
 
 
 def test_bidsfile_entities_cached():
     """Test that entities are cached after first parse."""
-    f = BIDSFile('sub-01_T1w.nii.gz')
+    f = BIDSFile("sub-01_T1w.nii.gz")
 
     # First call
     entities1 = f.get_entities()
@@ -38,37 +37,37 @@ def test_bidsfile_entities_cached():
 
 def test_bidsfile_str():
     """Test string representation."""
-    f = BIDSFile('sub-01/anat/sub-01_T1w.nii.gz')
-    assert str(f) == 'sub-01/anat/sub-01_T1w.nii.gz'
+    f = BIDSFile("sub-01/anat/sub-01_T1w.nii.gz")
+    assert str(f) == "sub-01/anat/sub-01_T1w.nii.gz"
 
 
 def test_bidsfile_repr():
     """Test developer representation."""
-    f = BIDSFile('sub-01/anat/sub-01_T1w.nii.gz')
+    f = BIDSFile("sub-01/anat/sub-01_T1w.nii.gz")
     assert repr(f) == "BIDSFile('sub-01/anat/sub-01_T1w.nii.gz')"
 
 
 def test_bidsfile_equality():
     """Test equality comparison."""
-    f1 = BIDSFile('sub-01_T1w.nii.gz')
-    f2 = BIDSFile('sub-01_T1w.nii.gz')
-    f3 = BIDSFile('sub-02_T1w.nii.gz')
+    f1 = BIDSFile("sub-01_T1w.nii.gz")
+    f2 = BIDSFile("sub-01_T1w.nii.gz")
+    f3 = BIDSFile("sub-02_T1w.nii.gz")
 
     assert f1 == f2
     assert f1 != f3
-    assert f1 != 'sub-01_T1w.nii.gz'  # Not equal to string
+    assert f1 != "sub-01_T1w.nii.gz"  # Not equal to string
 
 
 def test_bidsfile_hashable():
     """Test that BIDSFile can be used in sets/dicts."""
-    f1 = BIDSFile('sub-01_T1w.nii.gz')
-    f2 = BIDSFile('sub-01_T1w.nii.gz')
-    f3 = BIDSFile('sub-02_T1w.nii.gz')
+    f1 = BIDSFile("sub-01_T1w.nii.gz")
+    f2 = BIDSFile("sub-01_T1w.nii.gz")
+    f3 = BIDSFile("sub-02_T1w.nii.gz")
 
     # Can create set
     file_set = {f1, f2, f3}
     assert len(file_set) == 2  # f1 and f2 are equal
 
     # Can use as dict key
-    file_dict = {f1: 'first', f3: 'third'}
-    assert file_dict[f2] == 'first'  # f2 equals f1
+    file_dict = {f1: "first", f3: "third"}
+    assert file_dict[f2] == "first"  # f2 equals f1