fix test

Author: bbcho

.github/workflows/ci.yml

@@ -26,12 +26,16 @@ jobs:
         run: |
           python -m pip install --upgrade pip
           pip install -e ".[dev,docs]"
-          pip install igraph networkx searoute
+          pip install igraph networkx searoute nbmake
 
       - name: Run tests
         run: |
           pytest --cov=ggplotly --cov-report=xml
 
+      - name: Test notebooks
+        run: |
+          pytest --nbmake docs/
+
       - name: Upload coverage to Codecov
         if: matrix.python-version == '3.12'
         uses: codecov/codecov-action@v4

docs/guide/aesthetics.ipynb

@@ -27,41 +27,7 @@
    "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "from ggplotly import *\n",
-    "\n",
-    "# Sample data\n",
-    "np.random.seed(42)\n",
-    "df = pd.DataFrame({\n",
-    "    'x': np.random.randn(100),\n",
-    "    'y': np.random.randn(100),\n",
-    "    'species': np.random.choice(['A', 'B', 'C'], 100),\n",
-    "    'value': np.random.rand(100) * 10\n",
-    "})\n",
-    "\n",
-    "# Time series data\n",
-    "ts_df = pd.DataFrame({\n",
-    "    'date': pd.date_range('2024-01-01', periods=50, freq='D'),\n",
-    "    'value': np.cumsum(np.random.randn(50)) + 50\n",
-    "})\n",
-    "ts_df.index = ts_df['date']\n",
-    "ts_df.index.name = 'date'\n",
-    "\n",
-    "# Bar data\n",
-    "bar_df = pd.DataFrame({\n",
-    "    'category': ['A', 'B', 'C', 'D'],\n",
-    "    'count': [25, 40, 35, 30]\n",
-    "})\n",
-    "\n",
-    "# Line data with groups\n",
-    "line_df = pd.DataFrame({\n",
-    "    'x': np.tile(np.arange(10), 3),\n",
-    "    'y': np.random.randn(30),\n",
-    "    'id': np.repeat(['A', 'B', 'C'], 10)\n",
-    "})"
-   ]
+   "source": "import pandas as pd\nimport numpy as np\nfrom ggplotly import *\n\n# Sample data\nnp.random.seed(42)\ndf = pd.DataFrame({\n    'x': np.random.randn(100),\n    'y': np.random.randn(100),\n    'species': np.random.choice(['A', 'B', 'C'], 100),\n    'value': np.random.rand(100) * 10\n})\n\n# Time series data\nts_df = pd.DataFrame({\n    'date': pd.date_range('2024-01-01', periods=50, freq='D'),\n    'value': np.cumsum(np.random.randn(50)) + 50\n})\nts_df = ts_df.set_index('date')  # Set date as index, removes it from columns\n\n# Bar data\nbar_df = pd.DataFrame({\n    'category': ['A', 'B', 'C', 'D'],\n    'count': [25, 40, 35, 30]\n})\n\n# Line data with groups\nline_df = pd.DataFrame({\n    'x': np.tile(np.arange(10), 3),\n    'y': np.random.randn(30),\n    'id': np.repeat(['A', 'B', 'C'], 10)\n})"
   },
   {
    "cell_type": "markdown",
@@ -292,18 +258,14 @@
    "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": [
-    "ggplot(ts_df, aes(x='date', y='value')) + geom_line(linetype='dash')"
-   ]
+   "source": "ggplot(ts_df, aes(y='value')) + geom_line(linetype='dash')"
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": [
-    "ggplot(ts_df, aes(x='date', y='value')) + geom_line(linetype='dot')"
-   ]
+   "source": "ggplot(ts_df, aes(y='value')) + geom_line(linetype='dot')"
   }
  ],
  "metadata": {
@@ -319,4 +281,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 4
-}
+}

docs/guide/coordinates.ipynb

