style: Run ruff

Author: edmundmiller

altair_upset/preprocessing.py

@@ -5,26 +5,27 @@ def preprocess_data(data, sets, abbre, sort_order):
     """Handles the data preprocessing for UpSet plots."""
     # Create a copy to avoid SettingWithCopyWarning
     data = data.copy()
-    
+
     # Handle empty input data
     if len(data) == 0:
         # Create empty result DataFrame with required columns
         data = pd.DataFrame(columns=sets + ["count", "intersection_id", "degree"])
         data = pd.melt(data, id_vars=["intersection_id", "count", "degree"])
         data = data.rename(columns={"variable": "set", "value": "is_intersect"})
-        
+
         if abbre is None:
             abbre = sets
-            
+
         set_to_abbre = pd.DataFrame(
-            [[sets[i], abbre[i]] for i in range(len(sets))], columns=["set", "set_abbre"]
+            [[sets[i], abbre[i]] for i in range(len(sets))],
+            columns=["set", "set_abbre"],
         )
         set_to_order = pd.DataFrame(
             [[sets[i], 1 + sets.index(sets[i])] for i in range(len(sets))],
             columns=["set", "set_order"],
         )
         return data, set_to_abbre, set_to_order, abbre
-    
+
     # Process non-empty data
     data.loc[:, "count"] = 0
     data = data[sets + ["count"]]

altair_upset/upset.py

