fix: Infer entity value types from dbt column types

When creating entities from dbt models with integer columns, entities were
being created with default ValueType.STRING, causing validation errors:
"Entity X has type ValueType.STRING, which does not match the inferred type Int64"

Solution: Added mapping dict and helper function for clean type conversion:
- FEAST_TYPE_TO_VALUE_TYPE: Maps FeastType to ValueType
- feast_type_to_value_type(): Helper function for conversion
- _infer_entity_value_type(): Method in DbtToFeastMapper class

This replaces verbose if-else chains with a clean dictionary lookup pattern.

Also corrects schema generation to include entity columns, as FeatureView.__init__
expects to extract entity columns from the schema itself.

Signed-off-by: yassinnouh21 <[email protected]>

Author: YassinNouh21

sdk/python/feast/cli/dbt_import.py

@@ -225,27 +225,8 @@ def import_command(
         model_entities: List[Any] = []
         for entity_col in entity_cols:
             if entity_col not in entities_created:
-                # Infer entity value type from model column
-                from feast.types import String, Int32, Int64, Float32, Float64, Bool
-                from feast.value_type import ValueType
-                from feast.dbt.mapper import map_dbt_type_to_feast_type
-
-                entity_value_type = ValueType.UNKNOWN
-                for column in model.columns:
-                    if column.name == entity_col:
-                        feast_type = map_dbt_type_to_feast_type(column.data_type)
-                        if feast_type == String:
-                            entity_value_type = ValueType.STRING
-                        elif feast_type in [Int32, Int64]:
-                            entity_value_type = ValueType.INT64
-                        elif feast_type in [Float32, Float64]:
-                            entity_value_type = ValueType.DOUBLE
-                        elif feast_type == Bool:
-                            entity_value_type = ValueType.BOOL
-                        else:
-                            entity_value_type = ValueType.STRING
-                        break
-
+                # Use mapper's internal method for value type inference
+                entity_value_type = mapper._infer_entity_value_type(model, entity_col)
                 entity = mapper.create_entity(
                     name=entity_col,
                     description="Entity key for dbt models",

sdk/python/feast/dbt/mapper.py

@@ -26,6 +26,24 @@
 )
 from feast.value_type import ValueType
 
+# Mapping from FeastType to ValueType for entity value inference
+FEAST_TYPE_TO_VALUE_TYPE: Dict[FeastType, ValueType] = {
+    String: ValueType.STRING,
+    Int32: ValueType.INT64,
+    Int64: ValueType.INT64,
+    Float32: ValueType.DOUBLE,
+    Float64: ValueType.DOUBLE,
+    Bool: ValueType.BOOL,
+    Bytes: ValueType.BYTES,
+    UnixTimestamp: ValueType.UNIX_TIMESTAMP,
+}
+
+
+def feast_type_to_value_type(feast_type: FeastType) -> ValueType:
+    """Convert a FeastType to its corresponding ValueType for entities."""
+    return FEAST_TYPE_TO_VALUE_TYPE.get(feast_type, ValueType.STRING)
+
+
 # Comprehensive mapping from dbt/warehouse types to Feast types
 # Covers BigQuery, Snowflake, Redshift, PostgreSQL, and common SQL types
 DBT_TO_FEAST_TYPE_MAP: Dict[str, FeastType] = {
@@ -180,6 +198,14 @@ def __init__(
         self.timestamp_field = timestamp_field
         self.ttl_days = ttl_days
 
+    def _infer_entity_value_type(self, model: DbtModel, entity_col: str) -> ValueType:
+        """Infer entity ValueType from dbt model column type."""
+        for column in model.columns:
+            if column.name == entity_col:
+                feast_type = map_dbt_type_to_feast_type(column.data_type)
+                return feast_type_to_value_type(feast_type)
+        return ValueType.UNKNOWN
+
     def create_data_source(
         self,
         model: DbtModel,
@@ -357,23 +383,7 @@ def create_feature_view(
             entity_objs = []
             for entity_col in entity_cols:
                 # Infer entity value type from model column
-                entity_value_type = ValueType.UNKNOWN
-                for column in model.columns:
-                    if column.name == entity_col:
-                        feast_type = map_dbt_type_to_feast_type(column.data_type)
-                        # Convert Feast type to ValueType
-                        if feast_type == String:
-                            entity_value_type = ValueType.STRING
-                        elif feast_type in [Int32, Int64]:
-                            entity_value_type = ValueType.INT64
-                        elif feast_type in [Float32, Float64]:
-                            entity_value_type = ValueType.DOUBLE
-                        elif feast_type == Bool:
-                            entity_value_type = ValueType.BOOL
-                        else:
-                            entity_value_type = ValueType.STRING
-                        break
-
+                entity_value_type = self._infer_entity_value_type(model, entity_col)
                 ent = self.create_entity(
                     name=entity_col,
                     description=f"Entity for {model.name}",
@@ -436,24 +446,7 @@ def create_all_from_model(
         # Create entities (plural)
         entities_list = []
         for entity_col in entity_cols:
-            # Infer entity value type from model column
-            entity_value_type = ValueType.UNKNOWN
-            for column in model.columns:
-                if column.name == entity_col:
-                    feast_type = map_dbt_type_to_feast_type(column.data_type)
-                    # Convert Feast type to ValueType
-                    if feast_type == String:
-                        entity_value_type = ValueType.STRING
-                    elif feast_type in [Int32, Int64]:
-                        entity_value_type = ValueType.INT64
-                    elif feast_type in [Float32, Float64]:
-                        entity_value_type = ValueType.DOUBLE
-                    elif feast_type == Bool:
-                        entity_value_type = ValueType.BOOL
-                    else:
-                        entity_value_type = ValueType.STRING
-                    break
-
+            entity_value_type = self._infer_entity_value_type(model, entity_col)
             entity = self.create_entity(
                 name=entity_col,
                 description=f"Entity for {model.name}",

sdk/python/tests/integration/dbt/__init__.py

@@ -0,0 +1 @@
+"""dbt integration tests."""

sdk/python/tests/integration/dbt/conftest.py

@@ -0,0 +1,32 @@
+"""
+Conftest for dbt integration tests.
+
+This is a standalone conftest that doesn't depend on the main Feast test infrastructure.
+"""
+
+from pathlib import Path
+
+import pytest
+
+# This conftest is minimal and doesn't import the main feast conftest
+# to avoid complex dependency chains for dbt-specific tests
+
+# Path to the test dbt project manifest
+TEST_DBT_PROJECT_DIR = Path(__file__).parent / "test_dbt_project"
+TEST_MANIFEST_PATH = TEST_DBT_PROJECT_DIR / "target" / "manifest.json"
+
+
+def pytest_collection_modifyitems(config, items):  # noqa: ARG001
+    """
+    Skip dbt integration tests if manifest.json doesn't exist.
+
+    These tests require running 'dbt build' first to generate the manifest.
+    The dbt-integration-test workflow handles this, but regular unit test
+    runs don't, so we skip them to avoid failures.
+    """
+    if not TEST_MANIFEST_PATH.exists():
+        skip_marker = pytest.mark.skip(
+            reason="dbt manifest.json not found - run 'dbt build' first or use dbt-integration-test workflow"
+        )
+        for item in items:
+            item.add_marker(skip_marker)

sdk/python/tests/integration/dbt/pytest.ini

@@ -0,0 +1,9 @@
+[pytest]
+# Prevent loading parent conftest.py files which may import heavy dependencies
+# like ray that are not needed for dbt integration tests
+norecursedirs = ..
+asyncio_mode = auto
+
+# Test markers
+markers =
+    dbt: dbt integration tests