Minor reformatting & lint changes

Signed-off-by: Aniket Paluskar <[email protected]>

Author: aniketpalu

sdk/python/feast/feature_store.py

@@ -1896,19 +1896,21 @@ def write_to_online_store(
             allow_registry_cache=allow_registry_cache,
             transform_on_write=transform_on_write,
         )
-        
+
         # Validate that the dataframe has meaningful feature data
         if df is not None:
             if df.empty:
                 raise ValueError("Cannot write empty dataframe to online store")
-            
+
             # Check if feature columns are empty (entity columns may have data but feature columns are empty)
             feature_column_names = [f.name for f in feature_view.features]
             if feature_column_names:
                 feature_df = df[feature_column_names]
                 if feature_df.empty or feature_df.isnull().all().all():
-                    raise ValueError("Cannot write dataframe with empty feature columns to online store")
-        
+                    raise ValueError(
+                        "Cannot write dataframe with empty feature columns to online store"
+                    )
+
         provider = self._get_provider()
         provider.ingest_df(feature_view, df)
 
@@ -1938,19 +1940,21 @@ async def write_to_online_store_async(
             inputs=inputs,
             allow_registry_cache=allow_registry_cache,
         )
-        
+
         # Validate that the dataframe has meaningful feature data
         if df is not None:
             if df.empty:
                 raise ValueError("Cannot write empty dataframe to online store")
-            
+
             # Check if feature columns are empty (entity columns may have data but feature columns are empty)
             feature_column_names = [f.name for f in feature_view.features]
             if feature_column_names:
                 feature_df = df[feature_column_names]
                 if feature_df.empty or feature_df.isnull().all().all():
-                    raise ValueError("Cannot write dataframe with empty feature columns to online store")
-        
+                    raise ValueError(
+                        "Cannot write dataframe with empty feature columns to online store"
+                    )
+
         provider = self._get_provider()
         await provider.ingest_df_async(feature_view, df)
 

sdk/python/tests/unit/online_store/test_online_writes.py

@@ -175,13 +175,9 @@ def setUp(self):
         start_date = end_date - timedelta(days=1)
 
         driver_entities = [1001]
-        driver_df = create_driver_hourly_stats_df(
-            driver_entities, start_date, end_date
-        )
+        driver_df = create_driver_hourly_stats_df(driver_entities, start_date, end_date)
         driver_stats_path = os.path.join(self.data_dir, "driver_stats.parquet")
-        driver_df.to_parquet(
-            path=driver_stats_path, allow_truncated_timestamps=True
-        )
+        driver_df.to_parquet(path=driver_stats_path, allow_truncated_timestamps=True)
 
         driver = Entity(name="driver", join_keys=["driver_id"])
 
@@ -209,90 +205,107 @@ def setUp(self):
 
     def tearDown(self):
         import shutil
+
         shutil.rmtree(self.data_dir)
 
     def test_empty_dataframe_raises_error(self):
         """Test that completely empty dataframe raises ValueError"""
         empty_df = pd.DataFrame()
-        
+
         with self.assertRaises(ValueError) as context:
             self.store.write_to_online_store(
                 feature_view_name="driver_hourly_stats", df=empty_df
             )
-        
-        self.assertIn("Cannot write empty dataframe to online store", str(context.exception))
+
+        self.assertIn(
+            "Cannot write empty dataframe to online store", str(context.exception)
+        )
 
     def test_empty_dataframe_async_raises_error(self):
         """Test that completely empty dataframe raises ValueError in async version"""
         import asyncio
-        
+
         async def test_async_empty():
             empty_df = pd.DataFrame()
-            
+
             with self.assertRaises(ValueError) as context:
                 await self.store.write_to_online_store_async(
                     feature_view_name="driver_hourly_stats", df=empty_df
                 )
