feast 0.67.0.dev105__tar.gz → 0.67.0.dev107__tar.gz

{feast-0.67.0.dev105 → feast-0.67.0.dev107}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: feast
-Version: 0.67.0.dev105
+Version: 0.67.0.dev107
 Summary: Python SDK for Feast
 Author: Feast
 License-Expression: Apache-2.0

{feast-0.67.0.dev105 → feast-0.67.0.dev107}/sdk/python/feast/feature_server.py

@@ -262,6 +262,8 @@ def _emit_online_audit(
     latency_ms: float,
 ):
     """Best-effort audit log emission for online feature requests."""
+    if not feast_metrics._config.audit_logging:
+        return
     try:
         from feast.permissions.security_manager import get_security_manager
 
@@ -686,9 +688,11 @@ def get_app(
                 include_feature_view_version_metadata=request.include_feature_view_version_metadata,
             )
 
-            audit_start_ms = time.monotonic() * 1000
+            audit_start_ms = 0.0
             audit_status = "success"
             try:
+                if feast_metrics._config.audit_logging:
+                    audit_start_ms = time.monotonic() * 1000
                 if store._get_provider().async_supported.online.read:
                     response = await store.get_online_features_async(**read_params)  # type: ignore
                 else:
@@ -699,10 +703,11 @@ def get_app(
                 audit_status = "error"
                 raise
             finally:
-                audit_latency_ms = time.monotonic() * 1000 - audit_start_ms
-                _emit_online_audit(
-                    request, features, entity_count, audit_status, audit_latency_ms
-                )
+                if feast_metrics._config.audit_logging:
+                    audit_latency_ms = time.monotonic() * 1000 - audit_start_ms
+                    _emit_online_audit(
+                        request, features, entity_count, audit_status, audit_latency_ms
+                    )
 
             response_dict = await run_in_threadpool(
                 convert_response_to_dict, response.proto

feast-0.67.0.dev107/sdk/python/feast/infra/data_sources/contrib/iceberg_catalog/tests/test_iceberg_offline_write.py

@@ -0,0 +1,273 @@
+"""Unit tests for IcebergSource offline_write_batch support.
+
+Tests that SparkOfflineStore and DuckDB _write_data_source correctly
+route IcebergSource writes through PyIceberg's catalog-aware append/overwrite
+API instead of raw file writes.
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pyarrow as pa
+import pytest
+
+from feast.infra.data_sources.contrib.iceberg_catalog.iceberg_source import (
+    IcebergSource,
+)
+
+
+@pytest.fixture
+def sample_arrow_table():
+    """A minimal Arrow table representing feature data."""
+    return pa.table(
+        {
+            "entity_id": pa.array([1, 2, 3]),
+            "feature_value": pa.array([10.0, 20.0, 30.0]),
+            "event_timestamp": pa.array(
+                ["2026-01-01T00:00:00", "2026-01-02T00:00:00", "2026-01-03T00:00:00"]
+            ),
+        }
+    )
+
+
+@pytest.fixture
+def iceberg_source():
+    """An IcebergSource with REST catalog for testing."""
+    return IcebergSource(
+        endpoint="http://localhost:8181",
+        warehouse="test_warehouse",
+        namespace="test_ns",
+        table="test_features",
+        catalog_type="rest",
+        catalog_name="feast_test",
+        timestamp_field="event_timestamp",
+    )
+
+
+@pytest.fixture
+def iceberg_source_hive():
+    """An IcebergSource with Hive catalog for testing."""
+    return IcebergSource(
+        catalog_type="hive",
+        warehouse="hive_warehouse",
+        namespace="hive_ns",
+        table="hive_features",
+        catalog_name="hive_catalog",
+        catalog_properties={"uri": "thrift://metastore:9083"},
+        timestamp_field="event_timestamp",
+    )
+
+
+class TestSparkOfflineStoreIcebergWrite:
+    """Tests for _iceberg_offline_write_batch in the Spark offline store."""
+
+    @patch(
+        "feast.infra.offline_stores.contrib.spark_offline_store.spark"
+        "._load_pyiceberg_table"
+    )
+    def test_append_calls_pyiceberg(
+        self, mock_load_table, iceberg_source, sample_arrow_table
+    ):
+        """Verify that IcebergSource write calls PyIceberg append()."""
+        from feast.infra.offline_stores.contrib.spark_offline_store.spark import (
+            _iceberg_offline_write_batch,
+        )
+
+        mock_iceberg_table = MagicMock()
+        mock_load_table.return_value = mock_iceberg_table
+
+        feature_view = MagicMock()
+        feature_view.batch_source = iceberg_source
+
+        config = MagicMock()
+
+        _iceberg_offline_write_batch(config, feature_view, sample_arrow_table)
+
+        mock_load_table.assert_called_once_with(iceberg_source)
+        mock_iceberg_table.append.assert_called_once_with(sample_arrow_table)
+
+    @patch(
+        "feast.infra.offline_stores.contrib.spark_offline_store.spark"
+        "._load_pyiceberg_table"
+    )
+    def test_passes_correct_data_source(
+        self, mock_load_table, iceberg_source_hive, sample_arrow_table
+    ):
+        """Verify Hive catalog IcebergSource is passed to _load_pyiceberg_table."""
+        from feast.infra.offline_stores.contrib.spark_offline_store.spark import (
+            _iceberg_offline_write_batch,
+        )
+
+        mock_iceberg_table = MagicMock()
+        mock_load_table.return_value = mock_iceberg_table
+
+        feature_view = MagicMock()
+        feature_view.batch_source = iceberg_source_hive
+
+        config = MagicMock()
+
+        _iceberg_offline_write_batch(config, feature_view, sample_arrow_table)
+
+        mock_load_table.assert_called_once_with(iceberg_source_hive)
+        mock_iceberg_table.append.assert_called_once()
+
+    @patch(
+        "feast.infra.offline_stores.contrib.spark_offline_store.spark"
+        "._load_pyiceberg_table"
+    )
+    def test_append_error_propagates(
+        self, mock_load_table, iceberg_source, sample_arrow_table
+    ):
+        """Verify that PyIceberg errors during append propagate."""
+        from feast.infra.offline_stores.contrib.spark_offline_store.spark import (
+            _iceberg_offline_write_batch,
+        )
+
+        mock_iceberg_table = MagicMock()
+        mock_iceberg_table.append.side_effect = RuntimeError("Catalog commit failed")
+        mock_load_table.return_value = mock_iceberg_table
+
+        feature_view = MagicMock()
+        feature_view.batch_source = iceberg_source
+
+        config = MagicMock()
+
+        with pytest.raises(RuntimeError, match="Catalog commit failed"):
+            _iceberg_offline_write_batch(config, feature_view, sample_arrow_table)
+
+    @patch(
+        "feast.infra.offline_stores.contrib.spark_offline_store.spark"
+        "._load_pyiceberg_table"
+    )
+    @patch(
+        "feast.infra.offline_stores.contrib.spark_offline_store.spark"
+        ".get_spark_session_or_start_new_with_repoconfig"
+    )
+    def test_offline_write_batch_dispatches_iceberg(
+        self,
+        mock_get_spark,
+        mock_load_table,
+        iceberg_source,
+        sample_arrow_table,
+    ):
+        """End-to-end: SparkOfflineStore.offline_write_batch dispatches to
+        _iceberg_offline_write_batch when batch_source is IcebergSource."""
+        from feast.infra.offline_stores.contrib.spark_offline_store.spark import (
+            SparkOfflineStore,
+            SparkOfflineStoreConfig,
+        )
+
+        mock_iceberg_table = MagicMock()
+        mock_load_table.return_value = mock_iceberg_table
+
+        feature_view = MagicMock()
+        feature_view.batch_source = iceberg_source
+
+        config = MagicMock()
+        config.offline_store = SparkOfflineStoreConfig()
+
+        SparkOfflineStore.offline_write_batch(
+            config, feature_view, sample_arrow_table, progress=None
+        )
+
+        mock_load_table.assert_called_once_with(iceberg_source)
+        mock_iceberg_table.append.assert_called_once_with(sample_arrow_table)
+        mock_get_spark.assert_not_called()
+
+    def test_offline_write_batch_rejects_non_spark_non_iceberg(self):
+        """SparkOfflineStore.offline_write_batch raises for unknown source types."""
+        from feast.infra.offline_stores.contrib.spark_offline_store.spark import (
+            SparkOfflineStore,
+            SparkOfflineStoreConfig,
+        )
+
+        feature_view = MagicMock()
+        feature_view.batch_source = MagicMock()
+        feature_view.batch_source.__class__ = type("UnknownSource", (), {})
+
+        config = MagicMock()
+        config.offline_store = SparkOfflineStoreConfig()
+
+        with pytest.raises(AssertionError):
+            SparkOfflineStore.offline_write_batch(
+                config,
+                feature_view,
+                pa.table({"a": [1]}),
+                progress=None,
+            )
+
+
+class TestDuckDBOfflineStoreIcebergWrite:
+    """Tests for _write_iceberg_data_source in the DuckDB offline store."""
+
+    @patch("feast.infra.offline_stores.duckdb._load_pyiceberg_table_for_write")
+    def test_append_mode(self, mock_load_table, iceberg_source, sample_arrow_table):
+        """Verify append mode calls iceberg_table.append()."""
+        from feast.infra.offline_stores.duckdb import _write_iceberg_data_source
+
+        mock_iceberg_table = MagicMock()
+        mock_load_table.return_value = mock_iceberg_table
+
+        import ibis
+
+        ibis_table = ibis.memtable(sample_arrow_table)
+
+        _write_iceberg_data_source(ibis_table, iceberg_source, mode="append")
+
+        mock_load_table.assert_called_once_with(iceberg_source)
+        mock_iceberg_table.append.assert_called_once()
+        mock_iceberg_table.overwrite.assert_not_called()
+
+    @patch("feast.infra.offline_stores.duckdb._load_pyiceberg_table_for_write")
+    def test_overwrite_mode(self, mock_load_table, iceberg_source, sample_arrow_table):
+        """Verify overwrite mode calls iceberg_table.overwrite()."""
+        from feast.infra.offline_stores.duckdb import _write_iceberg_data_source
+
+        mock_iceberg_table = MagicMock()
+        mock_load_table.return_value = mock_iceberg_table
+
+        import ibis
+
+        ibis_table = ibis.memtable(sample_arrow_table)
+
+        _write_iceberg_data_source(ibis_table, iceberg_source, mode="overwrite")
+
+        mock_load_table.assert_called_once_with(iceberg_source)
+        mock_iceberg_table.overwrite.assert_called_once()
+        mock_iceberg_table.append.assert_not_called()
+
+    @patch("feast.infra.offline_stores.duckdb._load_pyiceberg_table_for_write")
+    def test_write_data_source_dispatches_iceberg(
+        self, mock_load_table, iceberg_source, sample_arrow_table
+    ):
+        """_write_data_source dispatches to _write_iceberg_data_source for IcebergSource."""
+        from feast.infra.offline_stores.duckdb import _write_data_source
+
+        mock_iceberg_table = MagicMock()
+        mock_load_table.return_value = mock_iceberg_table
+
+        import ibis
+
+        ibis_table = ibis.memtable(sample_arrow_table)
+
+        _write_data_source(ibis_table, iceberg_source, repo_path="/tmp/repo")
+
+        mock_load_table.assert_called_once_with(iceberg_source)
+        mock_iceberg_table.append.assert_called_once()
+
+    @patch("feast.infra.offline_stores.duckdb._load_pyiceberg_table_for_write")
+    def test_error_propagates(
+        self, mock_load_table, iceberg_source, sample_arrow_table
+    ):
+        """Verify that PyIceberg errors propagate through DuckDB path."""
+        from feast.infra.offline_stores.duckdb import _write_iceberg_data_source
+
+        mock_iceberg_table = MagicMock()
+        mock_iceberg_table.append.side_effect = RuntimeError("Schema mismatch")
+        mock_load_table.return_value = mock_iceberg_table
+
+        import ibis
+
+        ibis_table = ibis.memtable(sample_arrow_table)
+
+        with pytest.raises(RuntimeError, match="Schema mismatch"):
+            _write_iceberg_data_source(ibis_table, iceberg_source)

{feast-0.67.0.dev105 → feast-0.67.0.dev107}/sdk/python/feast/infra/offline_stores/contrib/spark_offline_store/spark.py

@@ -361,7 +361,16 @@ class SparkOfflineStore(OfflineStore):
         table: pyarrow.Table,
         progress: Optional[Callable[[int], Any]],
     ):
+        from feast.infra.data_sources.contrib.iceberg_catalog.iceberg_source import (
+            IcebergSource,
+        )
+
         assert isinstance(config.offline_store, SparkOfflineStoreConfig)
+
+        if isinstance(feature_view.batch_source, IcebergSource):
+            _iceberg_offline_write_batch(config, feature_view, table)
+            return
+
         assert isinstance(feature_view.batch_source, SparkSource)
 
         pa_schema, column_names = offline_utils.get_pyarrow_schema_from_batch_source(
@@ -1275,6 +1284,28 @@ def _load_pyiceberg_table(data_source: "DataSource"):
     return catalog.load_table(fqn)
 
 
+def _iceberg_offline_write_batch(
+    config: "RepoConfig",
+    feature_view: "FeatureView",
+    table: "pyarrow.Table",
+) -> None:
+    """Write a PyArrow table to an IcebergSource via PyIceberg.
+
+    Uses PyIceberg's append() API which produces proper Iceberg snapshots,
+    handles schema evolution, and updates catalog metadata — making the
+    written data discoverable via any Iceberg-compatible engine.
+    """
+    from feast.infra.data_sources.contrib.iceberg_catalog.iceberg_source import (
+        IcebergSource,
+    )
+
+    assert isinstance(feature_view.batch_source, IcebergSource)
+    data_source: IcebergSource = feature_view.batch_source
+
+    iceberg_table = _load_pyiceberg_table(data_source)
+    iceberg_table.append(table)
+
+
 def _pull_from_iceberg_source(
     spark_session: SparkSession,
     data_source: "DataSource",

{feast-0.67.0.dev105 → feast-0.67.0.dev107}/sdk/python/feast/infra/offline_stores/duckdb.py

@@ -126,6 +126,52 @@ def _read_iceberg_catalog_source(data_source: "IcebergSource", repo_path: str) -
     return ibis.memtable(table.scan().to_arrow())
 
 
+def _load_pyiceberg_table_for_write(data_source: "IcebergSource"):
+    """Load a PyIceberg table object for write operations.
+
+    Reuses the same catalog resolution logic as ``_read_iceberg_catalog_source``
+    but returns the raw PyIceberg table instead of an ibis memtable, so the
+    caller can use ``table.append()`` or ``table.overwrite()`` for writes.
+    """
+    fqn = f"{data_source.namespace}.{data_source.iceberg_table}"
+
+    if data_source.catalog_type != "rest":
+        catalog_client = data_source.get_catalog_client()
+        return catalog_client.load_table(fqn)
+
+    from pyiceberg.catalog import load_catalog
+
+    catalog_config: dict = {
+        "type": "rest",
+        "uri": data_source.endpoint,
+        "warehouse": data_source.warehouse,
+    }
+    if data_source.token_env_var:
+        token = os.environ.get(data_source.token_env_var)
+        if token:
+            catalog_config["token"] = token
+    catalog = load_catalog(data_source.catalog_name, **catalog_config)
+    return catalog.load_table(fqn)
+
+
+def _write_iceberg_data_source(
+    table: Table,
+    data_source: "IcebergSource",
+    mode: str = "append",
+) -> None:
+    """Write an ibis table to an IcebergSource via PyIceberg.
+
+    Converts the ibis table to Arrow and uses PyIceberg's append/overwrite
+    API to produce proper Iceberg snapshots with catalog metadata updates.
+    """
+    iceberg_table = _load_pyiceberg_table_for_write(data_source)
+    arrow_table = table.to_pyarrow()
+    if mode == "overwrite":
+        iceberg_table.overwrite(arrow_table)
+    else:
+        iceberg_table.append(arrow_table)
+
+
 def _write_data_source(
     table: Table,
     data_source: DataSource,
@@ -133,6 +179,14 @@ def _write_data_source(
     mode: str = "append",
     allow_overwrite: bool = False,
 ):
+    from feast.infra.data_sources.contrib.iceberg_catalog.iceberg_source import (
+        IcebergSource,
+    )
+
+    if isinstance(data_source, IcebergSource):
+        _write_iceberg_data_source(table, data_source, mode)
+        return
+
     assert isinstance(data_source, FileSource)
 
     file_options = data_source.file_options

{feast-0.67.0.dev105 → feast-0.67.0.dev107}/sdk/python/feast/utils.py

@@ -1829,6 +1829,7 @@ def _populate_response_from_feature_data(
     feat_statuses = [[NOT_FOUND] * output_len for _ in range(n_features)]
 
     feat_idx_map = {name: i for i, name in enumerate(requested_features)}
+    _present_count = 0
     for row_idx, destinations in enumerate(indexes_tuple):
         _, feature_data = read_rows[row_idx]
         if feature_data is None:
@@ -1839,13 +1840,13 @@ def _populate_response_from_feature_data(
                 for out_idx in destinations:
                     feat_values[f_idx][out_idx] = feat_val
                     feat_statuses[f_idx][out_idx] = PRESENT
+                    _present_count += 1
 
     try:
         from feast.metrics import track_feature_statuses
 
-        _present = sum(s == PRESENT for row in feat_statuses for s in row)
-        _not_found = (n_features * output_len) - _present
-        track_feature_statuses(table.name, _present, _not_found)
+        _not_found = (n_features * output_len) - _present_count
+        track_feature_statuses(table.name, _present_count, _not_found)
     except Exception:
         pass
 

{feast-0.67.0.dev105 → feast-0.67.0.dev107}/sdk/python/feast.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: feast
-Version: 0.67.0.dev105
+Version: 0.67.0.dev107
 Summary: Python SDK for Feast
 Author: Feast
 License-Expression: Apache-2.0

{feast-0.67.0.dev105 → feast-0.67.0.dev107}/sdk/python/feast.egg-info/SOURCES.txt

@@ -539,6 +539,7 @@ sdk/python/feast/infra/data_sources/contrib/iceberg_catalog/unity_catalog_source
 sdk/python/feast/infra/data_sources/contrib/iceberg_catalog/tests/__init__.py
 sdk/python/feast/infra/data_sources/contrib/iceberg_catalog/tests/data_source.py
 sdk/python/feast/infra/data_sources/contrib/iceberg_catalog/tests/test_iceberg_duckdb.py
+sdk/python/feast/infra/data_sources/contrib/iceberg_catalog/tests/test_iceberg_offline_write.py
 sdk/python/feast/infra/data_sources/contrib/iceberg_catalog/tests/test_iceberg_source.py
 sdk/python/feast/infra/data_sources/contrib/iceberg_catalog/tests/test_iceberg_spark.py
 sdk/python/feast/infra/feature_servers/__init__.py