@@ -108,16 +108,7 @@
    "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": [
-    "# Pie chart\n",
-    "pie_df = pd.DataFrame({\n",
-    "    'category': ['A', 'B', 'C', 'D'],\n",
-    "    'value': [25, 30, 20, 25]\n",
-    "})\n",
-    "ggplot(pie_df, aes(x='', y='value', fill='category')) + \\\n",
-    "    geom_bar(stat='identity', width=1) + \\\n",
-    "    coord_polar(theta='y')"
-   ]
+   "source": "# Pie chart\npie_df = pd.DataFrame({\n    'category': ['A', 'B', 'C', 'D'],\n    'value': [25, 30, 20, 25]\n})\npie_df['x'] = 1  # Constant x for stacked bar -> pie conversion\n\nggplot(pie_df, aes(x='x', y='value', fill='category')) + \\\n    geom_bar(stat='identity', width=1) + \\\n    coord_polar(theta='y')"
   },
   {
    "cell_type": "markdown",
@@ -179,4 +170,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 4
-}
+}

ggplotly/facets.py

@@ -142,6 +142,10 @@ def _has_3d_geoms(self, plot):
                 return True
         return False
 
+    def _is_no_facet(self, value):
+        """Check if value means 'no faceting on this dimension'."""
+        return value is None or value == '.'
+
     def apply(self, plot):
         """
         Apply facet grid to the plot.
@@ -155,25 +159,29 @@ def apply(self, plot):
         Raises:
             FacetColumnNotFoundError: If row or column variable doesn't exist in the data.
         """
-        # Validate row facet column exists
-        if self.rows not in plot.data.columns:
+        # Check if rows/cols are disabled (None or '.')
+        has_rows = not self._is_no_facet(self.rows)
+        has_cols = not self._is_no_facet(self.cols)
+
+        # Validate row facet column exists (if specified)
+        if has_rows and self.rows not in plot.data.columns:
             raise FacetColumnNotFoundError(
                 self.rows,
                 list(plot.data.columns),
                 facet_type="facet_grid rows"
             )
 
-        # Validate column facet column exists
-        if self.cols not in plot.data.columns:
+        # Validate column facet column exists (if specified)
+        if has_cols and self.cols not in plot.data.columns:
             raise FacetColumnNotFoundError(
                 self.cols,
                 list(plot.data.columns),
                 facet_type="facet_grid cols"
             )
 
         # Get unique values for the row and column variables
-        row_facets = plot.data[self.rows].unique()
-        col_facets = plot.data[self.cols].unique()
+        row_facets = plot.data[self.rows].unique() if has_rows else [None]
+        col_facets = plot.data[self.cols].unique() if has_cols else [None]
 
         nrows = len(row_facets)
         ncols = len(col_facets)
@@ -192,14 +200,22 @@ def apply(self, plot):
         shared_y = self.scales in ('fixed', 'free_x')
 
         # Generate labels
-        labels = [self._get_label(self.rows, row, self.cols, col)
-                  for row in row_facets for col in col_facets]
+        def get_facet_label(row, col):
+            if has_rows and has_cols:
+                return self._get_label(self.rows, row, self.cols, col)
+            elif has_rows:
+                return str(row)
+            elif has_cols:
+                return str(col)
+            else:
+                return ""
+        labels = [get_facet_label(row, col) for row in row_facets for col in col_facets]
 
         # Calculate column widths and row heights based on space parameter
         column_widths = None
         row_heights = None
 
-        if self.space in ('free', 'free_x'):
+        if self.space in ('free', 'free_x') and has_cols:
             # Calculate width proportional to x-axis data range per column
             x_col = plot.mapping.get('x')
             if x_col and x_col in plot.data.columns:
@@ -214,7 +230,7 @@ def apply(self, plot):
                 if total > 0:
                     column_widths = [r / total for r in col_ranges]
 
-        if self.space in ('free', 'free_y'):
+        if self.space in ('free', 'free_y') and has_rows:
             # Calculate height proportional to y-axis data range per row
             y_col = plot.mapping.get('y')
             if y_col and y_col in plot.data.columns:
@@ -269,10 +285,17 @@ def apply(self, plot):
                     scene_key = None
 
                 # Subset data for the current facet (row and column combination)
-                facet_data = plot.data[
-                    (plot.data[self.rows] == row_value)
-                    & (plot.data[self.cols] == col_value)
-                ]
+                if has_rows and has_cols:
+                    facet_data = plot.data[
+                        (plot.data[self.rows] == row_value)
+                        & (plot.data[self.cols] == col_value)
+                    ]
+                elif has_rows:
+                    facet_data = plot.data[plot.data[self.rows] == row_value]
+                elif has_cols:
+                    facet_data = plot.data[plot.data[self.cols] == col_value]
+                else:
+                    facet_data = plot.data
 
                 # Draw each geom on the subplot for the current facet
                 for geom in plot.layers:
@@ -281,10 +304,17 @@ def apply(self, plot):
 
                     # If geom has its own explicit data, use that for faceting instead of plot.data
                     if hasattr(geom, '_has_explicit_data') and geom._has_explicit_data:
-                        geom_facet_data = geom.data[
-                            (geom.data[self.rows] == row_value)
-                            & (geom.data[self.cols] == col_value)
-                        ]
+                        if has_rows and has_cols:
+                            geom_facet_data = geom.data[
+                                (geom.data[self.rows] == row_value)
+                                & (geom.data[self.cols] == col_value)
+                            ]
+                        elif has_rows:
+                            geom_facet_data = geom.data[geom.data[self.rows] == row_value]
+                        elif has_cols:
+                            geom_facet_data = geom.data[geom.data[self.cols] == col_value]
+                        else:
+                            geom_facet_data = geom.data
                         geom.setup_data(geom_facet_data, plot.mapping)
                     else:
                         geom.setup_data(facet_data, plot.mapping)

ggplotly/geoms/geom_map.py

@@ -131,13 +131,15 @@ def _draw_impl(self, fig, data, row, col):
 
         # Determine the mode:
         # 1. GeoJSON mode (sf-like) - when geojson is provided or data is GeoDataFrame
-        # 2. Choropleth mode - when map_id is provided
-        # 3. Base map mode - no data aesthetics
+        # 2. Choropleth mode - when map_id is provided (with optional fill)
+        # 3. Base map mode - no map_id (fill is ignored - may be inherited from other geoms)
         is_geojson_mode = geojson is not None
-        is_base_map = map_id_col is None and fill_col is None and not is_geojson_mode
+        is_choropleth = map_id_col is not None
+        is_base_map = not is_geojson_mode and not is_choropleth
 
         if is_base_map:
             # Just set up the geo layout - no data traces needed
+            # Note: fill may be inherited from ggplot aes but is ignored for base maps
             self._setup_geo_layout(fig)
             return
 
@@ -146,9 +148,7 @@ def _draw_impl(self, fig, data, row, col):
             self._draw_geojson(fig, data, geojson, fill_col)
             return
 
-        # Choropleth mode - require map_id
-        if map_id_col is None:
-            raise ValueError("geom_map choropleth requires a 'map_id' aesthetic")
+        # Choropleth mode - map_id is required (already checked above)
 
         mapper = AestheticMapper(data, self.mapping, self.params, self.theme)
         style_props = mapper.get_style_properties()

ggplotly/geoms/geom_point_3d.py

@@ -131,15 +131,23 @@ def should_show_legend(legendgroup):
             fig._shown_legendgroups.add(legendgroup)
             return True
 
-        # Determine grouping strategy
-        has_color_grouping = style_props['color_series'] is not None or style_props['fill_series'] is not None
+        # Check for continuous (numeric) color mapping
+        has_continuous_color = (
+            style_props.get('color_is_continuous', False) or
+            style_props.get('fill_is_continuous', False)
+        )
+
+        # Determine grouping strategy - only count as categorical if not continuous
+        has_color_grouping = (
+            style_props['color_series'] is not None or style_props['fill_series'] is not None
+        ) and not has_continuous_color
         has_shape_grouping = shape_series is not None
 
         # Get categorical aesthetic info