-            
-            self.assertIn("Cannot write empty dataframe to online store", str(context.exception))
-        
+
+            self.assertIn(
+                "Cannot write empty dataframe to online store", str(context.exception)
+            )
+
         asyncio.run(test_async_empty())
 
     def test_dataframe_with_empty_feature_columns_raises_error(self):
         """Test that dataframe with entity data but empty feature columns raises ValueError"""
         current_time = pd.Timestamp.now()
-        df_with_entity_only = pd.DataFrame({
-            "driver_id": [1001, 1002, 1003],
-            "event_timestamp": [current_time] * 3,
-            "created": [current_time] * 3,
-            "conv_rate": [None, None, None],  # All nulls
-            "acc_rate": [None, None, None],   # All nulls
-            "avg_daily_trips": [None, None, None]  # All nulls
-        })
-        
+        df_with_entity_only = pd.DataFrame(
+            {
+                "driver_id": [1001, 1002, 1003],
+                "event_timestamp": [current_time] * 3,
+                "created": [current_time] * 3,
+                "conv_rate": [None, None, None],  # All nulls
+                "acc_rate": [None, None, None],  # All nulls
+                "avg_daily_trips": [None, None, None],  # All nulls
+            }
+        )
+
         with self.assertRaises(ValueError) as context:
             self.store.write_to_online_store(
                 feature_view_name="driver_hourly_stats", df=df_with_entity_only
             )
-        
-        self.assertIn("Cannot write dataframe with empty feature columns to online store", str(context.exception))
+
+        self.assertIn(
+            "Cannot write dataframe with empty feature columns to online store",
+            str(context.exception),
+        )
 
     def test_dataframe_with_empty_feature_columns_async_raises_error(self):
         """Test that dataframe with entity data but empty feature columns raises ValueError in async version"""
         import asyncio
-        
+
         async def test_async_empty_features():
             current_time = pd.Timestamp.now()
-            df_with_entity_only = pd.DataFrame({
-                "driver_id": [1001, 1002, 1003],
-                "event_timestamp": [current_time] * 3,
-                "created": [current_time] * 3,
-                "conv_rate": [None, None, None],
-                "acc_rate": [None, None, None],
-                "avg_daily_trips": [None, None, None]
-            })
-            
+            df_with_entity_only = pd.DataFrame(
+                {
+                    "driver_id": [1001, 1002, 1003],
+                    "event_timestamp": [current_time] * 3,
+                    "created": [current_time] * 3,
+                    "conv_rate": [None, None, None],
+                    "acc_rate": [None, None, None],
+                    "avg_daily_trips": [None, None, None],
+                }
+            )
+
             with self.assertRaises(ValueError) as context:
                 await self.store.write_to_online_store_async(
                     feature_view_name="driver_hourly_stats", df=df_with_entity_only
                 )
-            
-            self.assertIn("Cannot write dataframe with empty feature columns to online store", str(context.exception))
-        
+
+            self.assertIn(
+                "Cannot write dataframe with empty feature columns to online store",
+                str(context.exception),
+            )
+
         asyncio.run(test_async_empty_features())
 
     def test_valid_dataframe(self):
         """Test that valid dataframe with feature data succeeds"""
         current_time = pd.Timestamp.now()
