chalkpy 2.89.22__py3-none-any.whl → 2.95.3__py3-none-any.whl

chalk/ml/model_version.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
 from datetime import datetime
-from typing import Any, List
+from typing import TYPE_CHECKING, Any
 
-from chalk.ml.model_hooks import MODEL_HOOKS, PREDICT_HOOKS
-from chalk.ml.utils import ModelEncoding, ModelType
+from chalk.ml.model_hooks import MODEL_REGISTRY
+from chalk.ml.utils import ModelClass, ModelEncoding, ModelType
+
+if TYPE_CHECKING:
+    from chalk.features.resolver import ResourceHint
 
 
 class ModelVersion:
@@ -18,8 +21,10 @@ class ModelVersion:
         identifier: str | None = None,
         model_type: ModelType | None = None,
         model_encoding: ModelEncoding | None = None,
-        model_class: str | None = None,
+        model_class: ModelClass | None = None,
         filename: str | None = None,
+        resource_hint: "ResourceHint | None" = None,
+        resource_group: str | None = None,
     ):
         """Specifies the model version that should be loaded into the deployment.
 
@@ -41,9 +46,11 @@ class ModelVersion:
         self.model_encoding = model_encoding
         self.model_class = model_class
         self.filename = filename
+        self.resource_hint: "ResourceHint | None" = resource_hint
+        self.resource_group = resource_group
 
         self._model = None
-        self._predict_fn = None
+        self._predictor = None
 
     def get_model_file(self) -> str | None:
         """Returns the filename of the model."""
@@ -54,26 +61,19 @@ class ModelVersion:
     def load_model(self):
         """Loads the model from the specified filename using the appropriate hook."""
         if self.model_type and self.model_encoding:
-            load_function = MODEL_HOOKS.get((self.model_type, self.model_encoding, self.model_class))
-            if load_function is not None and self.filename is not None:
-                self._model = load_function(self.filename)
+            model = MODEL_REGISTRY.get(
+                model_type=self.model_type, encoding=self.model_encoding, model_class=self.model_class
+            )
+            if model is not None and self.filename is not None:
+                self._model = model.load_model(self.filename, resource_hint=self.resource_hint)
             else:
                 raise ValueError(
-                    f"No load function defined for type {self.model_type} and extension {self.model_encoding}"
+                    f"No load function defined for type {self.model_type}, encoding {self.model_encoding}, and class {self.model_class}"
                 )
 
-    def predict(self, X: List[List[float]]):
-        """Loads the model from the specified filename using the appropriate hook."""
-
-        if self._predict_fn is None:
-            if self.model_type is None or self.model_encoding is None:
-                raise ValueError("Model type and encoding must be specified to use predict.")
-            self._predict_fn = PREDICT_HOOKS.get((self.model_type, self.model_encoding, self.model_class), None)
-            if self._predict_fn is None:
-                raise ValueError(
-                    f"No predict function defined for type {self.model_type} and extension {self.model_encoding}"
-                )
-        return self._predict_fn(self.model, X)
+    def predict(self, X: Any):
+        """Runs prediction using the loaded model."""
+        return self.predictor.predict(self.model, X)
 
     @property
     def model(self) -> Any:
@@ -82,3 +82,16 @@ class ModelVersion:
             self.load_model()
 
         return self._model
+
+    @property
+    def predictor(self) -> Any:
+        """Returns the predictor instance, initializing it if needed."""
+        if self._predictor is None:
+            if self.model_type is None or self.model_encoding is None:
+                raise ValueError("Model type and encoding must be specified to use predictor.")
+            self._predictor = MODEL_REGISTRY.get(
+                model_type=self.model_type, encoding=self.model_encoding, model_class=self.model_class
+            )
+            if self._predictor is None:
+                raise ValueError(f"No predictor defined for type {self.model_type} and encoding {self.model_encoding}")
+        return self._predictor

chalk/ml/utils.py

@@ -2,23 +2,33 @@ import os
 from dataclasses import dataclass
 from enum import Enum
 from functools import cache
-from typing import Literal, Mapping, Tuple
+from typing import Literal, Mapping, Optional, Tuple
 
 import pyarrow as pa
 
 import chalk._gen.chalk.models.v1.model_artifact_pb2 as pb
 import chalk._gen.chalk.models.v1.model_version_pb2 as mv_pb
 
-REGISTRY_METADATA_FILE = os.getenv("CHALK_MODEL_REGISTRY_METADATA_FILENAME", None)
+
+def get_registry_metadata_file() -> Optional[str]:
+    branch_root = os.getenv("CHALK_MODEL_REGISTRY_BRANCH_METADATA_ROOT", None)
+    if os.getenv("IS_BRANCH", None) is not None and branch_root is not None:
+        return os.path.join(branch_root, os.getenv("CHALK_DEPLOYMENT_ID", "") + ".bin")
+    return os.getenv("CHALK_MODEL_REGISTRY_METADATA_FILENAME", None)
+
+
 CHALK_MODEL_REGISTRY_ROOT = os.getenv("CHALK_MODEL_REGISTRY_ROOT", "/models")
 
 MODEL_METADATA_PREFIX = "__chalk_model__"
 
 MODEL_TRAIN_METADATA_RUN_NAME = f"{MODEL_METADATA_PREFIX}run_name__"
+MODEL_TRAIN_RUN_NAME_ENV_VAR = "CHALK_MODEL_TRAIN_RUN_NAME"
+
+MODEL_TRAIN_METADATA_RUN_ID = f"{MODEL_METADATA_PREFIX}run_id__"
 
 
 def get_model_metadata_run_name_from_env():
-    return os.getenv("MODEL_TRAIN_RUN_NAME", "")
+    return os.getenv(MODEL_TRAIN_RUN_NAME_ENV_VAR, "")
 
 
 class ModelType(str, Enum):
@@ -42,6 +52,14 @@ class ModelEncoding(str, Enum):
     SAFETENSOR = "MODEL_ENCODING_SAFETENSORS"
 
 
+class ModelClass(str, Enum):
+    CLASSIFICATION = "classification"
+    REGRESSION = "regression"
+    CLUSTERING = "clustering"
+    DIMENSIONALITY_REDUCTION = "dimensionality_reduction"
+    EMBEDDING = "embedding"
+
+
 @dataclass
 class ModelRunCriterion:
     direction: Literal["max", "min"]
@@ -66,11 +84,12 @@ def load_model_map() -> Mapping[Tuple[str, str], LoadedModel]:
     model_map: dict[Tuple[str, str], LoadedModel] = {}
 
     try:
-        if REGISTRY_METADATA_FILE is not None:
-            with open(REGISTRY_METADATA_FILE, "rb") as f:
+        registry_metadata_file = get_registry_metadata_file()
+        if registry_metadata_file is not None:
+            with open(registry_metadata_file, "rb") as f:
                 mms.ParseFromString(f.read())
     except FileNotFoundError:
-        raise FileNotFoundError(f"Model registry metadata file not found: {REGISTRY_METADATA_FILE}")
+        raise FileNotFoundError(f"Model registry metadata file not found: {registry_metadata_file}")
     except Exception as e:
         raise RuntimeError(f"Failed to load model map: {e}")
 
@@ -309,13 +328,104 @@ class ModelAttributeExtractor:
         return input_schema, output_schema
 
     @staticmethod
-    def infer_model_type(model: Any) -> Optional[ModelType]:
+    def infer_catboost_schemas(
+        model: Any,
+    ) -> Tuple[Optional[List[Tuple[List[int], Any]]], Optional[List[Tuple[List[int], Any]]]]:
+        input_schema: Optional[List[Tuple[List[int], Any]]] = None
+        output_schema: Optional[List[Tuple[List[int], Any]]] = None
+
+        try:
+            n_features = None
+
+            # CatBoost uses feature_names_ or can query from get_feature_importance
+            if hasattr(model, "feature_names_") and model.feature_names_ is not None:
+                n_features = len(model.feature_names_)
+            elif hasattr(model, "n_features_in_"):
+                n_features = model.n_features_in_
+            elif hasattr(model, "get_feature_importance"):
+                # Try to get feature count from the model's tree structure
+                try:
+                    feature_importances = model.get_feature_importance()
+                    if feature_importances is not None:
+                        n_features = len(feature_importances)
+                except Exception:
+                    pass
+
+            if n_features is not None:
+                input_schema = [([n_features], pa.float64())]
+
+            # Determine output schema based on model type
+            # CatBoost has is_fitted() and can check the model type
+            if hasattr(model, "_estimator_type"):
+                if model._estimator_type == "classifier":
+                    n_classes = None
+                    if hasattr(model, "classes_") and model.classes_ is not None:
+                        n_classes = len(model.classes_)
+
+                    if n_classes is not None:
+                        if n_classes == 2:
+                            output_schema = [([1], pa.float64())]
+                        else:
+                            output_schema = [([n_classes], pa.float64())]
+                    else:
+                        output_schema = [([1], pa.float64())]
+
+                elif model._estimator_type == "regressor":
+                    output_schema = [([1], pa.float64())]
+            else:
+                # Check class name as fallback
+                class_name = model.__class__.__name__
+                if "Classifier" in class_name:
+                    n_classes = None
+                    if hasattr(model, "classes_") and model.classes_ is not None:
+                        n_classes = len(model.classes_)
+
+                    if n_classes is not None:
+                        if n_classes == 2:
+                            output_schema = [([1], pa.float64())]
+                        else:
+                            output_schema = [([n_classes], pa.float64())]
+                    else:
+                        output_schema = [([1], pa.float64())]
+                elif "Regressor" in class_name:
+                    output_schema = [([1], pa.float64())]
+                else:
+                    # Default to single output
+                    output_schema = [([1], pa.float64())]
+
+        except Exception:
+            pass
+
+        return input_schema, output_schema
+
+    @staticmethod
+    def infer_model_type(model: Any) -> Tuple[Optional[ModelType], Optional[ModelClass]]:
+        # ONNX - check early since ONNX models are commonly wrapped
+        try:
+            import onnx  # pyright: ignore[reportMissingImports]
+
+            if isinstance(model, onnx.ModelProto):
+                return ModelType.ONNX, None
+            # Check if model has a wrapped ONNX ModelProto (e.g., model._model)
+            if hasattr(model, "_model") and isinstance(model._model, onnx.ModelProto):
+                return ModelType.ONNX, None
+        except ImportError:
+            pass
+
+        try:
+            import onnxruntime  # pyright: ignore[reportMissingImports]
+
+            if isinstance(model, onnxruntime.InferenceSession):
+                return ModelType.ONNX, None
+        except ImportError:
+            pass
+
         # PYTORCH
         try:
             import torch.nn as nn  # pyright: ignore[reportMissingImports]
 
             if isinstance(model, nn.Module):
-                return ModelType.PYTORCH
+                return ModelType.PYTORCH, None
         except ImportError:
             pass
 
@@ -323,11 +433,16 @@ class ModelAttributeExtractor:
         try:
             import xgboost as xgb  # pyright: ignore[reportMissingImports]
 
+            if isinstance(model, xgb.XGBClassifier):
+                return ModelType.XGBOOST, ModelClass.CLASSIFICATION
+            if isinstance(model, xgb.XGBRegressor):
+                return ModelType.XGBOOST, ModelClass.REGRESSION
+
             if isinstance(model, (xgb.XGBModel, xgb.Booster)):
-                return ModelType.XGBOOST
+                return ModelType.XGBOOST, None
             # Also check for XGBoost sklearn API
             if hasattr(model, "__class__") and "xgboost" in model.__class__.__module__:
-                return ModelType.XGBOOST
+                return ModelType.XGBOOST, None
         except ImportError:
             pass
 
@@ -336,9 +451,9 @@ class ModelAttributeExtractor:
             import lightgbm as lgb  # pyright: ignore[reportMissingImports]
 
             if isinstance(model, (lgb.LGBMModel, lgb.Booster)):
-                return ModelType.LIGHTGBM
+                return ModelType.LIGHTGBM, None
             if hasattr(model, "__class__") and "lightgbm" in model.__class__.__module__:
-                return ModelType.LIGHTGBM
+                return ModelType.LIGHTGBM, None
         except ImportError:
             pass
 
@@ -346,32 +461,20 @@ class ModelAttributeExtractor:
         try:
             import catboost as cb  # pyright: ignore[reportMissingImports]
 
-            # CatBoost has various model classes
-            if hasattr(model, "__class__") and "catboost" in model.__class__.__module__:
-                return ModelType.CATBOOST
-            # Common CatBoost classes
+            # Common CatBoost classes - check specific types first
             try:
-                if isinstance(model, (cb.CatBoost, cb.CatBoostClassifier, cb.CatBoostRegressor)):
-                    return ModelType.CATBOOST
+                if isinstance(model, cb.CatBoostClassifier):
+                    return ModelType.CATBOOST, ModelClass.CLASSIFICATION
+                if isinstance(model, cb.CatBoostRegressor):
+                    return ModelType.CATBOOST, ModelClass.REGRESSION
+
+                if isinstance(model, (cb.CatBoost)):
+                    return ModelType.CATBOOST, None
             except (AttributeError, NameError):
                 pass
-        except ImportError:
-            pass
-
-        # ONNX - do we need this one?
-        try:
-            import onnx  # pyright: ignore[reportMissingImports]
-
-            if isinstance(model, onnx.ModelProto):
-                return ModelType.ONNX
-        except ImportError:
-            pass
-
-        try:
-            import onnxruntime  # pyright: ignore[reportMissingImports]
-
-            if isinstance(model, onnxruntime.InferenceSession):
-                return ModelType.ONNX
+            # CatBoost has various model classes - generic fallback
+            if hasattr(model, "__class__") and "catboost" in model.__class__.__module__:
+                return ModelType.CATBOOST, None
         except ImportError:
             pass
 
@@ -380,10 +483,10 @@ class ModelAttributeExtractor:
             import sklearn.base  # pyright: ignore[reportMissingImports]
 
             if isinstance(model, sklearn.base.BaseEstimator):
-                return ModelType.SKLEARN
+                return ModelType.SKLEARN, None
 
             if hasattr(model, "__class__") and "sklearn" in model.__class__.__module__:
-                return ModelType.SKLEARN
+                return ModelType.SKLEARN, None
         except ImportError:
             pass
 
@@ -392,10 +495,10 @@ class ModelAttributeExtractor:
             import tensorflow as tf  # pyright: ignore[reportMissingImports]
 
             if isinstance(model, tf.keras.Model):
-                return ModelType.TENSORFLOW
+                return ModelType.TENSORFLOW, None
             if hasattr(model, "__class__") and "tensorflow" in model.__class__.__module__:
-                return ModelType.TENSORFLOW
+                return ModelType.TENSORFLOW, None
         except ImportError:
             pass
 
-        return None
+        return None, None

chalk/operators/_utils.py

@@ -9,6 +9,7 @@ import pyarrow
 from chalk import DataFrame, Features, StaticOperator
 from chalk._gen.chalk.expression.v1 import expression_pb2 as expr_pb
 from chalk.client import ChalkError, ChalkException, ErrorCode, ErrorCodeCategory
+from chalk.df.LazyFramePlaceholder import LazyFramePlaceholder
 from chalk.features.feature_field import Feature
 
 
@@ -79,7 +80,7 @@ def static_resolver_to_operator(
     fn: Callable,
     inputs: Sequence[Union[Feature, type[DataFrame]]],
     output: Optional[type[Features]],
-) -> StaticOperator | DfPlaceholder | ChalkDataFrame:
+) -> StaticOperator | DfPlaceholder | ChalkDataFrame | LazyFramePlaceholder:
     if output is None:
         raise _GetStaticOperatorError(
             resolver_fqn=fqn,
@@ -96,8 +97,14 @@ def static_resolver_to_operator(
             message="Static resolver must take no arguments and have exactly one DataFrame output",
             underlying_exception=None,
         )
+
     try:
-        placeholder_inputs = [DfPlaceholder(schema_dict=schema_for_input(input_type)) for input_type in inputs]
+        placeholder_inputs = [
+            LazyFramePlaceholder.named_table(
+                name=f"resolver_df_input_{input_index}", schema=pyarrow.schema(schema_for_input(input_type))
+            )
+            for input_index, input_type in enumerate(inputs)
+        ]
         static_operator = fn(*placeholder_inputs)
     except Exception as e:
         # Weird hacky way to return a placeholder even if the resolver fails.
@@ -108,9 +115,13 @@ def static_resolver_to_operator(
         )
     else:
         if (
-            not isinstance(static_operator, (StaticOperator, DfPlaceholder))
+            not isinstance(static_operator, (StaticOperator, DfPlaceholder, LazyFramePlaceholder))
             and not static_operator.__class__.__name__ == "ChalkDataFrame"
             and not static_operator.__class__.__name__ == "LazyFrame"
+            and not (
+                static_operator.__class__.__name__ == "DataFrame"
+                and static_operator.__class__.__module__ == "chalkdf.dataframe"
+            )
         ):
             raise _GetStaticOperatorError(
                 resolver_fqn=fqn,

chalk/parsed/_proto/export.py

@@ -27,6 +27,7 @@ from chalk.parsed._proto.utils import (
     convert_failed_import_to_gql,
     convert_failed_import_to_proto,
     datetime_to_proto_timestamp,
+    timedelta_to_proto_duration,
 )
 from chalk.parsed._proto.validation import validate_artifacts
 from chalk.parsed.to_proto import ToProtoConverter
@@ -145,6 +146,24 @@ def export_from_registry() -> export_pb.Export:
     """
     failed_protos: List[export_pb.FailedImport] = []
 
