salesforce-data-customcode 6.1.0.dev4__tar.gz → 6.1.0.dev6__tar.gz

{salesforce_data_customcode-6.1.0.dev4 → salesforce_data_customcode-6.1.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: salesforce-data-customcode
-Version: 6.1.0.dev4
+Version: 6.1.0.dev6
 Summary: Data Cloud Custom Code SDK
 License-Expression: Apache-2.0
 License-File: LICENSE.txt
@@ -534,7 +534,7 @@ exploration.  Instead of running an entire script, one can run one code cell at
 
 You can read more about Jupyter Notebooks here: https://jupyter.org/
 
-1. Within the root project of your package folder, run `./jupyterlab.sh start`
+1. Within the root project of your package folder, run `./jupyterlab.sh start`. This prints an access token and opens an already-authenticated JupyterLab session in your browser. If the browser doesn't open automatically, copy the printed `http://localhost:8888/?token=...` URL into your browser.
 1. Double-click on "account.ipynb" file, which provides a starting point for a notebook
 1. Use shift+enter to execute each cell within the notebook.  Add/edit/delete cells of code as needed for your data exploration.
 1. Don't forget to run `./jupyterlab.sh stop` to stop the docker container
@@ -625,5 +625,5 @@ If you're using OAuth Tokens authentication, the initial configure will retrieve
 ## Other docs
 
 - [Troubleshooting](./docs/troubleshooting.md)
-- [For Contributors](./FOR_CONTRIBUTORS.md)
+- [Contributing](./CONTRIBUTING.md)
 

{salesforce_data_customcode-6.1.0.dev4 → salesforce_data_customcode-6.1.0.dev6}/README.md

@@ -509,7 +509,7 @@ exploration.  Instead of running an entire script, one can run one code cell at
 
 You can read more about Jupyter Notebooks here: https://jupyter.org/
 
-1. Within the root project of your package folder, run `./jupyterlab.sh start`
+1. Within the root project of your package folder, run `./jupyterlab.sh start`. This prints an access token and opens an already-authenticated JupyterLab session in your browser. If the browser doesn't open automatically, copy the printed `http://localhost:8888/?token=...` URL into your browser.
 1. Double-click on "account.ipynb" file, which provides a starting point for a notebook
 1. Use shift+enter to execute each cell within the notebook.  Add/edit/delete cells of code as needed for your data exploration.
 1. Don't forget to run `./jupyterlab.sh stop` to stop the docker container
@@ -600,4 +600,4 @@ If you're using OAuth Tokens authentication, the initial configure will retrieve
 ## Other docs
 
 - [Troubleshooting](./docs/troubleshooting.md)
-- [For Contributors](./FOR_CONTRIBUTORS.md)
+- [Contributing](./CONTRIBUTING.md)

{salesforce_data_customcode-6.1.0.dev4 → salesforce_data_customcode-6.1.0.dev6}/pyproject.toml

@@ -18,7 +18,7 @@ license = "Apache-2.0"
 name = "salesforce-data-customcode"
 readme = "README.md"
 requires-python = ">=3.10,<3.12"
-version = "6.1.0.dev4"
+version = "6.1.0.dev6"
 
 [tool.black]
 exclude = '''

{salesforce_data_customcode-6.1.0.dev4 → salesforce_data_customcode-6.1.0.dev6}/src/datacustomcode/client.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 from enum import Enum
+import os
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -657,6 +658,15 @@ class StreamingClient(_BaseClient):
 
     _instance: ClassVar[Optional[StreamingClient]] = None
 
+    def read_dlo(self) -> PySparkDataFrame:
+        """Read the streamingSource
+
+        Returns:
+            A standard PySpark DataFrame from the streaming source DLO
+        """
+        self._record_dlo_access(_streaming_source_name())
+        return self._reader.read_dlo(_streaming_source_name())
+
     def read_dlo_deltas(self) -> PySparkDataFrame:
         """Read the streaming change feed (deltas) for a DLO from Data Cloud.
 
@@ -670,6 +680,14 @@ class StreamingClient(_BaseClient):
         self._record_dlo_access(_streaming_source_name())
         return self._reader.read_dlo_deltas()  # type: ignore[no-any-return]
 
+    def read_dmo(self) -> PySparkDataFrame:
+        """Read the streamingSource
+
+        Returns a standard PySpark DataFrame from the streaming source DMO
+        """
+        self._record_dmo_access(_streaming_source_name())
+        return self._reader.read_dmo(_streaming_source_name())
+
     def read_dmo_deltas(self) -> PySparkDataFrame:
         """Read the streaming change feed (deltas) for a DMO from Data Cloud.
 
@@ -697,3 +715,41 @@ class StreamingClient(_BaseClient):
         """
         self._validate_data_layer_history_does_not_contain(DataCloudObjectType.DMO)
         return self._writer.write_dlo_deltas(name, dataframe, **kwargs)  # type: ignore[no-any-return]
+
+    def auto_write_to_dlo(self, name: str, dataframe: PySparkDataFrame) -> None:
+        """Write a PySpark DataFrame to a DLO in Data Cloud automatically picking
+        the WriteMode.
+        For use with streaming transforms when running in rebuild or initial sync mode.
+        Args:
+            name: The name of the DLO to write to.
+            dataframe: The PySpark DataFrame to write.
+        """
+        self._validate_data_layer_history_does_not_contain(DataCloudObjectType.DMO)
+        return self._writer.auto_write_to_dlo(name, dataframe)
+
+    def auto_write_to_dmo(self, name: str, dataframe: PySparkDataFrame) -> None:
+        """Write a PySpark DataFrame to a DMO in Data Cloud automatically picking
+        the WriteMode.
+        For use with streaming transforms when running in rebuild or initial sync mode.
+        Args:
+            name: The name of the DMO to write to.
+            dataframe: The PySpark DataFrame to write.
+        """
+        self._validate_data_layer_history_does_not_contain(DataCloudObjectType.DLO)
+        return self._writer.auto_write_to_dmo(name, dataframe)
+
+
+class RunMode(Enum):
+    BATCH = "BATCH"
+    INITIAL_SYNC = "INITIAL_SYNC"
+    REBUILD = "REBUILD"
+    DELTA_SYNC = "DELTA_SYNC"
+
+
+def get_run_mode() -> RunMode:
+    """Read and validate the BYOC_RUN_MODE env var; default to BATCH when unset."""
+    run_mode = os.getenv("BYOC_RUN_MODE", "BATCH").upper()
+    try:
+        return RunMode(run_mode)
+    except ValueError as exc:
+        raise ValueError("Set BYOC_RUN_MODE to a valid value") from exc

{salesforce_data_customcode-6.1.0.dev4 → salesforce_data_customcode-6.1.0.dev6}/src/datacustomcode/io/writer/base.py

@@ -59,6 +59,18 @@ class BaseDataCloudWriter(BaseDataAccessLayer):
         self, name: str, dataframe: PySparkDataFrame, write_mode: WriteMode
     ) -> None: ...
 
+    def auto_write_to_dlo(self, name: str, dataframe: PySparkDataFrame) -> None:
+        """Write to a DLO automatically picking the write mode.
+        For use with streaming transforms when running in rebuild or initial sync mode.
+        """
+        raise NotImplementedError
+
+    def auto_write_to_dmo(self, name: str, dataframe: PySparkDataFrame) -> None:
+        """Write to a DMO automatically picking the write mode.
+        For use with streaming transforms when running in rebuild or initial sync mode.
+        """
+        raise NotImplementedError
+
     def write_dlo_deltas(
         self, name: str, dataframe: PySparkDataFrame
     ) -> StreamingQuery:

{salesforce_data_customcode-6.1.0.dev4 → salesforce_data_customcode-6.1.0.dev6}/src/datacustomcode/io/writer/csv.py

@@ -36,6 +36,10 @@ class CSVDataCloudWriter(BaseDataCloudWriter):
             name = f"{name}{SUFFIX}"
         dataframe.write.csv(name, mode=write_mode)
 
+    def auto_write_to_dlo(self, name: str, dataframe: PySparkDataFrame) -> None:
+        # use overwrite since this is a local only writer
+        self.write_to_dlo(name, dataframe, WriteMode.OVERWRITE)
+
     def write_to_dmo(
         self, name: str, dataframe: PySparkDataFrame, write_mode: WriteMode
     ) -> None:
@@ -43,3 +47,7 @@ class CSVDataCloudWriter(BaseDataCloudWriter):
         if not name.lower().endswith(SUFFIX):
             name = f"{name}{SUFFIX}"
         dataframe.write.csv(name, mode=write_mode)
+
+    def auto_write_to_dmo(self, name: str, dataframe: PySparkDataFrame) -> None:
+        # use overwrite since this is a local only writer
+        self.write_to_dmo(name, dataframe, WriteMode.OVERWRITE)

{salesforce_data_customcode-6.1.0.dev4 → salesforce_data_customcode-6.1.0.dev6}/src/datacustomcode/io/writer/print.py

@@ -122,6 +122,10 @@ class PrintDataCloudWriter(BaseDataCloudWriter):
 
         dataframe.show()
 
+    def auto_write_to_dlo(self, name: str, dataframe: PySparkDataFrame) -> None:
+        self.validate_dataframe_columns_against_dlo(dataframe, name)
+        dataframe.show()
+
     def write_to_dmo(
         self, name: str, dataframe: PySparkDataFrame, write_mode: WriteMode
     ) -> None:
@@ -130,3 +134,6 @@ class PrintDataCloudWriter(BaseDataCloudWriter):
         # so just show the dataframe.
 
         dataframe.show()
+
+    def auto_write_to_dmo(self, name: str, dataframe: PySparkDataFrame) -> None:
+        dataframe.show()

{salesforce_data_customcode-6.1.0.dev4 → salesforce_data_customcode-6.1.0.dev6}/src/datacustomcode/named_credential/types/http_request_builder.py

@@ -13,17 +13,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict, Union
+from typing import (
+    Dict,
+    Optional,
+    Union,
+)
 
 from datacustomcode.named_credential.types.http_method import HTTPMethod
 from datacustomcode.named_credential.types.http_request import HTTPRequest
 
+# Control header carrying the per-request callout response timeout (seconds).
+CALLOUT_RESPONSE_TIMEOUT_HEADER = "ctx-callout-response-timeout-seconds"
+
 
 class HTTPRequestBuilder:
     def __init__(self) -> None:
         self._url = ""
         self._method: Union[str, HTTPMethod] = HTTPMethod.GET
         self._headers: Dict[str, str] = {}
+        self._response_timeout_seconds: Optional[int] = None
 
     def set_url(self, url: str) -> "HTTPRequestBuilder":
         """Set the symbolic Named Credential reference.
@@ -44,12 +52,37 @@ class HTTPRequestBuilder:
         return self
 
     def set_headers(self, headers: Dict[str, str]) -> "HTTPRequestBuilder":
+        """Set the HTTP headers.
+
+        Args:
+            headers: a dictionary of HTTP headers
+        """
         self._headers = headers
         return self
 
+    def set_response_timeout_seconds(self, seconds: int) -> "HTTPRequestBuilder":
+        """Set the per-request callout response timeout, in seconds.
+
+        The ``ctx-callout-response-timeout-seconds`` control header allows to
+        configure the timeout for the callout response. This is optional.
+        If not set, the platform will use the default timeout.
+        """
+        if isinstance(seconds, bool) or not isinstance(seconds, int) or seconds <= 0:
+            raise ValueError(
+                "response timeout must be a positive integer number of seconds, "
+                f"got {seconds!r}."
+            )
+        self._response_timeout_seconds = seconds
+        return self
+
     def build(self) -> HTTPRequest:
+        headers = dict(self._headers)
+        if self._response_timeout_seconds is not None:
+            headers[CALLOUT_RESPONSE_TIMEOUT_HEADER] = str(
+                self._response_timeout_seconds
+            )
         return HTTPRequest(
             url=self._url,
             method=self._method,  # type: ignore[arg-type]
-            headers=self._headers,
+            headers=headers,
         )

{salesforce_data_customcode-6.1.0.dev4 → salesforce_data_customcode-6.1.0.dev6}/src/datacustomcode/templates/function/example/chunking_with_external_callout/README.md

@@ -16,6 +16,7 @@ request = (
     .set_url(CALLOUT_URL)
     .set_method(HTTPMethod.POST)
     .set_headers({"Content-Type": "application/json"})
+    .set_response_timeout_seconds(60) # optional: per-callout timeout (seconds)
     .build()
 )
 # Body is sent verbatim (serialize it yourself); the response body is a raw string.

{salesforce_data_customcode-6.1.0.dev4 → salesforce_data_customcode-6.1.0.dev6}/src/datacustomcode/templates/function/example/chunking_with_external_callout/entrypoint.py

@@ -108,6 +108,7 @@ def _analyze_chunk(chunk_text: str, runtime: Runtime) -> dict[str, str]:
         .set_url(CALLOUT_URL)
         .set_method(HTTPMethod.POST)
         .set_headers({"Content-Type": "application/json", "Accept": "application/json"})
+        .set_response_timeout_seconds(60)
         .build()
     )
 

salesforce_data_customcode-6.1.0.dev6/src/datacustomcode/templates/script/examples/external_callout/README.md

@@ -0,0 +1,136 @@
+# Transform with a Gemini Named Credential Callout
+
+The **transform** calls Google's **Gemini** `generateContent` API to summarize text, and
+write the result back to a DLO. Gemini is reached through a **Named Credential**
+(`callout:gemini`), so this code never handles the endpoint URL or the API key.
+
+It shows **both** callout paths against the same Named Credential.
+
+## Shared request template
+
+```python
+from datacustomcode.client import Client, named_credential_request_col
+
+# URL, method and headers apply to every callout on this template.
+request = (
+    HTTPRequestBuilder()
+    .set_url("callout:gemini")            # callout:<NC name>[/<path>]
+    .set_method(HTTPMethod.POST)
+    .set_headers({"Content-Type": "application/json"})
+    .set_response_timeout_seconds(60)     # optional: per-callout timeout (seconds)
+    .build()
+)
+```
+
+## Driver path — one-shot on the driver
+
+`Client.named_credential_request` runs the callout **once** on the driver and
+returns an `HTTPResponse` (`.status_code`, `.body`, `.headers`, `.is_success`).
+Use it for a lookup or a shared value you reuse across the job.
+
+```python
+response = client.named_credential_request(request, body=json.dumps(payload))
+if response.is_success:
+    envelope = json.loads(response.body)
+    text = envelope["candidates"][0]["content"]["parts"][0]["text"]
+```
+
+## Per-row path — fan out across the DataFrame
+
+`named_credential_request_col` dispatches one callout per row; only the body
+Column varies.
+
+```python
+# One callout per row; body is a Column built from the row's data.
+df = df.withColumn("_callout", named_credential_request_col(request, body=body_col))
+```
+
+It returns a struct Column:
+
+```
+{status, response: {status_code, body, headers}, error_code, error_message}
+```
+
+- A non-2xx response is still `status = "SUCCESS"` with the HTTP code in
+  `response.status_code` — extracting the model text just yields null for that row.
+- A transport failure sets `status = "ERROR"`; the row survives, the job does not
+  abort. Pull the model text out of `response.body` with `get_json_object(...)`.
+
+Both paths resolve the same Named Credential and read auth from the same local
+`external_callout_config.json`.
+
+The `gemini` Named Credential's URL already includes the full
+`/v1beta/models/<model>:generateContent` path, so the callout is just
+`callout:gemini` with **no path suffix** (anything after the name is appended to
+the credential's URL).
+
+## Configure the Named Credential
+
+1. Create an **External Credential** (e.g. `google_api_key`) that injects your
+   Gemini API key as the `X-goog-api-key` header.
+2. Create a **Named Credential** named `gemini`:
+   - **URL**: `https://generativelanguage.googleapis.com/v1beta/models/gemini-flash-latest:generateContent`
+   - **Enabled for Callouts** + **Generate Authorization Header**: on
+   - **External Credential**: `google_api_key`
+
+## Test locally
+
+Copy `entrypoint.py` into your `payload/` folder (or point the run at it), then:
+
+```bash
+DATACUSTOMCODE_EXTERNAL_CALLOUT_CONFIG=/abs/path/to/external_callout_config.json \
+  sf data-code-extension script run --entrypoint entrypoint.py --target-org <your-org-alias>
+```
+
+With `----target-org` the SDK fetches only the **URL** from the org's Named
+Credential; **auth is always taken from `external_callout_config.json`** locally
+(the org's External Credential is used only in the Data Cloud runtime). So the
+`X-goog-api-key` must be in the local config for a local test. Omit
+`--target-org` to run fully offline using `target_url`.
+
+```json
+{
+    "credentials": {
+        "callout:gemini": {
+            "auth_type": "Custom",
+            "custom_headers": { "X-goog-api-key": "YOUR_GEMINI_API_KEY" },
+            "target_url": "https://generativelanguage.googleapis.com/v1beta/models/gemini-flash-latest:generateContent"
+        }
+    }
+}
+```
+
+Place `external_callout_config.json` in the **parent of your payload folder** (or
+point `DATACUSTOMCODE_EXTERNAL_CALLOUT_CONFIG` at it). It is never packaged into
+the deployment zip. Get a key from [Google AI Studio](https://aistudio.google.com/apikey);
+**do not commit it.**
+
+## What it reads / writes
+
+`config.json` declares the DLO permissions for deployment:
+
+| | DLO | Notes |
+| ------ | ------------------- | --------------------------------------------- |
+| read   | `Account_std__dll`  | source rows; `description__c` is summarized   |
+| write  | `Account_std_copy__dll` | adds `summary__c`, `callout_status__c`, `callout_http_code__c` |
+
+Adjust `_TEXT_COLUMN`, `_SOURCE_DLO` and `_TARGET_DLO` in `entrypoint.py` (and the
+matching entries in `config.json`) to point at your own DLOs.
+
+## Auth types
+
+`auth_type` selects how auth is injected for local testing. It should mirror the
+External Credential your Named Credential uses in the org, so local and deployed
+runs behave the same. This example uses `Custom` (Gemini's `X-goog-api-key`);
+all four supported types:
+
+| `auth_type` | Fields read | Header sent |
+| ----------- | ------------------------------- | --------------------------------------- |
+| `Basic`     | `username`, `password`          | `Authorization: Basic <base64 user:pw>` |
+| `Custom`    | `custom_headers` (sent verbatim)| the headers you list                    |
+| `OAuth`     | `access_token` or `token`       | `Authorization: Bearer <token>`         |
+| `Jwt`       | `access_token` or `token`       | `Authorization: Bearer <token>`         |
+
+`OAuth`/`Jwt` take a token you supply for the local run — the SDK does not fetch
+or refresh it. In the Data Cloud runtime the Named Credential handles token
+acquisition; this local config only stands in for that during testing.

salesforce_data_customcode-6.1.0.dev6/src/datacustomcode/templates/script/examples/external_callout/entrypoint.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025, Salesforce, Inc.
+# SPDX-License-Identifier: Apache-2
+
+"""
+Data Transform with a Gemini Named Credential Callout
+
+This is a batch transform: read a DLO, enrich it via Google's Gemini ``generateContent``
+API, and write the result back to a DLO.
+
+It shows **both** callout paths against the same Named Credential
+(``callout:gemini``); the request template (URL, method, headers) is shared and
+only the body differs:
+
+- **Driver path** — :meth:`Client.named_credential_request` runs **once** on the
+  driver and returns an :class:`HTTPResponse`. Use it for a single job-level
+  callout whose result you reuse across the job.
+- **Per-row path** — :func:`datacustomcode.client.named_credential_request_col`
+  fans the callout out across the DataFrame, one call per row, returning a struct
+  Column ``{status, response, error_code, error_message}`` where ``response`` is
+  itself ``{status_code, body, headers}``. A non-2xx response is still
+  ``SUCCESS`` with its code in ``response.status_code``; a transport failure sets
+  ``status`` to ``ERROR`` without aborting the whole Spark job.
+"""
+
+import json
+import logging
+
+from pyspark.sql import Column
+from pyspark.sql.functions import (
+    array,
+    col,
+    concat,
+    get_json_object,
+    lit,
+    struct,
+    to_json,
+)
+
+from datacustomcode.client import Client, named_credential_request_col
+from datacustomcode.io.writer.base import WriteMode
+from datacustomcode.named_credential.types.http_method import HTTPMethod
+from datacustomcode.named_credential.types.http_request_builder import (
+    HTTPRequestBuilder,
+)
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+CALLOUT_URL = "callout:gemini"
+
+_TEXT_COLUMN = "Description__c"
+_SOURCE_DLO = "Account_std__dll"
+_TARGET_DLO = "Account_std_copy__dll"
+
+_PROMPT = (
+    "Summarize the following text in one sentence. Respond with the summary "
+    "only, no preamble.\n\nText:\n"
+)
+
+_REQUEST = (
+    HTTPRequestBuilder()
+    .set_url(CALLOUT_URL)
+    .set_method(HTTPMethod.POST)
+    .set_headers({"Content-Type": "application/json", "Accept": "application/json"})
+    .set_response_timeout_seconds(60)
+    .build()
+)
+
+
+def _gemini_body_col(text_col: Column) -> Column:
+    """Build a per-row Gemini ``generateContent`` request body as a JSON string.
+
+    Using ``to_json(struct(...))`` keeps the row text properly escaped inside the
+    JSON payload rather than string-concatenating it.
+    """
+    prompt = concat(lit(_PROMPT), text_col)
+    contents = array(struct(array(struct(prompt.alias("text"))).alias("parts")))
+    return to_json(struct(contents.alias("contents")))
+
+
+def _gemini_body(text: str) -> str:
+    """Build a Gemini ``generateContent`` request body as a JSON string (driver)."""
+    return json.dumps({"contents": [{"parts": [{"text": _PROMPT + text}]}]})
+
+
+def _summarize_on_driver(client: Client, text: str) -> str:
+    """One-shot driver callout: summarize a single string once, not per row.
+
+    The scalar counterpart to the per-row column path — same request template,
+    but dispatched once on the driver and returning an ``HTTPResponse``.
+    """
+    response = client.named_credential_request(_REQUEST, body=_gemini_body(text))
+
+    # Don't raise: a failed driver callout shouldn't abort the whole job.
+    if not response.is_success:
+        logger.error(f"Driver Gemini callout failed: HTTP {response.status_code}")
+        return ""
+
+    envelope = json.loads(response.body) if response.body else {}
+    try:
+        return str(envelope["candidates"][0]["content"]["parts"][0]["text"])
+    except (KeyError, IndexError, TypeError):
+        return ""
+
+
+def main():
+    client = Client()
+
+    df = client.read_dlo(_SOURCE_DLO)
+
+    # Driver path: one callout on the driver over a single representative row.
+    sample = df.select(_TEXT_COLUMN).first()
+    if sample and sample[0]:
+        driver_summary = _summarize_on_driver(client, sample[0])
+        logger.info(f"Driver-path sample summary: {driver_summary}")
+
+    # Per-row path: one Gemini callout per row; the result struct is a column.
+    callout = named_credential_request_col(
+        _REQUEST, body=_gemini_body_col(col(_TEXT_COLUMN))
+    )
+    df = df.withColumn("_callout", callout)
+
+    # Pull the model's text out of the response body. A row whose callout failed
+    # (non-2xx or transport error) yields null here rather than failing the job.
+    summary = get_json_object(
+        col("_callout")["response"]["body"],
+        "$.candidates[0].content.parts[0].text",
+    )
+
+    df = df.select(
+        col("id__c").alias("id__c"),
+        col("Description__c").alias("description__c"),
+        col("kq_id__c").alias("kq_id__c"),
+        summary.alias("summary__c"),
+        col("_callout")["status"].alias("callout_status__c"),
+        col("_callout")["response"]["status_code"].alias("callout_http_code__c"),
+    )
+
+    client.write_to_dlo(_TARGET_DLO, df, write_mode=WriteMode.APPEND)
+
+
+if __name__ == "__main__":
+    main()

salesforce_data_customcode-6.1.0.dev6/src/datacustomcode/templates/script/examples/external_callout/external_callout_config.json

@@ -0,0 +1,11 @@
+{
+    "credentials": {
+        "callout:gemini": {
+            "auth_type": "Custom",
+            "custom_headers": {
+                "X-goog-api-key": "YOUR_API_KEY"
+            },
+            "target_url": "https://generativelanguage.googleapis.com/v1beta/models/gemini-flash-latest:generateContent"
+        }
+    }
+}

salesforce_data_customcode-6.1.0.dev6/src/datacustomcode/templates/script/examples/streaming_deltas/entrypoint.py

@@ -0,0 +1,62 @@
+"""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.
+
+The first run of a streaming job will use the run mode INITIAL_SYNC which behaves
+like a batch run on the streaming source. A streaming transform can also use run
+mode REBUILD to do the same thing on demand. Note that these will process all
+source rows and overwrite the target.
+
+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 runtime;
+ the local ``datacustomcode run`` readers/writers raise
+``NotImplementedError`` for the delta methods.
+"""
+
+from pyspark.sql import DataFrame
+from pyspark.sql.functions import col, upper
+
+from datacustomcode.client import (
+    RunMode,
+    StreamingClient,
+    get_run_mode,
+)
+
+
+def main():
+    target_dlo = "Account_std_copy__dll"
+    client = StreamingClient()
+
+    if get_run_mode() == RunMode.DELTA_SYNC:
+        # Streaming DataFrame over the source DLO's change feed.
+        dataframe = client.read_dlo_deltas()
+        # Ordinary PySpark transform.
+        transformed = transform(dataframe)
+
+        # 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(target_dlo, transformed)
+
+        # Drive the query's lifecycle. In the streaming runtime this blocks until
+        # the job is stopped by the platform.
+        query.awaitTermination()
+    else:
+        # initial sync and rebuild read the entire streaming source DLO and
+        # write using a server-decided mode based on the run mode
+        dataframe = client.read_dlo()
+        transformed = transform(dataframe)
+        client.auto_write_to_dlo(target_dlo, transformed)
+
+
+def transform(dataframe: DataFrame) -> DataFrame:
+    return dataframe.withColumn("description__c", upper(col("description__c")))
+
+
+if __name__ == "__main__":
+    main()

{salesforce_data_customcode-6.1.0.dev4 → salesforce_data_customcode-6.1.0.dev6}/src/datacustomcode/templates/script/jupyterlab.sh

@@ -45,13 +45,24 @@ check_docker() {
     echo "Docker daemon is running"
 }
 
+# Function to check if openssl is installed
+check_openssl() {
+    if ! command -v openssl &> /dev/null; then
+        echo "openssl is not installed. It is required to generate a secure JupyterLab access token."
+        exit 1
+    fi
+}
+
 # Function to start Jupyter server
 start_jupyter() {
     echo "Building the docker image"
     docker build -t datacloud-customcode .
 
+    local TOKEN
+    TOKEN=$(openssl rand -hex 32)
+
     echo "Running the docker container"
-    docker run -d --rm -p 8888:8888 \
+    docker run -d --rm -p 127.0.0.1:8888:8888 \
         -v $(pwd):/workspace \
         --name jupyter-server \
         datacloud-customcode jupyter lab \
@@ -59,12 +70,14 @@ start_jupyter() {
         --port=8888 \
         --no-browser \
         --allow-root \
-        --NotebookApp.token='' \
-        --NotebookApp.password='' \
+        --NotebookApp.token="$TOKEN" \
         --notebook-dir=/workspace
 
     sleep 3  # Wait for server to start
-    open_browser "http://localhost:8888"
+    local URL
+    URL="http://localhost:8888/?token=$TOKEN"
+    echo "Opening $URL"
+    open_browser $URL
 }
 
 # Function to stop Jupyter server
@@ -82,6 +95,7 @@ stop_jupyter() {
 case "$1" in
     "start")
         check_docker
+        check_openssl
         start_jupyter
         ;;
     "stop")

salesforce_data_customcode-6.1.0.dev4/src/datacustomcode/templates/script/examples/streaming_deltas/entrypoint.py

@@ -1,49 +0,0 @@
-"""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()