-        valid_df = pd.DataFrame({
-            "driver_id": [1001, 1002],
-            "event_timestamp": [current_time] * 2,
-            "created": [current_time] * 2,
-            "conv_rate": [0.5, 0.7],
-            "acc_rate": [0.8, 0.9],
-            "avg_daily_trips": [10, 12]
-        })
-        
+        valid_df = pd.DataFrame(
+            {
+                "driver_id": [1001, 1002],
+                "event_timestamp": [current_time] * 2,
+                "created": [current_time] * 2,
+                "conv_rate": [0.5, 0.7],
+                "acc_rate": [0.8, 0.9],
+                "avg_daily_trips": [10, 12],
+            }
+        )
+
         # This should not raise an exception
         self.store.write_to_online_store(
             feature_view_name="driver_hourly_stats", df=valid_df
@@ -301,40 +314,45 @@ def test_valid_dataframe(self):
     def test_valid_dataframe_async(self):
         """Test that valid dataframe with feature data succeeds in async version"""
         import asyncio
+
         import pytest
-        
+
         pytest.skip("Feature not implemented yet")
-        
+
         async def test_async_valid():
             current_time = pd.Timestamp.now()
-            valid_df = pd.DataFrame({
-                "driver_id": [1001, 1002],
-                "event_timestamp": [current_time] * 2,
-                "created": [current_time] * 2,
-                "conv_rate": [0.5, 0.7],
-                "acc_rate": [0.8, 0.9],
-                "avg_daily_trips": [10, 12]
-            })
-            
+            valid_df = pd.DataFrame(
+                {
+                    "driver_id": [1001, 1002],
+                    "event_timestamp": [current_time] * 2,
+                    "created": [current_time] * 2,
+                    "conv_rate": [0.5, 0.7],
+                    "acc_rate": [0.8, 0.9],
+                    "avg_daily_trips": [10, 12],
+                }
+            )
+
             # This should not raise an exception
             await self.store.write_to_online_store_async(
                 feature_view_name="driver_hourly_stats", df=valid_df
             )
-        
+
         asyncio.run(test_async_valid())
 
     def test_mixed_dataframe_with_some_valid_features(self):
         """Test that dataframe with some valid feature values succeeds"""
         current_time = pd.Timestamp.now()
-        mixed_df = pd.DataFrame({
-            "driver_id": [1001, 1002, 1003],
-            "event_timestamp": [current_time] * 3,
-            "created": [current_time] * 3,
-            "conv_rate": [0.5, None, 0.7],  # Mixed values
-            "acc_rate": [0.8, 0.9, None],   # Mixed values
-            "avg_daily_trips": [10, 12, 15]  # All valid
-        })
-        
+        mixed_df = pd.DataFrame(
+            {
+                "driver_id": [1001, 1002, 1003],
+                "event_timestamp": [current_time] * 3,
+                "created": [current_time] * 3,
+                "conv_rate": [0.5, None, 0.7],  # Mixed values
+                "acc_rate": [0.8, 0.9, None],  # Mixed values
+                "avg_daily_trips": [10, 12, 15],  # All valid
+            }
+        )
+
         # This should not raise an exception because not all feature values are null
         self.store.write_to_online_store(
             feature_view_name="driver_hourly_stats", df=mixed_df
@@ -346,15 +364,17 @@ def test_empty_inputs_dict_raises_error(self):
             "driver_id": [],
             "conv_rate": [],
             "acc_rate": [],
-            "avg_daily_trips": []
+            "avg_daily_trips": [],
         }
-        
+
         with self.assertRaises(ValueError) as context:
             self.store.write_to_online_store(
                 feature_view_name="driver_hourly_stats", inputs=empty_inputs
             )
-        
-        self.assertIn("Cannot write empty dataframe to online store", str(context.exception))
+
+        self.assertIn(
+            "Cannot write empty dataframe to online store", str(context.exception)
+        )
 
     def test_inputs_dict_with_empty_features_raises_error(self):
         """Test that inputs dict with empty feature values raises ValueError"""
@@ -365,15 +385,18 @@ def test_inputs_dict_with_empty_features_raises_error(self):
             "created": [current_time] * 3,
             "conv_rate": [None, None, None],
             "acc_rate": [None, None, None],
-            "avg_daily_trips": [None, None, None]
+            "avg_daily_trips": [None, None, None],
         }
-        
+
         with self.assertRaises(ValueError) as context:
             self.store.write_to_online_store(
                 feature_view_name="driver_hourly_stats", inputs=empty_feature_inputs
             )
-        
-        self.assertIn("Cannot write dataframe with empty feature columns to online store", str(context.exception))
+
+        self.assertIn(
+            "Cannot write dataframe with empty feature columns to online store",
+            str(context.exception),
+        )
 
 
 class TestOnlineWritesWithTransform(unittest.TestCase):