+    # Validate registries BEFORE conversion to catch errors early
+    # This ensures parity with GQL validation path
+    from chalk.parsed.validation_from_registries import validate_all_from_registries
+
+    try:
+        validate_all_from_registries(
+            features_registry=FeatureSetBase.registry,
+            resolver_registry=RESOLVER_REGISTRY,
+        )
+    except Exception as e:
+        # If validation fails, add to failed_protos but continue
+        # to allow other validation to complete
+        from chalk._lsp.error_builder import LSPErrorBuilder
+
+        if not LSPErrorBuilder.promote_exception(e):
+            # Not an LSP error, so log it as a failed import
+            failed_protos.append(build_failed_import(e, "validation"))
+
     graph_res = ToProtoConverter.convert_graph(
         features_registry=FeatureSetBase.registry,
         resolver_registry=RESOLVER_REGISTRY.get_all_resolvers(),
@@ -193,6 +212,9 @@ def export_from_registry() -> export_pb.Export:
                 file_name=cron.filename,
                 resource_group=cron.resource_group,
                 planner_options=cron.planner_options,
+                completion_deadline=timedelta_to_proto_duration(cron.completion_deadline)
+                if cron.completion_deadline is not None
+                else cron.completion_deadline,
             )
         )
 

chalk/parsed/duplicate_input_gql.py