-        if style_props['color_series'] is not None:
+        if style_props['color_series'] is not None and not has_continuous_color:
             cat_col = style_props['color']
             cat_map = style_props['color_map']
-        elif style_props['fill_series'] is not None:
+        elif style_props['fill_series'] is not None and not has_continuous_color:
             cat_col = style_props['fill']
             cat_map = style_props['fill_map']
         else:
@@ -233,7 +241,46 @@ def should_show_legend(legendgroup):
                     trace_props, alpha, legend_name, should_show_legend, row, col
                 )
 
-        # Case 5: No grouping - single trace
+        # Case 5: Continuous color mapping (numeric values with colorscale)
+        elif has_continuous_color:
+            # Get the numeric color values
+            if style_props.get('color_is_continuous'):
+                color_values = style_props['color_series']
+            else:
+                color_values = style_props['fill_series']
+
+            # Build marker dict with colorscale
+            marker_dict = dict(
+                size=style_props['size'],
+                color=color_values,
+                colorscale='Viridis',  # Default, may be overridden by scale
+                showscale=True,
+                opacity=alpha,
+            )
+
+            # Get colorscale from scale if available
+            colorscale = style_props.get('colorscale')
+            if colorscale:
+                marker_dict['colorscale'] = colorscale
+
+            # Use scene key for faceted plots (3D traces use scene, not row/col)
+            scene_key = self.params.get('_scene_key', 'scene')
+
+            trace_name = self.params.get('name', '3D Scatter')
+            fig.add_trace(
+                go.Scatter3d(
+                    x=x,
+                    y=y,
+                    z=z,
+                    mode='markers',
+                    marker=marker_dict,
+                    name=trace_name,
+                    showlegend=False,  # Colorbar replaces discrete legend
+                    scene=scene_key,
+                )
+            )
+
+        # Case 6: No grouping - single trace
         else:
             trace_props = self._apply_color_targets(
                 {'color': 'marker_color', 'size': 'marker_size', 'shape': 'marker_symbol'},

pyproject.toml

@@ -52,6 +52,7 @@ dev = [
     "pytest>=7.0.0",
     "pytest-cov>=4.0.0",
     "pytest-ruff>=0.4.0",
+    "nbmake>=1.5.0",
     "black>=23.0.0",
     "ruff>=0.1.0",
     "mypy>=1.0.0",
@@ -92,9 +93,9 @@ include = ["ggplotly*"]
 ggplotly = ["data/*.csv"]
 
 [tool.pytest.ini_options]
-testpaths = ["pytest"]
+testpaths = ["pytest", "docs"]
 python_files = ["test_*.py"]
-addopts = "-v --tb=short"
+addopts = "-v --tb=short --nbmake"
 
 [tool.black]
 line-length = 88

pytest/test_geom_map.py

@@ -297,17 +297,24 @@ def test_base_map_custom_projection(self):
 class TestGeomMapChoropleth:
     """Tests for choropleth functionality."""
 
-    def test_choropleth_requires_map_id(self):
-        """Test that choropleth mode requires map_id aesthetic."""
+    def test_fill_without_map_id_creates_base_map(self):
+        """Test that fill without map_id creates base map (fill is ignored).
+
+        This allows geom_map to be used as a background when fill is inherited
+        from ggplot aes but intended for other geoms like geom_tile.
+        """
         data = pd.DataFrame({
             'value': [100, 200, 300],
         })
 
-        with pytest.raises(ValueError, match="map_id"):
-            fig = (
-                ggplot(data, aes(fill='value'))
-                + geom_map()
-            ).draw()
+        # Should not raise - creates base map, fill is ignored
+        fig = (
+            ggplot(data, aes(fill='value'))
+            + geom_map()
+        ).draw()
+
+        # Base map doesn't add data traces, just sets up geo layout
+        assert fig is not None
 
     def test_choropleth_with_fill_creates_choropleth_trace(self):
         """Test choropleth with numeric fill creates correct trace type."""