salesforce-data-customcode 6.1.0.dev3__py3-none-any.whl → 6.1.0.dev4__py3-none-any.whl

datacustomcode/__init__.py

@@ -23,6 +23,7 @@ __all__ = [
     "QueryAPIDataCloudReader",
     "SparkEinsteinPredictions",
     "SparkLLMGateway",
+    "StreamingClient",
     "einstein_predict_col",
     "llm_gateway_generate_text_col",
 ]
@@ -34,6 +35,10 @@ def __getattr__(name: str):
         from datacustomcode.client import Client
 
         return Client
+    elif name == "StreamingClient":
+        from datacustomcode.client import StreamingClient
+
+        return StreamingClient
     elif name == "AuthType":
         from datacustomcode.credentials import AuthType
 

datacustomcode/cli.py

@@ -262,7 +262,7 @@ def deploy(
         mapped_feature = USE_IN_FEATURE_MAPPING_FOR_CONNECT_API.get(
             use_in_feature, use_in_feature
         )
-        metadata.invokeOptions = [mapped_feature]
+        metadata.functionInvokeOptions = [mapped_feature]
 
     try:
         if sf_cli_org:
@@ -283,10 +283,19 @@ def deploy(
 )
 @click.option(
     "--use-in-feature",
-    default="SearchIndexChunking",
-    help="Feature where this function will be used (only applicable for function).",
+    "-u",
+    default=None,
+    help=(
+        "Invoke option for this package. For scripts: 'BatchTransform' "
+        "(default) or 'StreamingTransform'. For functions: 'SearchIndexChunking'."
+    ),
 )
 def init(directory: str, code_type: str, use_in_feature: Optional[str]):
+    from datacustomcode.constants import (
+        SCRIPT_USE_IN_FEATURE_BATCH,
+        SCRIPT_USE_IN_FEATURE_OPTIONS,
+        SCRIPT_USE_IN_FEATURE_STREAMING,
+    )
     from datacustomcode.scan import (
         dc_config_json_from_file,
         update_config,
@@ -294,9 +303,23 @@ def init(directory: str, code_type: str, use_in_feature: Optional[str]):
     )
     from datacustomcode.template import copy_function_template, copy_script_template
 
+    streaming = False
+    if code_type == "script":
+        use_in_feature = use_in_feature or SCRIPT_USE_IN_FEATURE_BATCH
+        if use_in_feature not in SCRIPT_USE_IN_FEATURE_OPTIONS:
+            click.secho(
+                f"Error: Invalid --use-in-feature '{use_in_feature}' for a "
+                f"script. Valid options: {', '.join(SCRIPT_USE_IN_FEATURE_OPTIONS)}.",
+                fg="red",
+            )
+            raise click.Abort()
+        streaming = use_in_feature == SCRIPT_USE_IN_FEATURE_STREAMING
+    else:
+        use_in_feature = use_in_feature or "SearchIndexChunking"
+
     click.echo("Copying template to " + click.style(directory, fg="blue", bold=True))
     if code_type == "script":
-        copy_script_template(directory)
+        copy_script_template(directory, streaming=streaming)
     elif code_type == "function":
         copy_function_template(directory, use_in_feature)
     entrypoint_path = os.path.join(directory, PAYLOAD_DIR, ENTRYPOINT_FILE)
@@ -306,7 +329,9 @@ def init(directory: str, code_type: str, use_in_feature: Optional[str]):
     sdk_config = {"type": code_type}
     write_sdk_config(directory, sdk_config)
 
-    config_json = dc_config_json_from_file(entrypoint_path, code_type)
+    config_json = dc_config_json_from_file(
+        entrypoint_path, code_type, streaming=streaming
+    )
     with open(config_location, "w") as f:
         json.dump(config_json, f, indent=2)
 

datacustomcode/client.py

@@ -21,7 +21,9 @@ from typing import (
     ClassVar,
     Dict,
     Optional,
+    TypeVar,
     Union,
+    cast,
 )
 
 from datacustomcode.config import config
@@ -35,7 +37,12 @@ from datacustomcode.spark.default import DefaultSparkSessionProvider
 if TYPE_CHECKING:
     from pathlib import Path
 
-    from pyspark.sql import Column, DataFrame as PySparkDataFrame
+    from pyspark.sql import (
+        Column,
+        DataFrame as PySparkDataFrame,
+        SparkSession,
+    )
+    from pyspark.sql.streaming import StreamingQuery
 
     from datacustomcode.einstein_predictions.spark_base import SparkEinsteinPredictions
     from datacustomcode.einstein_predictions.types import PredictionType
@@ -48,6 +55,40 @@ if TYPE_CHECKING:
     from datacustomcode.spark.base import BaseSparkSessionProvider
 
 
+def _streaming_source_name() -> str:
+    """Return the streaming transform's read-source name.
+
+    Resolved from ``config.streaming_source``, which ``run_entrypoint``
+    populates from config.json's ``streamingSource`` field.
+
+    Raises:
+        RuntimeError: If no ``streaming_source`` has been configured (e.g. the
+            transform's config.json has no ``streamingSource`` field).
+    """
+    source = config.streaming_source
+    if not source:
+        raise RuntimeError(
+            "No streaming source configured. A streaming transform must declare "
+            "its read source in config.json under 'streamingSource'."
+        )
+    return source
+
+
+def _active_client() -> "_BaseClient":
+    """Return the client backing the module-level Spark column helpers.
+
+    Prefers an already-initialized singleton so a streaming job reuses its
+    :class:`StreamingClient` (and a batch job its :class:`Client`) rather than
+    forcing an unrelated client into existence. Falls back to building the
+    batch :class:`Client` when neither has been created yet.
+    """
+    if Client._instance is not None:
+        return Client._instance
+    if StreamingClient._instance is not None:
+        return StreamingClient._instance
+    return Client()
+
+
 def _build_spark_llm_gateway() -> "SparkLLMGateway":
     """Instantiate the SDK-configured :class:`SparkLLMGateway`.
 
@@ -103,7 +144,7 @@ def llm_gateway_generate_text_col(
         the generated text; on failure, ``status == "ERROR"`` and the
         ``error_*`` fields carry diagnostic detail.
     """
-    gateway = Client()._get_spark_llm_gateway()
+    gateway = _active_client()._get_spark_llm_gateway()
     return gateway.llm_gateway_generate_text_col(template, values, model_id=model_id)
 
 
@@ -180,7 +221,7 @@ def einstein_predict_col(
         the JSON-serialized prediction payload; on failure, ``status ==
         "ERROR"`` and the ``error_*`` fields carry diagnostic detail.
     """
-    predictions = Client()._get_spark_einstein_predictions()
+    predictions = _active_client()._get_spark_einstein_predictions()
     return predictions.einstein_predict_col(
         model_api_name, prediction_type, features, settings=settings
     )
@@ -258,26 +299,22 @@ class DataCloudAccessLayerException(Exception):
         return msg
 
 
-class Client:
-    """Entrypoint for accessing DataCloud objects.
+_ClientT = TypeVar("_ClientT", bound="_BaseClient")
+
+
+class _BaseClient:
+    """Shared machinery for the Data Cloud client singletons.
 
-    This is the object used to access Data Cloud DLOs and DMOs. Accessing DLOs/DMOs
-    are tracked and will throw an exception if they are mixed. In other words, you
-    can read from DLOs and write to DLOs, read from DMOs and write to DMOs, but you
-    cannot read from DLOs and write to DMOs or read from DMOs and write to DLOs.
-    Furthermore you cannot mix during merging tables. This class is a singleton to
-    prevent accidental mixing of DLOs and DMOs.
+    Holds the wiring common to :class:`Client` (batch) and
+    :class:`StreamingClient`
 
-    You can provide custom readers and writers to the client for advanced use
-    cases, but this is not recommended for testing as they may result in unexpected
-    behavior once deployed to Data Cloud. By default, the client intercepts all
-    read/write operations and mocks access to Data Cloud. For example, during
-    writing, we print to the console instead of writing to Data Cloud.
+    This base class is not meant to be instantiated directly; use
+    :class:`Client` or :class:`StreamingClient`.
 
     Args:
-        finder: Find a file path
         reader: A custom reader to use for reading Data Cloud objects.
         writer: A custom writer to use for writing Data Cloud objects.
+        spark_provider: Optional custom :class:`BaseSparkSessionProvider`.
         spark_llm_gateway: Optional custom :class:`SparkLLMGateway`.
         spark_einstein_predictions: Optional custom
             :class:`SparkEinsteinPredictions`.
@@ -291,7 +328,18 @@ class Client:
     >>> answer = client.llm_gateway_generate_text("Generate a greeting message")
     """
 
-    _instance: ClassVar[Optional[Client]] = None
+    # Each concrete subclass gets its own ``_instance`` slot: reads fall through
+    # to this base default of ``None``, but ``cls._instance = ...`` in __new__
+    # always writes to the subclass, so ``Client`` and ``StreamingClient`` never
+    # share an instance.
+    _instance: ClassVar[Optional[_BaseClient]] = None
+    # Process-wide Spark session shared across BOTH client types. Unlike
+    # ``_instance``, this is written via ``_BaseClient._shared_spark`` (never
+    # ``cls._shared_spark``), so the slot lives on the base class and a
+    # ``Client`` and a ``StreamingClient`` in the same process reuse one session
+    # — and therefore one underlying connection — instead of opening two
+    # containing differing state
+    _shared_spark: ClassVar[Optional[SparkSession]] = None
     _reader: BaseDataCloudReader
     _writer: BaseDataCloudWriter
     _file: DefaultFindFilePath
@@ -302,7 +350,7 @@ class Client:
     _code_type: str
 
     def __new__(
-        cls,
+        cls: type[_ClientT],
         reader: Optional[BaseDataCloudReader] = None,
         writer: Optional[BaseDataCloudWriter] = None,
         spark_provider: Optional[BaseSparkSessionProvider] = None,
@@ -310,31 +358,38 @@ class Client:
         spark_einstein_predictions: Optional[SparkEinsteinPredictions] = None,
         spark_named_credential: Optional[SparkNamedCredential] = None,
         code_type: str = "script",
-    ) -> Client:
+    ) -> _ClientT:
 
         if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            cls._instance._spark_llm_gateway = spark_llm_gateway
-            cls._instance._spark_einstein_predictions = spark_einstein_predictions
-            cls._instance._spark_named_credential = spark_named_credential
+            instance = super().__new__(cls)
+            instance._spark_llm_gateway = spark_llm_gateway
+            instance._spark_einstein_predictions = spark_einstein_predictions
+            instance._spark_named_credential = spark_named_credential
             # Initialize Readers and Writers from config
             # and/or provided reader and writer
             if reader is None or writer is None:
-                # We need a spark because we will initialize readers and writers
-                if config.spark_config is None:
-                    raise ValueError(
-                        "Spark config is required when reader/writer is not provided"
-                    )
-
-                provider: BaseSparkSessionProvider
-                if spark_provider is not None:
-                    provider = spark_provider
-                elif config.spark_provider_config is not None:
-                    provider = config.spark_provider_config.to_object()
+                # We need a spark because we will initialize readers and writers.
+                # Reuse the process-wide session if one client already built it,
+                # so a Client and a StreamingClient share a single connection.
+                if _BaseClient._shared_spark is not None:
+                    spark = _BaseClient._shared_spark
                 else:
-                    provider = DefaultSparkSessionProvider()
-
-                spark = provider.get_session(config.spark_config)
+                    if config.spark_config is None:
+                        raise ValueError(
+                            "Spark config is required when reader/writer is not "
+                            "provided"
+                        )
+
+                    provider: BaseSparkSessionProvider
+                    if spark_provider is not None:
+                        provider = spark_provider
+                    elif config.spark_provider_config is not None:
+                        provider = config.spark_provider_config.to_object()
+                    else:
+                        provider = DefaultSparkSessionProvider()
+
+                    spark = provider.get_session(config.spark_config)
+                    _BaseClient._shared_spark = spark
 
             if config.reader_config is None and reader is None:
                 raise ValueError(
@@ -357,66 +412,17 @@ class Client:
             else:
                 writer_init = writer
 
-            cls._instance._reader = reader_init
-            cls._instance._writer = writer_init
-            cls._instance._file = DefaultFindFilePath()
-            cls._instance._data_layer_history = {
+            instance._reader = reader_init
+            instance._writer = writer_init
+            instance._file = DefaultFindFilePath()
+            instance._data_layer_history = {
                 DataCloudObjectType.DLO: set(),
                 DataCloudObjectType.DMO: set(),
             }
-        elif (reader is not None or writer is not None) and cls._instance is not None:
+            cls._instance = instance
+        elif reader is not None or writer is not None:
             raise ValueError("Cannot set reader or writer after client is initialized")
-        return cls._instance
-
-    def read_dlo(self, name: str) -> PySparkDataFrame:
-        """Read a DLO from Data Cloud.
-
-        Args:
-            name: The name of the DLO to read.
-
-        Returns:
-            A PySpark DataFrame containing the DLO data.
-        """
-        self._record_dlo_access(name)
-        return self._reader.read_dlo(name)  # type: ignore[no-any-return]
-
-    def read_dmo(self, name: str) -> PySparkDataFrame:
-        """Read a DMO from Data Cloud.
-
-        Args:
-            name: The name of the DMO to read.
-
-        Returns:
-            A PySpark DataFrame containing the DMO data.
-        """
-        self._record_dmo_access(name)
-        return self._reader.read_dmo(name)  # type: ignore[no-any-return]
-
-    def write_to_dlo(
-        self, name: str, dataframe: PySparkDataFrame, write_mode: WriteMode, **kwargs
-    ) -> None:
-        """Write a PySpark DataFrame to a DLO in Data Cloud.
-
-        Args:
-            name: The name of the DLO to write to.
-            dataframe: The PySpark DataFrame to write.
-            write_mode: The write mode to use for writing to the DLO.
-        """
-        self._validate_data_layer_history_does_not_contain(DataCloudObjectType.DMO)
-        return self._writer.write_to_dlo(name, dataframe, write_mode, **kwargs)  # type: ignore[no-any-return]
-
-    def write_to_dmo(
-        self, name: str, dataframe: PySparkDataFrame, write_mode: WriteMode, **kwargs
-    ) -> None:
-        """Write a PySpark DataFrame to a DMO in Data Cloud.
-
-        Args:
-            name: The name of the DMO to write to.
-            dataframe: The PySpark DataFrame to write.
-            write_mode: The write mode to use for writing to the DMO.
-        """
-        self._validate_data_layer_history_does_not_contain(DataCloudObjectType.DLO)
-        return self._writer.write_to_dmo(name, dataframe, write_mode, **kwargs)  # type: ignore[no-any-return]
+        return cast(_ClientT, cls._instance)
 
     def find_file_path(self, file_name: str) -> Path:
         """Resolve a bundled file shipped in the package to an absolute path.
@@ -579,3 +585,115 @@ class Client:
 
     def _record_dmo_access(self, name: str) -> None:
         self._data_layer_history[DataCloudObjectType.DMO].add(name)
+
+
+class Client(_BaseClient):
+    """Entrypoint for batch access to Data Cloud objects.
+
+    This is the object used to read and write bounded snapshots of Data Cloud
+    DLOs and DMOs.
+    """
+
+    _instance: ClassVar[Optional[Client]] = None
+
+    def read_dlo(self, name: str) -> PySparkDataFrame:
+        """Read a DLO from Data Cloud.
+
+        Args:
+            name: The name of the DLO to read.
+
+        Returns:
+            A PySpark DataFrame containing the DLO data.
+        """
+        self._record_dlo_access(name)
+        return self._reader.read_dlo(name)  # type: ignore[no-any-return]
+
+    def read_dmo(self, name: str) -> PySparkDataFrame:
+        """Read a DMO from Data Cloud.
+
+        Args:
+            name: The name of the DMO to read.
+
+        Returns:
+            A PySpark DataFrame containing the DMO data.
+        """
+        self._record_dmo_access(name)
+        return self._reader.read_dmo(name)  # type: ignore[no-any-return]
+
+    def write_to_dlo(
+        self, name: str, dataframe: PySparkDataFrame, write_mode: WriteMode, **kwargs
+    ) -> None:
+        """Write a PySpark DataFrame to a DLO in Data Cloud.
+
+        Args:
+            name: The name of the DLO to write to.
+            dataframe: The PySpark DataFrame to write.
+            write_mode: The write mode to use for writing to the DLO.
+        """
+        self._validate_data_layer_history_does_not_contain(DataCloudObjectType.DMO)
+        return self._writer.write_to_dlo(name, dataframe, write_mode, **kwargs)  # type: ignore[no-any-return]
+
+    def write_to_dmo(
+        self, name: str, dataframe: PySparkDataFrame, write_mode: WriteMode, **kwargs
+    ) -> None:
+        """Write a PySpark DataFrame to a DMO in Data Cloud.
+
+        Args:
+            name: The name of the DMO to write to.
+            dataframe: The PySpark DataFrame to write.
+            write_mode: The write mode to use for writing to the DMO.
+        """
+        self._validate_data_layer_history_does_not_contain(DataCloudObjectType.DLO)
+        return self._writer.write_to_dmo(name, dataframe, write_mode, **kwargs)  # type: ignore[no-any-return]
+
+
+class StreamingClient(_BaseClient):
+    """Entrypoint for streaming (``DELTA_SYNC``) access to Data Cloud objects.
+
+    This is the streaming counterpart to :class:`Client`. Instead of reading and
+    writing bounded snapshots, it reads a DLO/DMO change feed as a streaming
+    DataFrame and writes the transformed stream back via a ``StreamingQuery``.
+    """
+
+    _instance: ClassVar[Optional[StreamingClient]] = None
+
+    def read_dlo_deltas(self) -> PySparkDataFrame:
+        """Read the streaming change feed (deltas) for a DLO from Data Cloud.
+
+        For use in a streaming (``DELTA_SYNC``) BYOC transform. Returns a
+        streaming DataFrame whose rows carry the change-feed metadata columns
+        (``_record_type``, ``_commit_*``) alongside the source columns.
+
+        Returns:
+            A streaming PySpark DataFrame over the DLO change feed.
+        """
+        self._record_dlo_access(_streaming_source_name())
+        return self._reader.read_dlo_deltas()  # type: ignore[no-any-return]
+
+    def read_dmo_deltas(self) -> PySparkDataFrame:
+        """Read the streaming change feed (deltas) for a DMO from Data Cloud.
+
+        Returns:
+            A streaming PySpark DataFrame over the DMO change feed.
+        """
+        self._record_dmo_access(_streaming_source_name())
+        return self._reader.read_dmo_deltas()  # type: ignore[no-any-return]
+
+    def write_dlo_deltas(
+        self, name: str, dataframe: PySparkDataFrame, **kwargs
+    ) -> StreamingQuery:
+        """Write a streaming DataFrame of deltas to a DLO in Data Cloud.
+
+        Starts a streaming query that writes each micro-batch to the
+        target DLO and returns the  ``StreamingQuery`` handle; the caller
+        typically calls ``query.awaitTermination()``.
+
+        Args:
+            name: The name of the DLO to write to.
+            dataframe: The streaming PySpark DataFrame to write.
+
+        Returns:
+            The started ``StreamingQuery``.
+        """
+        self._validate_data_layer_history_does_not_contain(DataCloudObjectType.DMO)
+        return self._writer.write_dlo_deltas(name, dataframe, **kwargs)  # type: ignore[no-any-return]

datacustomcode/config.py

@@ -89,6 +89,9 @@ class ClientConfig(BaseConfig):
     spark_provider_config: Union[
         SparkProviderConfig[BaseSparkSessionProvider], None
     ] = None
+    # Source object name for a streaming (DELTA_SYNC) transform, populated by
+    # ``run_entrypoint`` from config.json's ``streamingSource`` field
+    streaming_source: Union[str, None] = None
 
     def update(self, other: ClientConfig) -> ClientConfig:
         """Merge this ClientConfig with another, respecting force flags.
@@ -116,6 +119,8 @@ class ClientConfig(BaseConfig):
         self.spark_provider_config = merge(
             self.spark_provider_config, other.spark_provider_config
         )
+        if other.streaming_source is not None:
+            self.streaming_source = other.streaming_source
         return self
 
 

datacustomcode/constants.py

@@ -35,9 +35,17 @@ FEATURE_TEMPLATE_MAPPING = {
 
 # Feature name to Connect API name mapping
 USE_IN_FEATURE_MAPPING_FOR_CONNECT_API = {
-    "SearchIndexChunking": "SearchIndexChunking",
+    "SearchIndexChunking": "UnstructuredChunking",
 }
 
+# Script (data transform) invoke options
+SCRIPT_USE_IN_FEATURE_BATCH = "BatchTransform"
+SCRIPT_USE_IN_FEATURE_STREAMING = "StreamingTransform"
+SCRIPT_USE_IN_FEATURE_OPTIONS = [
+    SCRIPT_USE_IN_FEATURE_BATCH,
+    SCRIPT_USE_IN_FEATURE_STREAMING,
+]
+
 # Pydantic request/response type names to feature names
 REQUEST_TYPE_TO_FEATURE = {
     "SearchIndexChunkingV1Request": "SearchIndexChunking",

datacustomcode/deploy.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 from __future__ import annotations
 
+import copy
 from html import unescape
 import json
 import os
@@ -42,8 +43,9 @@ from datacustomcode.named_credential.direct.credentials import (
 )
 from datacustomcode.scan import find_base_directory, get_package_type
 
-DATA_CUSTOM_CODE_PATH = "services/data/v67.0/ssot/data-custom-code"
+DATA_CUSTOM_CODE_PATH = "services/data/v63.0/ssot/data-custom-code"
 DATA_TRANSFORMS_PATH = "services/data/v63.0/ssot/data-transforms"
+DATA_CUSTOM_CODE_INVOKE_OPTIONS_PATH = "services/data/v67.0/ssot/data-custom-code"
 WAIT_FOR_DEPLOYMENT_TIMEOUT = 3000
 
 # Available compute types for Data Cloud deployments.
@@ -110,6 +112,7 @@ class CodeExtensionMetadata(BaseModel):
     description: str
     computeType: str
     codeType: str
+    functionInvokeOptions: Union[list[str], None] = None
     invokeOptions: Union[list[str], None] = None
 
     def __init__(self, **data):
@@ -203,7 +206,14 @@ def create_deployment(
     access_token: AccessTokenResponse, metadata: CodeExtensionMetadata
 ) -> CreateDeploymentResponse:
     """Create a custom code deployment in the DataCloud."""
-    url = _join_strip_url(access_token.instance_url, DATA_CUSTOM_CODE_PATH)
+    # invokeOptions only binds at v67.0; route there when it is set so the
+    # option isn't silently dropped. Everything else stays on v63.0.
+    code_custom_code_path = (
+        DATA_CUSTOM_CODE_INVOKE_OPTIONS_PATH
+        if metadata.invokeOptions
+        else DATA_CUSTOM_CODE_PATH
+    )
+    url = _join_strip_url(access_token.instance_url, code_custom_code_path)
     body = dict[str, Any](
         {
             "label": metadata.name,
@@ -214,6 +224,8 @@ def create_deployment(
             "codeType": metadata.codeType,
         }
     )
+    if metadata.functionInvokeOptions:
+        body["functionInvokeOptions"] = metadata.functionInvokeOptions
     if metadata.invokeOptions:
         body["invokeOptions"] = metadata.invokeOptions
     logger.debug(f"Creating deployment {metadata.name}...")
@@ -393,6 +405,30 @@ class DataTransformConfig(BaseConfig):
     dataspace: str
     permissions: Permissions
     dataObjects: Optional[list[DataObject]] = None
+    streamingSource: Optional[StreamingSource] = None
+
+    @property
+    def is_streaming(self) -> bool:
+        return self.streamingSource is not None
+
+    @model_validator(mode="after")
+    def _validate_layers(self) -> "DataTransformConfig":
+        read_is_dlo = isinstance(self.permissions.read, DloPermission)
+        write_is_dlo = isinstance(self.permissions.write, DloPermission)
+        if self.is_streaming:
+            if not write_is_dlo:
+                raise ValueError(
+                    "A streaming transform must write to a DLO "
+                    "(permissions.write must be a 'dlo' entry)."
+                )
+        elif read_is_dlo != write_is_dlo:
+            raise ValueError(
+                "permissions.read and permissions.write must both reference "
+                "DLOs or both reference DMOs (got "
+                f"read={type(self.permissions.read).__name__}, "
+                f"write={type(self.permissions.write).__name__})"
+            )
+        return self
 
 
 class FunctionConfig(BaseConfig):
@@ -407,23 +443,15 @@ class DmoPermission(BaseModel):
     dmo: list[str]
 
 
+class StreamingSource(BaseModel):
+    type: str
+    name: str
+
+
 class Permissions(BaseModel):
     read: Union[DloPermission, DmoPermission]
     write: Union[DloPermission, DmoPermission]
 
-    @model_validator(mode="after")
-    def _no_mixed_layers(self) -> "Permissions":
-        read_is_dlo = isinstance(self.read, DloPermission)
-        write_is_dlo = isinstance(self.write, DloPermission)
-        if read_is_dlo != write_is_dlo:
-            raise ValueError(
-                "permissions.read and permissions.write must both reference "
-                "DLOs or both reference DMOs (got "
-                f"read={type(self.read).__name__}, "
-                f"write={type(self.write).__name__})"
-            )
-        return self
-
 
 def _permission_entries(perm: Union[DloPermission, DmoPermission]) -> list[str]:
     """Return the list of object names regardless of layer (DLO or DMO)."""
@@ -495,7 +523,9 @@ def create_data_transform(
 ) -> dict:
     """Create a data transform in the DataCloud."""
     script_name = metadata.name
-    request_hydrated = DATA_TRANSFORM_REQUEST_TEMPLATE.copy()
+    # Deep copy: the template's nested nodes/sources/macros dicts would
+    # otherwise be shared across calls and accumulate entries between deploys.
+    request_hydrated = copy.deepcopy(DATA_TRANSFORM_REQUEST_TEMPLATE)
 
     # Add nodes for each write entry (DLO or DMO)
     for i, name in enumerate(
@@ -538,7 +568,7 @@ def create_data_transform(
         "definition": definition,
         "label": f"{metadata.name}",
         "name": f"{metadata.name}",
-        "type": "BATCH",
+        "type": "STREAMING" if data_transform_config.is_streaming else "BATCH",
         "dataSpaceName": data_transform_config.dataspace,
     }
 
@@ -621,9 +651,18 @@ def deploy_full(
     callback=None,
 ) -> AccessTokenResponse:
     """Deploy a data transform in the DataCloud."""
+    from datacustomcode.constants import SCRIPT_USE_IN_FEATURE_STREAMING
+
     # prepare payload
     config = get_config(directory)
 
+    if (
+        isinstance(config, DataTransformConfig)
+        and config.is_streaming
+        and not metadata.invokeOptions
+    ):
+        metadata.invokeOptions = [SCRIPT_USE_IN_FEATURE_STREAMING]
+
     # create deployment and upload payload
     deployment = create_deployment(access_token, metadata)
     zip(directory, docker_network, metadata.codeType)

datacustomcode/io/reader/base.py

@@ -41,3 +41,45 @@ class BaseDataCloudReader(BaseDataAccessLayer):
         name: str,
         schema: Union[AtomicType, StructType, str, None] = None,
     ) -> PySparkDataFrame: ...
+
+    def read_dlo_deltas(self) -> PySparkDataFrame:
+        """Read the streaming change feed (deltas) for a Data Lake Object.
+
+        This is the streaming counterpart to :meth:`read_dlo`. It returns a
+        streaming DataFrame over the change feed the Data Cloud runtime
+        publishes for a streaming (``DELTA_SYNC``) transform. Concrete
+        streaming behavior is provided by the deployed Data Cloud runtime; the
+        base implementation raises :class:`NotImplementedError` so local
+        readers that do not support streaming fail clearly.
+
+        Returns:
+            A streaming PySpark DataFrame over the DLO change feed.
+
+        Raises:
+            NotImplementedError: If the active reader does not support streaming
+                deltas (e.g. the local development readers).
+        """
+        raise NotImplementedError(
+            "read_dlo_deltas is only supported when running in the Data Cloud "
+            "streaming runtime; the local reader does not support streaming "
+            "deltas."
+        )
+
+    def read_dmo_deltas(self) -> PySparkDataFrame:
+        """Read the streaming change feed (deltas) for a Data Model Object.
+
+        Streaming counterpart to :meth:`read_dmo`. See :meth:`read_dlo_deltas`
+        for behavior and the local-development caveat.
+
+        Returns:
+            A streaming PySpark DataFrame over the DMO change feed.
+
+        Raises:
+            NotImplementedError: If the active reader does not support streaming
+                deltas (e.g. the local development readers).
+        """
+        raise NotImplementedError(
+            "read_dmo_deltas is only supported when running in the Data Cloud "
+            "streaming runtime; the local reader does not support streaming "
+            "deltas."
+        )

datacustomcode/io/writer/base.py

@@ -22,6 +22,7 @@ from datacustomcode.io.base import BaseDataAccessLayer
 
 if TYPE_CHECKING:
     from pyspark.sql import DataFrame as PySparkDataFrame, SparkSession
+    from pyspark.sql.streaming import StreamingQuery
 
 
 class WriteMode(str, Enum):
@@ -57,3 +58,35 @@ class BaseDataCloudWriter(BaseDataAccessLayer):
     def write_to_dmo(
         self, name: str, dataframe: PySparkDataFrame, write_mode: WriteMode
     ) -> None: ...
+
+    def write_dlo_deltas(
+        self, name: str, dataframe: PySparkDataFrame
+    ) -> StreamingQuery:
+        """Write a streaming DataFrame of deltas to a Data Lake Object.
+
+        Streaming counterpart to :meth:`write_to_dlo`. Starts a streaming query
+        that writes each micro-batch to the target DLO via the Data Cloud
+        streaming sink and returns the resulting ``StreamingQuery`` handle. The
+        runtime owns the trigger and checkpoint location; callers pass only the
+        table name. Concrete streaming behavior is provided by the deployed
+        Data Cloud runtime; the base implementation raises
+        :class:`NotImplementedError`.
+
+        Args:
+            name: Target Data Lake Object name.
+            dataframe: Streaming PySpark DataFrame produced from a
+                ``read_dlo_deltas`` / ``read_dmo_deltas`` source.
+
+        Returns:
+            The started ``StreamingQuery``; the caller drives its lifecycle
+            (typically ``query.awaitTermination()``).
+
+        Raises:
+            NotImplementedError: If the active writer does not support streaming
+                deltas (e.g. the local development writers).
+        """
+        raise NotImplementedError(
+            "write_dlo_deltas is only supported when running in the Data Cloud "
+            "streaming runtime; the local writer does not support streaming "
+            "deltas."
+        )

datacustomcode/run.py

@@ -43,6 +43,15 @@ def _set_config_option(config_obj, key: str, value: Optional[str]) -> None:
         config_obj.options[key] = value
 
 
+def _read_streaming_source(config_json: dict) -> Optional[str]:
+    """Return the streaming source name from config.json's ``streamingSource``."""
+    source = config_json.get("streamingSource")
+    if not isinstance(source, dict):
+        return None
+    name = source.get("name")
+    return str(name) if name else None
+
+
 def _update_config_options(profile: Optional[str], sf_cli_org: Optional[str]):
     if sf_cli_org:
         config_key = "sf_cli_org"
@@ -132,6 +141,8 @@ def run_entrypoint(
         _set_config_option(config.reader_config, "dataspace", dataspace)
         _set_config_option(config.writer_config, "dataspace", dataspace)
 
+        config.streaming_source = _read_streaming_source(config_json)
+
     _update_config_options(profile, sf_cli_org)
 
     for dependency in dependencies:

datacustomcode/scan.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import ast
+import copy
 import json
 import os
 import sys
@@ -32,6 +33,8 @@ import pydantic
 from datacustomcode.version import get_version
 
 DATA_ACCESS_METHODS = ["read_dlo", "read_dmo", "write_to_dlo", "write_to_dmo"]
+STREAMING_READ_METHODS = ["read_dlo_deltas", "read_dmo_deltas"]
+STREAMING_WRITE_METHODS = ["write_dlo_deltas"]
 
 DATA_TRANSFORM_CONFIG_TEMPLATE = {
     "sdkVersion": get_version(),
@@ -43,6 +46,20 @@ DATA_TRANSFORM_CONFIG_TEMPLATE = {
     },
 }
 
+STREAMING_TRANSFORM_CONFIG_TEMPLATE = {
+    "sdkVersion": get_version(),
+    "entryPoint": "",
+    "dataspace": "default",
+    "streamingSource": {
+        "type": "dlo",
+        "name": "",
+    },
+    "permissions": {
+        "read": {},
+        "write": {},
+    },
+}
+
 FUNCTION_CONFIG_TEMPLATE = {
     "entryPoint": "",
 }
@@ -160,6 +177,35 @@ class DataAccessLayerCalls(pydantic.BaseModel):
         return next(iter(self.write_to_dmo))
 
 
+class StreamingDataAccessLayerCalls(pydantic.BaseModel):
+    read_dlo_deltas: bool
+    read_dmo_deltas: bool
+    write_dlo_deltas: frozenset[str]
+
+    @pydantic.model_validator(mode="after")
+    def validate_access_layer(self) -> StreamingDataAccessLayerCalls:
+        if self.read_dlo_deltas and self.read_dmo_deltas:
+            raise ValueError(
+                "Cannot read DLO and DMO deltas in the same streaming transform."
+            )
+        if not self.read_dlo_deltas and not self.read_dmo_deltas:
+            raise ValueError(
+                "A streaming transform must read from at least one DLO or DMO "
+                "delta stream (read_dlo_deltas / read_dmo_deltas)."
+            )
+        if not self.write_dlo_deltas:
+            raise ValueError(
+                "A streaming transform must write to at least one DLO via "
+                "write_dlo_deltas."
+            )
+        return self
+
+    @property
+    def read_layer(self) -> str:
+        """Return the read source layer, ``"dlo"`` or ``"dmo"``."""
+        return "dlo" if self.read_dlo_deltas else "dmo"
+
+
 class ClientMethodVisitor(ast.NodeVisitor):
     """AST Visitor that finds all instances of Client read/write method calls."""
 
@@ -168,6 +214,9 @@ class ClientMethodVisitor(ast.NodeVisitor):
         self._read_dmo_instances: set[str] = set()
         self._write_to_dlo_instances: set[str] = set()
         self._write_to_dmo_instances: set[str] = set()
+        self._read_dlo_deltas: bool = False
+        self._read_dmo_deltas: bool = False
+        self._write_dlo_deltas_instances: set[str] = set()
         self.variable_values: Dict[str, Union[str, None]] = {}
 
     def visit_Assign(self, node: ast.Assign) -> None:
@@ -189,14 +238,15 @@ class ClientMethodVisitor(ast.NodeVisitor):
             node.func.value, ast.Name
         ):
             method_name = node.func.attr
+
+            if method_name == "read_dlo_deltas":
+                self._read_dlo_deltas = True
+            elif method_name == "read_dmo_deltas":
+                self._read_dmo_deltas = True
+
             if method_name in DATA_ACCESS_METHODS and node.args:
                 arg = node.args[0]
-                name = None
-
-                if isinstance(arg, ast.Constant) and isinstance(arg.value, str):
-                    name = arg.value
-                elif isinstance(arg, ast.Name) and arg.id in self.variable_values:
-                    name = self.variable_values[arg.id]
+                name = self._resolve_name_arg(arg)
 
                 if name:
                     if method_name == "read_dlo":
@@ -207,8 +257,29 @@ class ClientMethodVisitor(ast.NodeVisitor):
                         self._write_to_dlo_instances.add(name)
                     elif method_name == "write_to_dmo":
                         self._write_to_dmo_instances.add(name)
+            elif method_name in STREAMING_WRITE_METHODS and node.args:
+                name = self._resolve_name_arg(node.args[0])
+                if name and method_name == "write_dlo_deltas":
+                    self._write_dlo_deltas_instances.add(name)
         self.generic_visit(node)
 
+    def _resolve_name_arg(self, arg: ast.expr) -> Union[str, None]:
+        """Resolve a string-literal or tracked-variable first argument."""
+        if isinstance(arg, ast.Constant) and isinstance(arg.value, str):
+            return arg.value
+        if isinstance(arg, ast.Name) and arg.id in self.variable_values:
+            return self.variable_values[arg.id]
+        return None
+
+    @property
+    def is_streaming(self) -> bool:
+        """Whether any streaming (delta) access method was found."""
+        return (
+            self._read_dlo_deltas
+            or self._read_dmo_deltas
+            or bool(self._write_dlo_deltas_instances)
+        )
+
     def found(self) -> DataAccessLayerCalls:
         return DataAccessLayerCalls(
             read_dlo=frozenset(self._read_dlo_instances),
@@ -217,6 +288,13 @@ class ClientMethodVisitor(ast.NodeVisitor):
             write_to_dmo=frozenset(self._write_to_dmo_instances),
         )
 
+    def found_streaming(self) -> StreamingDataAccessLayerCalls:
+        return StreamingDataAccessLayerCalls(
+            read_dlo_deltas=self._read_dlo_deltas,
+            read_dmo_deltas=self._read_dmo_deltas,
+            write_dlo_deltas=frozenset(self._write_dlo_deltas_instances),
+        )
+
 
 class ImportVisitor(ast.NodeVisitor):
     """AST Visitor that extracts external package imports from Python code."""
@@ -301,23 +379,51 @@ def write_requirements_file(file_path: str) -> str:
     return requirements_path
 
 
-def scan_file(file_path: str) -> DataAccessLayerCalls:
-    """Scan a single Python file for Client read/write method calls."""
+def _visit_file(file_path: str) -> ClientMethodVisitor:
+    """Parse a Python file and return the populated method visitor."""
     with open(file_path, "r") as f:
-        code = f.read()
-        tree = ast.parse(code)
-        visitor = ClientMethodVisitor()
-        visitor.visit(tree)
-        return visitor.found()
+        tree = ast.parse(f.read())
+    visitor = ClientMethodVisitor()
+    visitor.visit(tree)
+    return visitor
+
+
+def scan_file(file_path: str) -> DataAccessLayerCalls:
+    """Scan a single Python file for batch Client read/write method calls."""
+    return _visit_file(file_path).found()
+
+
+def scan_file_streaming(file_path: str) -> StreamingDataAccessLayerCalls:
+    """Scan a single Python file for StreamingClient delta method calls."""
+    return _visit_file(file_path).found_streaming()
+
 
+def file_is_streaming(file_path: str) -> bool:
+    """Return whether the entrypoint uses streaming (delta) access methods."""
+    return _visit_file(file_path).is_streaming
 
-def dc_config_json_from_file(file_path: str, type: str) -> dict[str, Any]:
-    """Create a Data Cloud Custom Code config JSON from a script."""
+
+def dc_config_json_from_file(
+    file_path: str, type: str, streaming: bool = False
+) -> dict[str, Any]:
+    """Create a Data Cloud Custom Code config JSON from a script.
+
+    Args:
+        file_path: Path to the entrypoint.
+        type: Package type, ``"script"`` or ``"function"``.
+        streaming: For scripts, a streaming
+            (``streamingSource``) config instead of a batch one.
+    """
     config: dict[str, Any]
     if type == "script":
-        config = DATA_TRANSFORM_CONFIG_TEMPLATE.copy()
+        template = (
+            STREAMING_TRANSFORM_CONFIG_TEMPLATE
+            if streaming
+            else DATA_TRANSFORM_CONFIG_TEMPLATE
+        )
+        config = copy.deepcopy(template)
     elif type == "function":
-        config = FUNCTION_CONFIG_TEMPLATE.copy()
+        config = copy.deepcopy(FUNCTION_CONFIG_TEMPLATE)
     config["entryPoint"] = os.path.basename(file_path)
     return config
 
@@ -372,22 +478,51 @@ def update_config(file_path: str) -> dict[str, Any]:
 
     if package_type == "script":
         existing_config["dataspace"] = get_dataspace(existing_config)
-        output = scan_file(file_path)
-        read: dict[str, list[str]] = {}
-        if output.read_dlo:
-            read["dlo"] = list(output.read_dlo)
-        else:
-            read["dmo"] = list(output.read_dmo)
-        write: dict[str, list[str]] = {}
-        if output.write_to_dlo:
-            write["dlo"] = list(output.write_to_dlo)
+        if file_is_streaming(file_path):
+            _update_streaming_config(existing_config, file_path)
         else:
-            write["dmo"] = list(output.write_to_dmo)
-
-        existing_config["permissions"] = {"read": read, "write": write}
+            existing_config.pop("streamingSource", None)
+            output = scan_file(file_path)
+            read: dict[str, list[str]] = {}
+            if output.read_dlo:
+                read["dlo"] = list(output.read_dlo)
+            else:
+                read["dmo"] = list(output.read_dmo)
+            write: dict[str, list[str]] = {}
+            if output.write_to_dlo:
+                write["dlo"] = list(output.write_to_dlo)
+            else:
+                write["dmo"] = list(output.write_to_dmo)
+
+            existing_config["permissions"] = {"read": read, "write": write}
     return existing_config
 
 
+def _update_streaming_config(existing_config: dict[str, Any], file_path: str) -> None:
+    output = scan_file_streaming(file_path)
+    read_layer = output.read_layer
+
+    source = existing_config.get("streamingSource")
+    if not isinstance(source, dict):
+        source = {}
+    source_name = source.get("name", "")
+    existing_config["streamingSource"] = {"type": read_layer, "name": source_name}
+
+    if not source_name:
+        logger.warning(
+            "streamingSource.name is empty in config.json. A streaming "
+            "transform must declare its read source; set streamingSource.name "
+            "to the DLO/DMO the transform reads from."
+        )
+
+    read_names = [source_name] if source_name else []
+    write_names = list(output.write_dlo_deltas)
+    existing_config["permissions"] = {
+        "read": {read_layer: read_names},
+        "write": {"dlo": write_names},
+    }
+
+
 def get_dataspace(existing_config: dict[str, str]) -> str:
     if "dataspace" in existing_config:
         dataspace_value = existing_config["dataspace"]

datacustomcode/template.py

@@ -23,8 +23,12 @@ from datacustomcode.constants import FEATURE_TEMPLATE_MAPPING
 script_template_dir = os.path.join(os.path.dirname(__file__), "templates", "script")
 function_template_dir = os.path.join(os.path.dirname(__file__), "templates", "function")
 
+STREAMING_EXAMPLE_ENTRYPOINT = os.path.join(
+    script_template_dir, "examples", "streaming_deltas", "entrypoint.py"
+)
 
-def copy_script_template(target_dir: str) -> None:
+
+def copy_script_template(target_dir: str, streaming: bool = False) -> None:
     """Copy the template to the target directory."""
     os.makedirs(target_dir, exist_ok=True)
 
@@ -39,6 +43,14 @@ def copy_script_template(target_dir: str) -> None:
             logger.debug(f"Copying file {source} to {destination}...")
             shutil.copy2(source, destination)
 
+    if streaming:
+        destination = os.path.join(target_dir, "payload", "entrypoint.py")
+        logger.debug(
+            f"Copying streaming example {STREAMING_EXAMPLE_ENTRYPOINT} to "
+            f"{destination}..."
+        )
+        shutil.copy2(STREAMING_EXAMPLE_ENTRYPOINT, destination)
+
 
 def copy_function_template(target_dir: str, use_in_feature: Optional[str]) -> None:
     os.makedirs(target_dir, exist_ok=True)

datacustomcode/templates/script/examples/streaming_deltas/entrypoint.py

@@ -0,0 +1,49 @@
+"""Streaming BYOC transform: read a DLO change feed and write the deltas back.
+
+This example is the streaming counterpart to a normal batch entrypoint. Instead
+of a batch ``Client`` with ``read_dlo`` / ``write_to_dlo`` (which read and write
+a bounded snapshot), it uses a :class:`StreamingClient` and its streaming delta
+methods:
+
+* ``client.read_dlo_deltas()`` returns a *streaming* DataFrame over the
+  Change Data Feed of the source DLO. Each row carries the source columns plus
+  change-feed metadata columns (``_record_type``, ``_commit_*``).
+* ``client.write_dlo_deltas(name, df)`` starts a streaming query that writes
+  each micro-batch to the target DLO and returns the ``StreamingQuery`` handle.
+  The runtime owns the trigger, and checkpoint location — the caller only
+  chooses the table.
+
+The transform in between is ordinary PySpark. Because the source is a change
+feed, keep the metadata columns on the DataFrame you hand to
+``write_dlo_deltas`` — the sink relies on them to merge changes correctly.
+
+This entrypoint only runs inside the Data Cloud streaming (``DELTA_SYNC``)
+runtime; the local ``datacustomcode run`` readers/writers raise
+``NotImplementedError`` for the delta methods.
+"""
+
+from pyspark.sql.functions import col, upper
+
+from datacustomcode.client import StreamingClient
+
+
+def main():
+    client = StreamingClient()
+
+    # Streaming DataFrame over the source DLO's change feed.
+    deltas = client.read_dlo_deltas()
+
+    # Ordinary PySpark transform.
+    transformed = deltas.withColumn("description__c", upper(col("description__c")))
+
+    # Start the streaming write. write_dlo_deltas returns the StreamingQuery;
+    # the trigger and checkpoint location are provided by the runtime.
+    query = client.write_dlo_deltas("Account_std_copy__dll", transformed)
+
+    # Drive the query's lifecycle. In the streaming runtime this blocks until
+    # the job is stopped by the platform.
+    query.awaitTermination()
+
+
+if __name__ == "__main__":
+    main()

{salesforce_data_customcode-6.1.0.dev3.dist-info → salesforce_data_customcode-6.1.0.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: salesforce-data-customcode
-Version: 6.1.0.dev3
+Version: 6.1.0.dev4
 Summary: Data Cloud Custom Code SDK
 License-Expression: Apache-2.0
 License-File: LICENSE.txt
@@ -170,15 +170,22 @@ Your Python dependencies can be packaged as .py files, .zip archives (containing
 
 ## API
 
-Your entry point script will define logic using the `Client` object which wraps data access layers.
+Your entry point script will define logic using the `Client` object (for batch transforms) or the `StreamingClient` object (for streaming delta transforms), which wrap the data access layers. Both are singletons; a single transform should use one or the other, not both.
 
-You should only need the following methods:
+For a batch transform, use `Client`. You should only need the following methods:
 * `find_file_path(file_name)` – Resolve a bundled file (placed under `payload/files/`) to a `pathlib.Path` that exists. Works the same locally and inside Data Cloud — see [Bundled file resolution](#bundled-file-resolution) below for the full lookup order. Raises `FileNotFoundError` if the file isn't found.
 * `read_dlo(name)` – Read from a Data Lake Object by name
 * `read_dmo(name)` – Read from a Data Model Object by name
 * `write_to_dlo(name, spark_dataframe, write_mode)` – Write to a Data Model Object by name with a Spark dataframe
 * `write_to_dmo(name, spark_dataframe, write_mode)` – Write to a Data Lake Object by name with a Spark dataframe
 
+For a streaming (delta) transform, use `StreamingClient`, which exposes the streaming counterparts:
+* `read_dlo_deltas()` – Read the streaming change feed (deltas) of a Data Lake Object as a streaming DataFrame.
+* `read_dmo_deltas()` – Read the streaming change feed (deltas) of a Data Model Object as a streaming DataFrame.
+* `write_dlo_deltas(name, spark_dataframe)` – Write a streaming DataFrame of deltas to a Data Lake Object; returns the started `StreamingQuery`
+
+`find_file_path`, `llm_gateway_generate_text`, and `einstein_predict` are available on both clients.
+
 For example:
 ```python
 from datacustomcode import Client
@@ -194,6 +201,36 @@ client.write_to_dlo('output_DLO')
 > [!WARNING]
 > Currently we only support reading from DMOs and writing to DMOs or reading from DLOs and writing to DLOs, but they cannot mix.
 
+### Streaming (delta) transforms
+
+Streaming BYOC transforms process a Data Lake Object's Change Data Feed continuously instead of reading a bounded snapshot. Use a `StreamingClient` and its `*_deltas` methods in place of the batch `Client` read/write methods:
+
+```python
+from pyspark.sql.functions import col, upper
+
+from datacustomcode import StreamingClient
+
+client = StreamingClient()
+
+# read_dlo_deltas returns a *streaming* DataFrame over the change feed.
+# The runtime resolves the single streaming source, so no name is passed.
+deltas = client.read_dlo_deltas()
+
+# Ordinary PySpark transform.
+transformed = deltas.withColumn("description__c", upper(col("description__c")))
+
+# write_dlo_deltas starts a streaming query and returns the StreamingQuery.
+# The runtime owns the trigger and checkpoint location; you
+# choose only the target table.
+query = client.write_dlo_deltas("Output__dll", transformed)
+query.awaitTermination()
+```
+
+Notes:
+
+- These methods only run inside the Data Cloud streaming (`DELTA_SYNC`) runtime. Locally (`datacustomcode run`) they raise `NotImplementedError`, since there is no change feed to stream.
+- A complete runnable entry point is provided in [`examples/streaming_deltas/entrypoint.py`](src/datacustomcode/templates/script/examples/streaming_deltas/entrypoint.py).
+
 ### Bundled file resolution
 
 Place bundled files (CSVs, prompt files, etc.) under `payload/files/`. The same `client.find_file_path("data.csv")` call resolves consistently across all three runtimes:

{salesforce_data_customcode-6.1.0.dev3.dist-info → salesforce_data_customcode-6.1.0.dev4.dist-info}/RECORD

@@ -1,14 +1,14 @@
-datacustomcode/__init__.py,sha256=SGsDnWDTihWkLNnWdqvH08zklQgxykar73JAcPL2plI,2666
+datacustomcode/__init__.py,sha256=5vvWRk5gb2mZIaVZ9BSPRL45uKSUwmSerxhLp6A4Q-4,2815
 datacustomcode/auth.py,sha256=fpSjhIBdv9trC8yq2vuljAix_Euu-4Ah7HDCGhYjOxI,8309
-datacustomcode/cli.py,sha256=qAUEFztKjYaG6Ws8xuE8rUpUr06snmFbUEuNRggjdBY,13256
-datacustomcode/client.py,sha256=lbOseiGaDru-vUtdRXgAORhrJa5V5WrFkbcEIfzBkaU,24325
+datacustomcode/cli.py,sha256=K4LHL5xrb7-erXbjYz7pT4Kg4jG6Wf81c9wl_8tLabE,14162
+datacustomcode/client.py,sha256=0uw9qptultCYT-fZ3cXwaPvIFW5J9E79nD46tnu4NUE,28743
 datacustomcode/cmd.py,sha256=ZMs46aydJw2EaU26JgCtZmnqESQFHvvaJz10hnjZTBk,3537
 datacustomcode/common_config.py,sha256=SAUnxj3kqmOeWwPmFoYq4tuxokMgURVm4QwcGi-avL4,1928
-datacustomcode/config.py,sha256=2Pk61ieQsEWSxKDxlS66_rliKE8iX0j-9LweEm0aaGo,4072
+datacustomcode/config.py,sha256=lqed3jcWfoIweikSFZelaAoyBa0cXXScL8O6vaqdeRU,4372
 datacustomcode/config.yaml,sha256=LqpbkZhzN0nZOPEPnaz2qOCbchp8fxC4GHamT_b56D0,1082
-datacustomcode/constants.py,sha256=wcWy82JAZgMCzIrDLb6k0nl-qtNHawGedGBxY4atL8E,1435
+datacustomcode/constants.py,sha256=NCGptcql30En5N7WAH96TYD_DTzHFYdh1sZZ5f327cs,1686
 datacustomcode/credentials.py,sha256=D-7Zd3Nh_wStdj8_wUy5cnC8M_mdbfBijhIAi-2EbXs,9467
-datacustomcode/deploy.py,sha256=eN5k7Rbxe-Yf8c_CeeHICZJqzJqMuvIVNu11agNW8NA,22111
+datacustomcode/deploy.py,sha256=kyd8QqvWrw_thHvGWEnjbeNVgAyjpoqR8TKqjcIriGA,23678
 datacustomcode/einstein_platform_client.py,sha256=ON2B_m--vdbCVVMVcLc81T-BRZ5-UuxVCer8E6OEQPA,4083
 datacustomcode/einstein_platform_config.py,sha256=6lb_FRbEzdt5a8-2cR15f13ZKw674uvRJ4Xq0o_pQXE,1490
 datacustomcode/einstein_predictions/__init__.py,sha256=_RIDTqcEHDRu6AsCsj9lRBykNkHI8Ch8JBILL1ioPtA,1237
@@ -32,12 +32,12 @@ datacustomcode/function_utils.py,sha256=y6vaoSSaJ9CeHhjLCNyqzJT4vx6yCePWRxNLz38d
 datacustomcode/io/__init__.py,sha256=gamfOD1VnAtEslRBpqh-yKiVjkG_wYWYdSatGIfsN-w,621
 datacustomcode/io/base.py,sha256=gbwZWWVUbCbGR4jIg_4h4qOz8tOMjE4RDTleD23WFKo,973
 datacustomcode/io/reader/__init__.py,sha256=gamfOD1VnAtEslRBpqh-yKiVjkG_wYWYdSatGIfsN-w,621
-datacustomcode/io/reader/base.py,sha256=JRKg8KfEPJGR58wqicsEdpAPiXTl2K1eV3eHQyxYWaE,1390
+datacustomcode/io/reader/base.py,sha256=2hAqaZvzHvvr5KBEgQSjUrHpidcHkgUXXTbGQG-b8io,3176
 datacustomcode/io/reader/query_api.py,sha256=eVrohrcnTnhSMsGfPRHu5XltjFtGG0hyHt1o4q1hp2w,9340
 datacustomcode/io/reader/sf_cli.py,sha256=x5QacVqRZaZSyph1_wwxo67s8r29wsOcUsOaiF9cDWE,6324
 datacustomcode/io/reader/utils.py,sha256=HlHhPZoHfmWA3mF8kTnd3m4Nd2exaz4NsOJJfQY7Pew,1656
 datacustomcode/io/writer/__init__.py,sha256=gamfOD1VnAtEslRBpqh-yKiVjkG_wYWYdSatGIfsN-w,621
-datacustomcode/io/writer/base.py,sha256=6e2Yszb6BiuN1zCV2rjvZ5CQ0YikQdUgdYAkutoy9pE,1787
+datacustomcode/io/writer/base.py,sha256=LtyOtkcEsX3oQZ-2zWFeNutVae1T3ialbGbvwl-7spU,3246
 datacustomcode/io/writer/csv.py,sha256=asty5teBpNQ1fMGHZ7wA3suLhq0sk0lVQPN5x7TOSRk,1555
 datacustomcode/io/writer/print.py,sha256=0g2sP_1Wb95UIyEELWJt3dqM18Iv_CWhDW3mDxcIhns,5105
 datacustomcode/llm_gateway/__init__.py,sha256=rcoGpSkv36tZuAOcTxKkhNpM0qV03qgmer_ej07Vmfc,1088
@@ -72,12 +72,12 @@ datacustomcode/named_credential/types/http_response.py,sha256=ZqX52RMjSdn8OpHSDk
 datacustomcode/named_credential/types/http_response_builder.py,sha256=MoUjpT-P5W2uT1-h1rIfKpBQHpMj_ZA_nUmn-FyBdbQ,896
 datacustomcode/named_credential_config.py,sha256=M07-oWzYj0KTrfA0fqvk3BQvaaDaw7C6nxbR0s3lOUk,3645
 datacustomcode/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datacustomcode/run.py,sha256=PXfpIwcgqyW6KLawTUuzGSt4FeAcxtafg-FgBHGXOLg,8091
-datacustomcode/scan.py,sha256=Zb9mE733H_xaqyDI-LZjjnIcctMC9j1AaD_kcr9qTh4,14325
+datacustomcode/run.py,sha256=G0b5PCU0nucOFGX578LlYjmCpmgAASADnf2rh8NmccI,8485
+datacustomcode/scan.py,sha256=9rq1Wae_tYACJykaOmBOv1covYvOSdky8w13exnmyJ0,19170
 datacustomcode/spark/__init__.py,sha256=12drVVlRiczCxOQw-EzuGtLsikCM8baBXvDEgwvelCI,860
 datacustomcode/spark/base.py,sha256=tlGqM4LxuLoDa7OxJF5nVeb7phO5uvD1DHBQeH7NMMs,1036
 datacustomcode/spark/default.py,sha256=aMB8CaTPYwHbQE_7XqBLQUZPGRdDJcRL72qTVh0aG7M,1433
-datacustomcode/template.py,sha256=FNNi8YPfd-JB-hUt1DDWSFK5AqwKnTnRSy_KpqYluaU,3282
+datacustomcode/template.py,sha256=1u0U86coPX7-8g0ZixCbFGDBOMNcOqMhTXdJDAN9TaU,3726
 datacustomcode/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datacustomcode/templates/function/.devcontainer/devcontainer.json,sha256=21RNTadhC-rynON2-VOtr5U174Hxnr_MA4RQ4592rsg,166
 datacustomcode/templates/function/Dockerfile.dependencies,sha256=AfHRddm5l3ujv4vdrf0d-SMB-qxPCOa0XQm6ptP2Euw,174
@@ -111,6 +111,7 @@ datacustomcode/templates/script/account.ipynb,sha256=LIbxgiVxflNASdspF2lfpMKkKAT
 datacustomcode/templates/script/build_native_dependencies.sh,sha256=ICRrp4f1ATBwPaUiuVGjY-MwiubFswNJLf8gMGU6YNg,197
 datacustomcode/templates/script/examples/employee_hierarchy/employee_data.csv,sha256=C7ggLBfoyi3M2BdMLNyOeKqF-5OO-Da76lkwgWg2cVQ,302
 datacustomcode/templates/script/examples/employee_hierarchy/entrypoint.py,sha256=Mfm3iQtEHTQRW6cmZTwRKdTh3IeGWR-teXrd6x-YLSY,2223
+datacustomcode/templates/script/examples/streaming_deltas/entrypoint.py,sha256=1PpYyZck2j9IRTnoI-kfHbMf21vN8gA49_-qJr3rDjk,1984
 datacustomcode/templates/script/jupyterlab.sh,sha256=IHR3YQ8d_busuyvesByhJgzCKULIFPI-Hqogs0NPhCs,2432
 datacustomcode/templates/script/payload/config.json,sha256=0d2mEMt4NHIeOUTsgiPMuRKdOLIQxmh-Wq-IfEqU-gc,28
 datacustomcode/templates/script/payload/entrypoint.py,sha256=4Uph0ILa5ukk_6C90paK3uzQn0zZvNLr9ho3o_ZwErQ,2474
@@ -118,8 +119,8 @@ datacustomcode/templates/script/requirements-dev.txt,sha256=OWwuy1awesqOZOS3Zizm
 datacustomcode/templates/script/requirements.txt,sha256=qJbqzs5z0Hrx590U3T7dHq_m8UQEx2TdhgrJSz-QHIQ,40
 datacustomcode/token_provider.py,sha256=qA_e4vqSXnxn0MccFFPULWO8ZeUOEAu5QpBnoYCg-fc,6839
 datacustomcode/version.py,sha256=9LlbVrzwBvut1L308QbwNBgxdQk5CrghH39JARVSxms,989
-salesforce_data_customcode-6.1.0.dev3.dist-info/METADATA,sha256=FDlrw8kdEPaFPCw8PJ0knkNqmS3vIuntw2oznOqA-A0,25115
-salesforce_data_customcode-6.1.0.dev3.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
-salesforce_data_customcode-6.1.0.dev3.dist-info/entry_points.txt,sha256=WpQ94UB7UuRCYGOLtJV3vAgm1tl7iVf43VYRWIuNu5Y,74
-salesforce_data_customcode-6.1.0.dev3.dist-info/licenses/LICENSE.txt,sha256=iOi8EmQpfkFhMENi7VYtkl2EqS14pEOccoXHiW2dyPU,11443
-salesforce_data_customcode-6.1.0.dev3.dist-info/RECORD,,
+salesforce_data_customcode-6.1.0.dev4.dist-info/METADATA,sha256=Z3pzLUNQb2iRxImuljMvwdpumcV5x8wJEVtySG545pc,27207
+salesforce_data_customcode-6.1.0.dev4.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
+salesforce_data_customcode-6.1.0.dev4.dist-info/entry_points.txt,sha256=WpQ94UB7UuRCYGOLtJV3vAgm1tl7iVf43VYRWIuNu5Y,74
+salesforce_data_customcode-6.1.0.dev4.dist-info/licenses/LICENSE.txt,sha256=iOi8EmQpfkFhMENi7VYtkl2EqS14pEOccoXHiW2dyPU,11443
+salesforce_data_customcode-6.1.0.dev4.dist-info/RECORD,,