@@ -271,6 +271,7 @@ class UpsertCronQueryGQL:
     upperBound: Optional[datetime]  # deprecated: can't use datetime
     tags: Optional[List[str]]
     requiredResolverTags: Optional[List[str]]
+    datasetName: Optional[str] = None
     storeOnline: Optional[bool] = True  # None = True
     storeOffline: Optional[bool] = True  # None = True
     incrementalSources: Optional[List[str]] = None
@@ -278,6 +279,9 @@ class UpsertCronQueryGQL:
     upperBoundStr: Optional[str] = None
     resourceGroup: Optional[str] = None
     plannerOptions: Optional[Dict[str, str]] = None
+    completionDeadline: Optional[str] = None
+    numShards: Optional[int] = None
+    numWorkers: Optional[int] = None
 
 
 @dataclasses_json.dataclass_json

chalk/parsed/expressions.py

@@ -1,6 +1,4 @@
-from typing import Literal
-
-from typing_extensions import TypeGuard
+from typing import Literal, TypeGuard
 
 Operation = Literal[
     "!=",

chalk/parsed/json_conversions.py

@@ -418,6 +418,7 @@ def convert_type_to_gql(
             ),
             lowerBound=None,
             upperBound=None,
+            datasetName=t.dataset_name,
             lowerBoundStr=datetime.isoformat(t.lower_bound) if t.lower_bound is not None else None,
             upperBoundStr=datetime.isoformat(t.upper_bound) if t.upper_bound is not None else None,
             tags=list(t.tags) if t.tags is not None else None,
@@ -427,6 +428,9 @@ def convert_type_to_gql(
             incrementalSources=None if t.incremental_resolvers is None else list(t.incremental_resolvers),
             resourceGroup=t.resource_group,
             plannerOptions=t.planner_options,
+            completionDeadline=None if t.completion_deadline is None else timedelta_to_duration(t.completion_deadline),
+            numShards=t.num_shards,
+            numWorkers=t.num_workers,
         )
 
     if isinstance(t, NamedQuery):
@@ -538,20 +542,23 @@ def convert_type_to_gql(
             )
 
         elif t.join is not None:
-            # If a has_one/has_many has an incorrect type annotation
-            builder = t.features_cls.__chalk_error_builder__
-            builder.add_diagnostic(
-                range=builder.annotation_range(t.attribute_name),
-                message=(
-                    f"The attribute '{t.features_cls.__name__}.{t.attribute_name}' "
-                    f"has a join filter ({t.join}) but its type annotation is not a feature class or "
-                    f"DataFrame ({t.typ})."
-                ),
-                label="Incorrect join type annotation",
-                raise_error=TypeError,
-                code="34",
-                code_href="https://docs.chalk.ai/docs/has-many",
-            )
+            # Check if user tried to use DataFrame (even if validation failed)
+            # Use is_dataframe_annotation() to detect DataFrame types without triggering validation errors
+            if not t.typ.is_dataframe_annotation():
+                # If a has_one/has_many has an incorrect type annotation
+                builder = t.features_cls.__chalk_error_builder__
+                builder.add_diagnostic(
+                    range=builder.annotation_range(t.attribute_name),
+                    message=(
+                        f"The attribute '{t.features_cls.__name__}.{t.attribute_name}' "
+                        f"has a join filter ({t.join}) but its type annotation is not a feature class or "
+                        f"DataFrame ({t.typ})."
+                    ),
+                    label="Incorrect join type annotation",
+                    raise_error=TypeError,
+                    code="34",
+                    code_href="https://docs.chalk.ai/docs/has-many",
+                )
 
         elif t.is_feature_time:
             feature_time_kind_gql = UpsertFeatureTimeKindGQL()

chalk/parsed/to_proto.py

@@ -21,6 +21,7 @@ from chalk._gen.chalk.graph.v1 import graph_pb2 as pb
 from chalk._gen.chalk.graph.v2 import sources_pb2 as sources_pb
 from chalk._gen.chalk.lsp.v1.lsp_pb2 import Location, Position, Range
 from chalk._validation.feature_validation import FeatureValidation
+from chalk.df.LazyFramePlaceholder import LazyFramePlaceholder
 from chalk.features import (
     CacheStrategy,
     Feature,
@@ -899,7 +900,7 @@ class ToProtoConverter:
                     else None,
                     backfill_schedule=mat.backfill_schedule,
                     approx_top_k_arg_k=aggregation_kwargs.get("k")
-                    if mat.aggregation in ("approx_top_k", "min_by_n", "max_by_n")
+                    if mat.aggregation in ("approx_top_k", "approx_percentile", "min_by_n", "max_by_n")
                     else None,
                 ),
                 tags=f.tags,
@@ -995,7 +996,7 @@ class ToProtoConverter:
                             else None,
                             continuous_resolver=wmp.continuous_resolver,
                             approx_top_k_arg_k=aggregation_kwargs.get("k")
-                            if wmp.aggregation in ("approx_top_k", "min_by_n", "max_by_n")
+                            if wmp.aggregation in ("approx_top_k", "approx_percentile", "min_by_n", "max_by_n")
                             else None,
                         )
                         if wmp is not None
