discovery: default to wide schema, deprecate narrow

- discover_sensors() now defaults to schema="wide" (instant
  information_schema.columns lookup) instead of schema="narrow"
- narrow schema path emits DeprecationWarning directing users to wide
- Updated tests: split into TestDiscoverSensorsWide and
  TestDiscoverSensorsNarrow; added deprecation warning assertion
- Bump version to 0.2.2

Author: wfr-data-acquisition

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slicks"
-version = "0.2.1"
+version = "0.2.2"
 description = "The home baked data pipeline for Western Formula Racing"
 readme = "README.md"
 authors = [

src/slicks/discovery.py

@@ -2,13 +2,14 @@
 Sensor discovery module.
 
 Scans the database for all unique sensor names within a time range.
-Uses adaptive chunking with parallel execution for narrow schema.
-For wide schema, uses instant information_schema.columns metadata lookup.
+For wide schema (default), uses an instant information_schema.columns metadata lookup.
+For narrow schema (legacy EAV), uses adaptive chunking with parallel execution.
 """
 
 from __future__ import annotations
 
 import threading
+import warnings
 from datetime import datetime, timedelta
 from typing import List, Optional
 
@@ -26,24 +27,25 @@ def discover_sensors(
     chunk_size_days: int = 7,
     client=None,
     show_progress: bool = True,
-    schema: str = "narrow",
+    schema: str = "wide",
 ) -> List[str]:
     """
     Scan the database for ALL unique sensor names within the time range.
 
-    For ``schema="wide"``, uses an instant ``information_schema.columns`` metadata
-    lookup (no data scan, no adaptive bisection, ignores time range and chunk params).
+    For ``schema="wide"`` (default), uses an instant ``information_schema.columns``
+    metadata lookup (no data scan, no adaptive bisection, ignores time range and
+    chunk params).
 
-    For ``schema="narrow"`` (default), uses adaptive chunking with parallel execution
-    to handle server resource limits efficiently.
+    For ``schema="narrow"`` (legacy EAV, deprecated), uses adaptive chunking with
+    parallel execution to handle server resource limits efficiently.
 
     Args:
         start_time: Start of scan range (narrow schema only).
         end_time: End of scan range (narrow schema only).
         chunk_size_days: Days per chunk (default 7, narrow schema only).
         client: Ignored (kept for backward compatibility).
         show_progress: Show progress bar (default True, narrow schema only).
-        schema: "narrow" (legacy EAV) or "wide" (one field per signal).
+        schema: "wide" (default, one column per signal) or "narrow" (legacy EAV, deprecated).
 
     Returns:
         Sorted list of unique sensor name strings.
@@ -68,7 +70,13 @@ def discover_sensors(
             if v.as_py() is not None and v.as_py() not in NON_SIGNAL_COLS
         )
 
-    # --- narrow (legacy EAV) path ---
+    # --- narrow (legacy EAV) path — deprecated, wide schema is now standard ---
+    warnings.warn(
+        "schema='narrow' is deprecated and will be removed in a future release. "
+        "WFR has moved to wide schema — use schema='wide' (now the default).",
+        DeprecationWarning,
+        stacklevel=2,
+    )
 
     def _make_client():
         return get_influx_client()

tests/test_discovery.py

@@ -6,9 +6,11 @@
 - Arrow-direct extraction (no pandas)
 - Deduplication and sorting
 - Error classification and propagation
+- Wide schema (default) vs narrow schema (legacy, deprecated)
 """
 
 import unittest
+import warnings
 from datetime import datetime
 from unittest.mock import MagicMock, patch
 import sys
@@ -19,31 +21,34 @@
 from slicks.discovery import discover_sensors
 
 
-class TestDiscoverSensorsMocked(unittest.TestCase):
-    """Tests for discover_sensors with mocked InfluxDB."""
+def _make_wide_mock_config(mock_config):
+    """Set config attributes expected by the wide schema path."""
+    mock_config.INFLUX_SCHEMA = "iox"
+    mock_config.INFLUX_TABLE = "WFR26"
+    mock_config.INFLUX_DB = "WFR26"
+
+
+class TestDiscoverSensorsWide(unittest.TestCase):
+    """Tests for discover_sensors with wide schema (default)."""
 
     @patch('slicks.discovery.get_influx_client')
     @patch('slicks.discovery.config')
-    def test_returns_sorted_unique_sensors(self, mock_config, mock_client_class):
-        """Should return sorted deduplicated sensor list."""
-        mock_config.INFLUX_URL = "http://localhost:8086"
-        mock_config.INFLUX_TOKEN = "test-token"
-        mock_config.INFLUX_DB = "test-db"
+    def test_returns_sorted_sensors(self, mock_config, mock_client_class):
+        """Should return sorted sensor list from column metadata."""
+        _make_wide_mock_config(mock_config)
 
-        mock_col_values = [MagicMock(), MagicMock(), MagicMock()]
+        mock_col_values = [MagicMock(), MagicMock()]
         mock_col_values[0].as_py.return_value = "SensorB"
         mock_col_values[1].as_py.return_value = "SensorA"
-        mock_col_values[2].as_py.return_value = "SensorB"  # duplicate
 
         mock_table = MagicMock()
-        mock_table.num_rows = 3
+        mock_table.num_rows = 2
         mock_col = MagicMock()
         mock_col.__iter__ = MagicMock(return_value=iter(mock_col_values))
         mock_table.column.return_value = mock_col
 
         mock_client = MagicMock()
         mock_client.query.return_value = mock_table
-        mock_client.close = MagicMock()
         mock_client_class.return_value = mock_client
 
         result = discover_sensors(
@@ -57,16 +62,13 @@ def test_returns_sorted_unique_sensors(self, mock_config, mock_client_class):
     @patch('slicks.discovery.get_influx_client')
     @patch('slicks.discovery.config')
     def test_returns_empty_list_when_no_data(self, mock_config, mock_client_class):
-        """Should return empty list when no sensors found."""
-        mock_config.INFLUX_URL = "http://localhost:8086"
-        mock_config.INFLUX_TOKEN = "test-token"
-        mock_config.INFLUX_DB = "test-db"
+        """Should return empty list when no columns found."""
+        _make_wide_mock_config(mock_config)
 
         mock_table = MagicMock()
         mock_table.num_rows = 0
         mock_client = MagicMock()
         mock_client.query.return_value = mock_table
-        mock_client.close = MagicMock()
         mock_client_class.return_value = mock_client
 
         result = discover_sensors(
@@ -77,33 +79,11 @@ def test_returns_empty_list_when_no_data(self, mock_config, mock_client_class):
 
         self.assertEqual(result, [])
 
-    @patch('slicks.discovery.get_influx_client')
-    @patch('slicks.discovery.config')
-    def test_raises_on_permanent_error(self, mock_config, mock_client_class):
-        """Should raise RuntimeError on auth failure."""
-        mock_config.INFLUX_URL = "http://localhost:8086"
-        mock_config.INFLUX_TOKEN = "bad-token"
-        mock_config.INFLUX_DB = "test-db"
-
-        mock_client = MagicMock()
-        mock_client.query.side_effect = Exception("Unauthorized: invalid token")
-        mock_client.close = MagicMock()
-        mock_client_class.return_value = mock_client
-
-        with self.assertRaises(RuntimeError):
-            discover_sensors(
-                start_time=datetime(2025, 1, 1),
-                end_time=datetime(2025, 1, 2),
-                show_progress=False,
-            )
-
     @patch('slicks.discovery.get_influx_client')
     @patch('slicks.discovery.config')
     def test_filters_none_values(self, mock_config, mock_client_class):
-        """Should skip None values in the signal name column."""
-        mock_config.INFLUX_URL = "http://localhost:8086"
-        mock_config.INFLUX_TOKEN = "test-token"
-        mock_config.INFLUX_DB = "test-db"
+        """Should skip None values in the column_name column."""
+        _make_wide_mock_config(mock_config)
 
         mock_col_values = [MagicMock(), MagicMock()]
         mock_col_values[0].as_py.return_value = "SensorA"
@@ -117,7 +97,6 @@ def test_filters_none_values(self, mock_config, mock_client_class):
 
         mock_client = MagicMock()
         mock_client.query.return_value = mock_table
-        mock_client.close = MagicMock()
         mock_client_class.return_value = mock_client
 
         result = discover_sensors(
@@ -130,53 +109,126 @@ def test_filters_none_values(self, mock_config, mock_client_class):
 
     @patch('slicks.discovery.get_influx_client')
     @patch('slicks.discovery.config')
-    def test_default_chunk_size_is_7_days(self, mock_config, mock_client_class):
-        """Default chunk_size_days=7 should produce 2 chunks for 10-day range."""
-        mock_config.INFLUX_URL = "http://localhost:8086"
-        mock_config.INFLUX_TOKEN = "test-token"
-        mock_config.INFLUX_DB = "test-db"
+    def test_single_query_regardless_of_time_range(self, mock_config, mock_client_class):
+        """Wide schema should issue exactly one metadata query, ignoring time range."""
+        _make_wide_mock_config(mock_config)
 
         mock_table = MagicMock()
         mock_table.num_rows = 0
         mock_client = MagicMock()
         mock_client.query.return_value = mock_table
-        mock_client.close = MagicMock()
         mock_client_class.return_value = mock_client
 
         discover_sensors(
             start_time=datetime(2025, 1, 1),
-            end_time=datetime(2025, 1, 11),
+            end_time=datetime(2025, 12, 31),
             show_progress=False,
         )
 
-        # 10-day range with 7-day chunks = 2 chunks, each triggers at least 1 query
-        self.assertGreaterEqual(mock_client.query.call_count, 2)
+        self.assertEqual(mock_client.query.call_count, 1)
 
     @patch('slicks.discovery.get_influx_client')
     @patch('slicks.discovery.config')
     def test_backward_compatible_client_param(self, mock_config, mock_client_class):
         """Passing client= should not raise (backward compat), even though unused."""
-        mock_config.INFLUX_URL = "http://localhost:8086"
-        mock_config.INFLUX_TOKEN = "test-token"
-        mock_config.INFLUX_DB = "test-db"
+        _make_wide_mock_config(mock_config)
 
         mock_table = MagicMock()
         mock_table.num_rows = 0
         mock_client = MagicMock()
         mock_client.query.return_value = mock_table
-        mock_client.close = MagicMock()
         mock_client_class.return_value = mock_client
 
-        old_client = MagicMock()
         result = discover_sensors(
             start_time=datetime(2025, 1, 1),
             end_time=datetime(2025, 1, 2),
-            client=old_client,
+            client=MagicMock(),
             show_progress=False,
         )
 
         self.assertEqual(result, [])
 
 
+class TestDiscoverSensorsNarrow(unittest.TestCase):
+    """Tests for discover_sensors with narrow schema (legacy EAV, deprecated)."""
+
+    def _make_narrow_config(self, mock_config):
+        mock_config.INFLUX_URL = "http://localhost:8086"
+        mock_config.INFLUX_TOKEN = "test-token"
+        mock_config.INFLUX_SCHEMA = "iox"
+        mock_config.INFLUX_TABLE = "WFR26"
+        mock_config.INFLUX_DB = "WFR26"
+
+    @patch('slicks.discovery.get_influx_client')
+    @patch('slicks.discovery.config')
+    def test_emits_deprecation_warning(self, mock_config, mock_client_class):
+        """schema='narrow' should emit a DeprecationWarning."""
+        self._make_narrow_config(mock_config)
+
+        mock_table = MagicMock()
+        mock_table.num_rows = 0
+        mock_client = MagicMock()
+        mock_client.query.return_value = mock_table
+        mock_client_class.return_value = mock_client
+
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            discover_sensors(
+                start_time=datetime(2025, 1, 1),
+                end_time=datetime(2025, 1, 2),
+                schema="narrow",
+                show_progress=False,
+            )
+
+        deprecation_warnings = [w for w in caught if issubclass(w.category, DeprecationWarning)]
+        self.assertEqual(len(deprecation_warnings), 1)
+        self.assertIn("narrow", str(deprecation_warnings[0].message))
+        self.assertIn("wide", str(deprecation_warnings[0].message))
+
+    @patch('slicks.discovery.get_influx_client')
+    @patch('slicks.discovery.config')
+    def test_raises_on_permanent_error(self, mock_config, mock_client_class):
+        """Should raise RuntimeError on auth failure."""
+        self._make_narrow_config(mock_config)
+
+        mock_client = MagicMock()
+        mock_client.query.side_effect = Exception("Unauthorized: invalid token")
+        mock_client_class.return_value = mock_client
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            with self.assertRaises(RuntimeError):
+                discover_sensors(
+                    start_time=datetime(2025, 1, 1),
+                    end_time=datetime(2025, 1, 2),
+                    schema="narrow",
+                    show_progress=False,
+                )
+
+    @patch('slicks.discovery.get_influx_client')
+    @patch('slicks.discovery.config')
+    def test_default_chunk_size_is_7_days(self, mock_config, mock_client_class):
+        """Default chunk_size_days=7 should produce 2 chunks for 10-day range."""
+        self._make_narrow_config(mock_config)
+
+        mock_table = MagicMock()
+        mock_table.num_rows = 0
+        mock_client = MagicMock()
+        mock_client.query.return_value = mock_table
+        mock_client_class.return_value = mock_client
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            discover_sensors(
+                start_time=datetime(2025, 1, 1),
+                end_time=datetime(2025, 1, 11),
+                schema="narrow",
+                show_progress=False,
+            )
+
+        # 10-day range with 7-day chunks = 2 chunks, each triggers at least 1 query
+        self.assertGreaterEqual(mock_client.query.call_count, 2)
+
+
 if __name__ == '__main__':
     unittest.main()