@@ -209,7 +209,9 @@ def UpSetAltair(
     if horizontal_bar_chart_width is None:
         horizontal_bar_chart_width = int(width * 0.15)  # Make it 25% of total width
     vertical_bar_chart_height = height * height_ratio
-    matrix_height = (height - vertical_bar_chart_height) * 0.8  # Reduce height to tighten spacing
+    matrix_height = (
+        height - vertical_bar_chart_height
+    ) * 0.8  # Reduce height to tighten spacing
     matrix_width = width - horizontal_bar_chart_width
 
     # Automatic padding

docs/conf.py

@@ -9,9 +9,9 @@
 sys.path.insert(0, str(Path(__file__).parent.parent.resolve()))
 
 # Project information
-project = 'altair-upset'
-copyright = f'2024-{datetime.now().year}, Edmund Miller'
-author = 'Edmund Miller'
+project = "altair-upset"
+copyright = f"2024-{datetime.now().year}, Edmund Miller"
+author = "Edmund Miller"
 
 # Extensions
 extensions = [
@@ -48,28 +48,28 @@
 
 # Intersphinx mapping
 intersphinx_mapping = {
-    'python': ('https://docs.python.org/3', None),
-    'altair': ('https://altair-viz.github.io/', None),
-    'pandas': ('https://pandas.pydata.org/docs/', None),
+    "python": ("https://docs.python.org/3", None),
+    "altair": ("https://altair-viz.github.io/", None),
+    "pandas": ("https://pandas.pydata.org/docs/", None),
 }
 
 # Paths and static files
-html_static_path = ['_static']  # Include _static directory
+html_static_path = ["_static"]  # Include _static directory
 html_css_files = [
-    'custom.css',
+    "custom.css",
 ]
-templates_path = ['_templates']
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+templates_path = ["_templates"]
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
 
 # Numpydoc settings
 numpydoc_show_class_members = False
 numpydoc_show_inherited_class_members = False
 numpydoc_class_members_toctree = False
 
 # Autodoc settings
-autodoc_default_flags = ['members', 'inherited-members']
-autodoc_member_order = 'groupwise'
-autodoc_typehints = 'none'
+autodoc_default_flags = ["members", "inherited-members"]
+autodoc_member_order = "groupwise"
+autodoc_typehints = "none"
 
 # Generate autosummary even if no references
 autosummary_generate = True

pyproject.toml

@@ -63,7 +63,7 @@ addopts = "--cov=altair_upset --cov-report=term-missing"
 [tool.ruff]
 line-length = 88
 target-version = "py38"
-select = ["E", "F", "I", "UP"]
+lint.select = ["E", "F", "I", "UP"]
 
 [tool.mypy]
 python_version = "3.8"

tests/test_advanced_features.py

@@ -12,140 +12,137 @@ def sample_data():
     """Create sample dataset for testing."""
     np.random.seed(42)
     n_samples = 100
-    
+
     # Create set membership data
-    data = pd.DataFrame({
-        'A': np.random.choice([0, 1], size=n_samples, p=[0.3, 0.7]),
-        'B': np.random.choice([0, 1], size=n_samples, p=[0.4, 0.6]),
-        'C': np.random.choice([0, 1], size=n_samples, p=[0.5, 0.5])
-    })
-    
+    data = pd.DataFrame(
+        {
+            "A": np.random.choice([0, 1], size=n_samples, p=[0.3, 0.7]),
+            "B": np.random.choice([0, 1], size=n_samples, p=[0.4, 0.6]),
+            "C": np.random.choice([0, 1], size=n_samples, p=[0.5, 0.5]),
+        }
+    )
+
     # Add set-specific attributes
-    data['set_size'] = data.sum(axis=1)  # Number of sets each element belongs to
-    
+    data["set_size"] = data.sum(axis=1)  # Number of sets each element belongs to
+
     return data
 
 
 @pytest.fixture
 def basic_chart(sample_data):
     """Create basic UpSet chart for testing."""
-    return au.UpSetAltair(
-        data=sample_data,
-        sets=['A', 'B', 'C'],
-        title="Test Chart"
-    )
+    return au.UpSetAltair(data=sample_data, sets=["A", "B", "C"], title="Test Chart")
 
 
 def test_basic_chart_structure(basic_chart):
     """Test that the basic chart has all required components."""
     # The chart should be a VConcatChart (vertical concatenation)
     assert isinstance(basic_chart.chart, alt.VConcatChart)
-    
+
     # Should have intersection matrix and bar charts
     assert len(basic_chart.chart.vconcat) == 2  # Vertical components
-    assert isinstance(basic_chart.chart.vconcat[1], alt.HConcatChart)  # Horizontal components
+    assert isinstance(
+        basic_chart.chart.vconcat[1], alt.HConcatChart
+    )  # Horizontal components
 
 
 def test_set_size_encoding(basic_chart):
     """Test that set sizes are correctly encoded."""
     # Get the horizontal bar chart component
     hconcat = basic_chart.chart.vconcat[1]
     horizontal_bar = hconcat.hconcat[-1]
-    
+
     # Check encoding - need to convert to dict to access field values
     encoding_dict = horizontal_bar.encoding.to_dict()
-    assert encoding_dict['x']['field'] == 'count'
-    assert encoding_dict['y']['field'] == 'set_order'
+    assert encoding_dict["x"]["field"] == "count"
+    assert encoding_dict["y"]["field"] == "set_order"
 
 
 def test_intersection_encoding(basic_chart):
     """Test that intersections are correctly encoded."""
     # Get the matrix view component
     hconcat = basic_chart.chart.vconcat[1]
     matrix = hconcat.hconcat[0]
-    
+
     # Convert encodings to dict for checking
-    encoding_dict = matrix.layer[0].encoding.to_dict()  # Use first layer for matrix encodings
-    assert encoding_dict['x']['field'] == 'intersection_id'
-    assert encoding_dict['y']['field'] == 'set_order'
+    encoding_dict = matrix.layer[
+        0
+    ].encoding.to_dict()  # Use first layer for matrix encodings
+    assert encoding_dict["x"]["field"] == "intersection_id"
+    assert encoding_dict["y"]["field"] == "set_order"
 
 
 def test_interactive_legend(basic_chart):
     """Test that the chart has interactive legend selection."""
     # Check for legend selection parameter
     params = basic_chart.chart.params
-    assert any('legend' in str(p) for p in params)
+    assert any("legend" in str(p) for p in params)
 
 
 def test_hover_interaction(basic_chart):
     """Test that the chart has hover interactions."""
     # Get the matrix view component
     hconcat = basic_chart.chart.vconcat[1]
     matrix = hconcat.hconcat[0]
-    
+
     # Check for tooltips in any layer of the matrix
     has_tooltip = False
     for layer in matrix.layer:
-        if hasattr(layer, 'encoding'):
+        if hasattr(layer, "encoding"):
             encoding_dict = layer.encoding.to_dict()
-            if 'tooltip' in encoding_dict:
+            if "tooltip" in encoding_dict:
                 has_tooltip = True
                 break
-    
+
     assert has_tooltip, "No tooltip found in matrix view"
 
 
 def test_sort_by_frequency(sample_data):
     """Test sorting intersections by frequency."""
     chart = au.UpSetAltair(
         data=sample_data,
-        sets=['A', 'B', 'C'],
-        sort_by='frequency',
-        sort_order='descending'
+        sets=["A", "B", "C"],
+        sort_by="frequency",
+        sort_order="descending",
     )
-    
+
     # Get the matrix view component
     matrix_view = chart.chart.vconcat[1].hconcat[0]
-    
+
     # Check sort configuration in the first layer
     encoding_dict = matrix_view.layer[0].encoding.to_dict()
-    sort_config = encoding_dict['x'].get('sort', {})
-    
-    assert sort_config.get('field') == 'count'
-    assert sort_config.get('order') == 'descending'
+    sort_config = encoding_dict["x"].get("sort", {})
+
+    assert sort_config.get("field") == "count"
+    assert sort_config.get("order") == "descending"
 
 
 def test_sort_by_degree(sample_data):
     """Test sorting intersections by degree."""
     chart = au.UpSetAltair(
-        data=sample_data,
-        sets=['A', 'B', 'C'],
-        sort_by='degree',
-        sort_order='ascending'
+        data=sample_data, sets=["A", "B", "C"], sort_by="degree", sort_order="ascending"
     )
-    
+
     # Get the matrix view component
     matrix_view = chart.chart.vconcat[1].hconcat[0]
-    
+
     # Check sort configuration in the first layer
     encoding_dict = matrix_view.layer[0].encoding.to_dict()
-    sort_config = encoding_dict['x'].get('sort', {})
-    
-    assert sort_config.get('field') == 'degree'
-    assert sort_config.get('order') == 'ascending'
+    sort_config = encoding_dict["x"].get("sort", {})
+
+    assert sort_config.get("field") == "degree"
+    assert sort_config.get("order") == "ascending"
 
 
 def test_custom_colors(sample_data):
     """Test applying custom colors to the chart."""
     custom_colors = ["#FF0000", "#00FF00", "#0000FF"]
     chart = au.UpSetAltair(
-        data=sample_data,
-        sets=['A', 'B', 'C'],
-        color_range=custom_colors
+        data=sample_data, sets=["A", "B", "C"], color_range=custom_colors
     )
-    
+
     # Check that custom colors are applied
     hconcat = chart.chart.vconcat[1]
     horizontal_bar = hconcat.hconcat[-1]
-    assert 'scale' in str(horizontal_bar.encoding.color)
+    assert "scale" in str(horizontal_bar.encoding.color)
     assert all(color in str(horizontal_bar.encoding.color) for color in custom_colors)