@@ -1025,6 +1026,9 @@ class ToProtoConverter:
                 expression=ToProtoConverter.convert_underscore(f.underscore_expression)
                 if f.underscore_expression is not None
                 else None,
+                offline_expression=ToProtoConverter.convert_underscore(f.offline_underscore_expression)
+                if f.offline_underscore_expression is not None
+                else None,
                 expression_definition_location=ToProtoConverter.convert_expression_definition_location(
                     f.underscore_expression
                 )
@@ -1147,9 +1151,13 @@ class ToProtoConverter:
             raise ValueError(f"Unsupported resource hint: {r.resource_hint}")
 
         static_operation = None
+        static_operation_dataframe = None
         if r.static:
             static_operator = static_resolver_to_operator(fqn=r.fqn, fn=r.fn, inputs=r.inputs, output=r.output)
-            static_operation = static_operator._to_proto()  # pyright: ignore[reportPrivateUsage]
+            if isinstance(static_operator, LazyFramePlaceholder):
+                static_operation_dataframe = static_operator._to_proto()  # pyright: ignore[reportPrivateUsage]
+            else:
+                static_operation = static_operator._to_proto()  # pyright: ignore[reportPrivateUsage]
 
         function_reference_proto = ToProtoConverter.create_function_reference(
             r.fn,
@@ -1158,7 +1166,9 @@ class ToProtoConverter:
             filename=r.filename,
             source_line=r.source_line,
         )
-
+        postprocessing_underscore_expr: expr_pb.LogicalExprNode | None = None
+        if isinstance(r.postprocessing, Underscore):
+            postprocessing_underscore_expr = r.postprocessing._to_proto()  # pyright: ignore[reportPrivateUsage]
         return pb.Resolver(
             fqn=r.fqn,
             kind=(
@@ -1186,9 +1196,11 @@ class ToProtoConverter:
             unique_on=tuple(x.root_fqn for x in r.unique_on) if r.unique_on is not None else (),
             partitioned_by=(x.root_fqn for x in r.partitioned_by) if r.partitioned_by is not None else (),
             static_operation=static_operation,
+            static_operation_dataframe=static_operation_dataframe,
             sql_settings=ToProtoConverter.convert_sql_settings(r.sql_settings) if r.sql_settings else None,
             output_row_order=r.output_row_order,
             venv=r.venv,
+            underscore_expr=postprocessing_underscore_expr,
         )
 
     @staticmethod