salesforce-data-customcode 6.0.8.dev1__py3-none-any.whl → 6.1.0.dev2__py3-none-any.whl

datacustomcode/named_credential/types/http_request.py

@@ -0,0 +1,63 @@
+# Copyright (c) 2025, Salesforce, Inc.
+# SPDX-License-Identifier: Apache-2
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from enum import Enum
+from typing import Dict
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    field_validator,
+)
+
+from datacustomcode.named_credential.types.http_method import HTTPMethod
+
+
+class HTTPRequest(BaseModel):
+    """External callout request. The endpoint and its auth are resolved
+    server-side from the Named Credential referenced by ``url``, which uses
+    ``callout:<NamedCredential>/<path>`` syntax."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    url: str = Field(
+        ...,
+        min_length=1,
+        description="Symbolic Named Credential reference, "
+        "e.g. 'callout:<NamedCredential>/<path>'",
+    )
+    method: str = Field(
+        default="GET",
+        description="HTTP method (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS)",
+    )
+    headers: Dict[str, str] = Field(default_factory=dict, description="Request headers")
+
+    @field_validator("method", mode="before")
+    @classmethod
+    def _normalize_method(cls, value: object) -> str:
+        # Accept str, this module's HTTPMethod, or http.HTTPMethod (3.11+).
+        if isinstance(value, Enum):
+            method = str(value.value)
+        else:
+            method = str(value)
+        method = method.upper()
+        if method not in {m.value for m in HTTPMethod}:
+            supported = ", ".join(m.value for m in HTTPMethod)
+            raise ValueError(
+                f"Unsupported HTTP method '{method}'. "
+                f"Named Credential callouts support {supported}."
+            )
+        return method

datacustomcode/named_credential/types/http_request_builder.py

@@ -0,0 +1,55 @@
+# Copyright (c) 2025, Salesforce, Inc.
+# SPDX-License-Identifier: Apache-2
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Dict, Union
+
+from datacustomcode.named_credential.types.http_method import HTTPMethod
+from datacustomcode.named_credential.types.http_request import HTTPRequest
+
+
+class HTTPRequestBuilder:
+    def __init__(self) -> None:
+        self._url = ""
+        self._method: Union[str, HTTPMethod] = HTTPMethod.GET
+        self._headers: Dict[str, str] = {}
+
+    def set_url(self, url: str) -> "HTTPRequestBuilder":
+        """Set the symbolic Named Credential reference.
+
+        Args:
+            url: e.g. 'callout:<NamedCredential>/<path>'
+        """
+        self._url = url
+        return self
+
+    def set_method(self, method: Union[str, HTTPMethod]) -> "HTTPRequestBuilder":
+        """Set the HTTP method.
+
+        Accepts this module's ``HTTPMethod``, ``http.HTTPMethod`` (Python 3.11+),
+        or a plain string such as ``"GET"``.
+        """
+        self._method = method
+        return self
+
+    def set_headers(self, headers: Dict[str, str]) -> "HTTPRequestBuilder":
+        self._headers = headers
+        return self
+
+    def build(self) -> HTTPRequest:
+        return HTTPRequest(
+            url=self._url,
+            method=self._method,  # type: ignore[arg-type]
+            headers=self._headers,
+        )

datacustomcode/named_credential/types/http_response.py

@@ -0,0 +1,43 @@
+# Copyright (c) 2025, Salesforce, Inc.
+# SPDX-License-Identifier: Apache-2
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Dict
+
+from pydantic import BaseModel, Field
+
+
+class HTTPResponse(BaseModel):
+    """Response from a Named Credential external callout."""
+
+    status_code: int = Field(..., description="HTTP status code", ge=0)
+    headers: Dict[str, str] = Field(
+        default_factory=dict, description="Response headers"
+    )
+    body: str = Field(
+        default="",
+        description="Raw response body, verbatim (any format). The SDK does not "
+        "parse it; the caller decodes as needed (e.g. json.loads). Empty string "
+        "if the response had no body.",
+    )
+
+    @property
+    def is_success(self) -> bool:
+        """Check if the request succeeded (2xx)."""
+        return 200 <= self.status_code < 300
+
+    @property
+    def is_error(self) -> bool:
+        """Check if the request failed."""
+        return not self.is_success

datacustomcode/named_credential/types/http_response_builder.py

@@ -0,0 +1,24 @@
+# Copyright (c) 2025, Salesforce, Inc.
+# SPDX-License-Identifier: Apache-2
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Dict
+
+from datacustomcode.named_credential.types.http_response import HTTPResponse
+
+
+class HTTPResponseBuilder:
+    @staticmethod
+    def build(response_dict: Dict[str, Any]) -> HTTPResponse:
+        return HTTPResponse.model_validate(response_dict)

datacustomcode/named_credential_config.py

@@ -0,0 +1,105 @@
+# Copyright (c) 2025, Salesforce, Inc.
+# SPDX-License-Identifier: Apache-2
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import (
+    ClassVar,
+    Generic,
+    Type,
+    TypeVar,
+    Union,
+)
+
+from datacustomcode.common_config import (
+    BaseConfig,
+    BaseObjectConfig,
+    default_config_file,
+)
+from datacustomcode.named_credential.base import NamedCredential
+from datacustomcode.named_credential.spark_base import SparkNamedCredential
+
+_N = TypeVar("_N", bound=NamedCredential)
+_S = TypeVar("_S", bound=SparkNamedCredential)
+
+
+class NamedCredentialObjectConfig(BaseObjectConfig, Generic[_N]):
+    type_to_create: ClassVar[Type[NamedCredential]] = NamedCredential  # type: ignore[type-abstract]
+
+    def to_object(self) -> NamedCredential:
+        type_ = self.type_to_create.subclass_from_config_name(self.type_config_name)
+        return type_(**self.options)
+
+
+class NamedCredentialConfig(BaseConfig):
+    named_credential_config: Union[
+        NamedCredentialObjectConfig[NamedCredential], None
+    ] = None
+
+    def update(self, other: "NamedCredentialConfig") -> "NamedCredentialConfig":
+        def merge(
+            config_a: Union[NamedCredentialObjectConfig, None],
+            config_b: Union[NamedCredentialObjectConfig, None],
+        ) -> Union[NamedCredentialObjectConfig, None]:
+            if config_a is not None and config_a.force:
+                return config_a
+            if config_b:
+                return config_b
+            return config_a
+
+        self.named_credential_config = merge(
+            self.named_credential_config, other.named_credential_config
+        )
+        return self
+
+
+class SparkNamedCredentialObjectConfig(BaseObjectConfig, Generic[_S]):
+    type_to_create: ClassVar[Type[SparkNamedCredential]] = SparkNamedCredential  # type: ignore[type-abstract]
+
+    def to_object(self) -> SparkNamedCredential:
+        type_ = self.type_to_create.subclass_from_config_name(self.type_config_name)
+        return type_(**self.options)
+
+
+class SparkNamedCredentialConfig(BaseConfig):
+    spark_named_credential_config: Union[
+        SparkNamedCredentialObjectConfig[SparkNamedCredential], None
+    ] = None
+
+    def update(
+        self, other: "SparkNamedCredentialConfig"
+    ) -> "SparkNamedCredentialConfig":
+        def merge(
+            config_a: Union[SparkNamedCredentialObjectConfig, None],
+            config_b: Union[SparkNamedCredentialObjectConfig, None],
+        ) -> Union[SparkNamedCredentialObjectConfig, None]:
+            if config_a is not None and config_a.force:
+                return config_a
+            if config_b:
+                return config_b
+            return config_a
+
+        self.spark_named_credential_config = merge(
+            self.spark_named_credential_config, other.spark_named_credential_config
+        )
+        return self
+
+
+# Global Named Credential config instance
+named_credential_config = NamedCredentialConfig()
+named_credential_config.load(default_config_file())
+
+
+# Global Spark Named Credential config instance
+spark_named_credential_config = SparkNamedCredentialConfig()
+spark_named_credential_config.load(default_config_file())

datacustomcode/run.py

@@ -27,6 +27,7 @@ from typing import (
 from datacustomcode.config import config
 from datacustomcode.einstein_predictions_config import einstein_predictions_config
 from datacustomcode.llm_gateway_config import llm_gateway_config
+from datacustomcode.named_credential_config import named_credential_config
 from datacustomcode.scan import find_base_directory, get_package_type
 
 
@@ -55,6 +56,9 @@ def _update_config_options(profile: Optional[str], sf_cli_org: Optional[str]):
         _set_config_option(
             llm_gateway_config.llm_gateway_config, config_key, sf_cli_org
         )
+        _set_config_option(
+            named_credential_config.named_credential_config, config_key, sf_cli_org
+        )
     elif profile != "default":
         config_key = "credentials_profile"
         _set_config_option(config.reader_config, config_key, profile)
@@ -63,6 +67,9 @@ def _update_config_options(profile: Optional[str], sf_cli_org: Optional[str]):
             einstein_predictions_config.einstein_predictions_config, config_key, profile
         )
         _set_config_option(llm_gateway_config.llm_gateway_config, config_key, profile)
+        _set_config_option(
+            named_credential_config.named_credential_config, config_key, profile
+        )
 
 
 def run_entrypoint(

datacustomcode/templates/function/example/chunking_with_external_callout/README.md

@@ -0,0 +1,119 @@
+# Chunking with a Gemini Named Credential Callout
+
+Splits each input document into paragraph-sized chunks and calls Google's
+**Gemini** `generateContent` API for every chunk. The model returns a summary,
+category, sentiment, and topics, which are attached to the chunk as citations so
+the search index can filter and rank on them. Gemini is reached through a
+**Named Credential**, so this code never handles the endpoint URL or the API key.
+
+## How the callout works
+
+```python
+CALLOUT_URL = "callout:gemini"  # callout:<NC name>[/<path>]
+
+request = (
+    HTTPRequestBuilder()
+    .set_url(CALLOUT_URL)
+    .set_method(HTTPMethod.POST)
+    .set_headers({"Content-Type": "application/json"})
+    .build()
+)
+# Body is sent verbatim (serialize it yourself); the response body is a raw string.
+response = runtime.named_credential.request(request, json.dumps(payload))
+if response.is_success:
+    envelope = json.loads(response.body)
+    text = envelope["candidates"][0]["content"]["parts"][0]["text"]
+```
+
+The request asks for `responseMimeType: application/json` with a `responseSchema`,
+so Gemini returns the classification as a JSON string in
+`candidates[0].content.parts[0].text` — decode it, then decode that text again.
+
+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
+
+```bash
+DATACUSTOMCODE_EXTERNAL_CALLOUT_CONFIG=/abs/path/to/external_callout_config.json \
+  sf data-code-extension function run \
+    --entrypoint payload/entrypoint.py \
+    --test-with payload/tests/test.json \
+    --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.**
+
+## 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:
+
+```json
+{
+    "credentials": {
+        "callout:my_custom_api": {
+            "auth_type": "Custom",
+            "custom_headers": { "X-goog-api-key": "YOUR_API_KEY" }
+        },
+        "callout:my_basic_api": {
+            "auth_type": "Basic",
+            "username": "svc_user",
+            "password": "YOUR_PASSWORD"
+        },
+        "callout:my_oauth_api": {
+            "auth_type": "OAuth",
+            "access_token": "YOUR_ACCESS_TOKEN"
+        },
+        "callout:my_jwt_api": {
+            "auth_type": "Jwt",
+            "token": "YOUR_JWT"
+        }
+    }
+}
+```
+
+| `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.

datacustomcode/templates/function/example/chunking_with_external_callout/config.json

@@ -0,0 +1,3 @@
+{
+    "entryPoint": "entrypoint.py"
+}

datacustomcode/templates/function/example/chunking_with_external_callout/entrypoint.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025, Salesforce, Inc.
+# SPDX-License-Identifier: Apache-2
+
+"""
+Document Chunking with a Gemini Named Credential Callout
+
+Splits each input document into paragraph-sized chunks and classifies every
+chunk via Google's Gemini ``generateContent`` API, reached through a Named
+Credential (``callout:gemini``) so the endpoint URL and API key are resolved
+outside this code. The classification is attached to each chunk as citations.
+"""
+
+import json
+import logging
+
+from datacustomcode.function import Runtime
+from datacustomcode.function.feature_types.chunking import (
+    ChunkType,
+    SearchIndexChunkingV1Output,
+    SearchIndexChunkingV1Request,
+    SearchIndexChunkingV1Response,
+)
+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"
+
+_ANALYSIS_FIELDS = ("summary", "category", "sentiment")
+
+_PROMPT = (
+    "Analyze the following document chunk and classify it. Respond with its "
+    "one-sentence summary, a single-word category, overall sentiment "
+    "(positive, negative, or neutral), and up to five key topics.\n\nChunk:\n"
+)
+
+# Force Gemini to return the classification as JSON in a fixed shape.
+_GENERATION_CONFIG = {
+    "responseMimeType": "application/json",
+    "responseSchema": {
+        "type": "object",
+        "properties": {
+            "summary": {"type": "string"},
+            "category": {"type": "string"},
+            "sentiment": {"type": "string"},
+            "topics": {"type": "array", "items": {"type": "string"}},
+        },
+        "required": ["summary", "category", "sentiment", "topics"],
+    },
+}
+
+
+def _chunk_text(text: str, max_words: int = 80) -> list[str]:
+    """Split text into paragraph-aligned chunks of at most ``max_words`` words."""
+    paragraphs = [p.strip() for p in text.split("\n\n") if p.strip()]
+
+    chunks: list[str] = []
+    current: list[str] = []
+    current_words = 0
+
+    for paragraph in paragraphs:
+        paragraph_words = len(paragraph.split())
+        if current and current_words + paragraph_words > max_words:
+            chunks.append("\n\n".join(current))
+            current = []
+            current_words = 0
+        current.append(paragraph)
+        current_words += paragraph_words
+
+    if current:
+        chunks.append("\n\n".join(current))
+
+    return chunks
+
+
+def _extract_model_json(body: str) -> dict:
+    """Decode the model's JSON classification from a Gemini response.
+
+    The generated text sits at ``candidates[0].content.parts[0].text`` and is
+    itself a JSON string, so decode twice. Any malformed layer yields ``{}``.
+    """
+    try:
+        envelope = json.loads(body) if body else {}
+    except json.JSONDecodeError:
+        return {}
+
+    try:
+        text = envelope["candidates"][0]["content"]["parts"][0]["text"]
+    except (KeyError, IndexError, TypeError):
+        return {}
+
+    try:
+        payload = json.loads(text)
+    except json.JSONDecodeError:
+        return {}
+    return payload if isinstance(payload, dict) else {}
+
+
+def _analyze_chunk(chunk_text: str, runtime: Runtime) -> dict[str, str]:
+    """Classify one chunk via the Gemini callout and return it as citations."""
+    request = (
+        HTTPRequestBuilder()
+        .set_url(CALLOUT_URL)
+        .set_method(HTTPMethod.POST)
+        .set_headers({"Content-Type": "application/json", "Accept": "application/json"})
+        .build()
+    )
+
+    payload = {
+        "contents": [{"parts": [{"text": _PROMPT + chunk_text}]}],
+        "generationConfig": _GENERATION_CONFIG,
+    }
+    response = runtime.named_credential.request(request, json.dumps(payload))
+
+    # Don't raise: a single failed callout shouldn't abort the whole job.
+    if not response.is_success:
+        logger.error(f"Gemini callout failed with status {response.status_code}")
+        return {"analysis_status": "failed", "http_status": str(response.status_code)}
+
+    data = _extract_model_json(response.body)
+    citations = {"analysis_status": "success"}
+    for field in _ANALYSIS_FIELDS:
+        value = data.get(field)
+        citations[field] = str(value) if value is not None else "unavailable"
+
+    topics = data.get("topics")
+    if isinstance(topics, list):
+        citations["topics"] = ", ".join(str(topic) for topic in topics)
+
+    return citations
+
+
+def function(
+    request: SearchIndexChunkingV1Request, runtime: Runtime
+) -> SearchIndexChunkingV1Response:
+    """Chunk each input document and classify every chunk via the Gemini API."""
+    logger.info(f"Received {len(request.input)} documents to chunk")
+
+    chunks = []
+    chunk_id = 1
+
+    for doc in request.input:
+        for chunk_text in _chunk_text(doc.text):
+            citations = _analyze_chunk(chunk_text, runtime)
+
+            chunk = SearchIndexChunkingV1Output(
+                text=chunk_text,
+                seq_no=chunk_id,
+                chunk_type=ChunkType.TEXT,
+                citations=citations,
+            )
+            chunks.append(chunk)
+            chunk_id += 1
+
+    logger.info(f"Produced {len(chunks)} classified chunks")
+    return SearchIndexChunkingV1Response(output=chunks)

datacustomcode/templates/function/example/chunking_with_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"
+        }
+    }
+}

datacustomcode/templates/function/example/chunking_with_external_callout/tests/test.json

@@ -0,0 +1,16 @@
+{
+    "input": [
+        {
+            "text": "Product Review: Northstar Analytics\n\nWe rolled Northstar out to our whole revenue team last quarter and the difference has been night and day. Dashboards that used to take our analysts a full day to assemble now refresh in seconds, and the natural-language query box means our account executives can answer their own questions without filing a ticket.\n\nOnboarding was smoother than any tool we have adopted in years. The guided setup imported our Salesforce data on the first try and the sample templates gave us something useful on day one. Support answered our two questions within the hour. Easily the best purchase decision we made this year."
+        },
+        {
+            "text": "Support Ticket #48210: Repeated timeouts on scheduled exports\n\nFor the third week running our nightly export to the data warehouse has failed silently. There is no alert, no email, nothing in the activity log, and we only find out when the morning report is empty and the leadership meeting has no numbers.\n\nI have raised this twice already and both times the ticket was closed as resolved without anyone actually contacting me. This is costing us real credibility internally and I am extremely frustrated. If the connector cannot handle our volume we need to know now so we can plan a migration, because right now the product is not doing the one job we bought it for."
+        },
+        {
+            "text": "Renewal Feedback: mixed feelings heading into year two\n\nThe core product is genuinely good. The reporting engine is fast, the permissions model is granular enough for our compliance team, and our analysts like working in it. On the functionality alone I would renew without hesitation.\n\nWhat gives me pause is the pricing. The per-seat cost jumped noticeably at renewal and several add-ons that used to be included are now separate line items. The value is still there, but the conversation with my finance team was harder than it should have been, and I would like more transparency before the next cycle."
+        },
+        {
+            "text": "Feature Request: scheduled report subscriptions\n\nWe would like the ability to subscribe internal stakeholders to a report on a recurring schedule so a PDF lands in their inbox every Monday morning. Today we export manually and forward it, which is workable but easy to forget.\n\nA few teams have asked whether subscriptions could support filtered views per recipient, for example each regional manager receiving only their own territory. Not urgent for us, but it would remove a recurring bit of manual work and is something a couple of competing tools already offer."
+        }
+    ]
+}

{salesforce_data_customcode-6.0.8.dev1.dist-info → salesforce_data_customcode-6.1.0.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: salesforce-data-customcode
-Version: 6.0.8.dev1
+Version: 6.1.0.dev2
 Summary: Data Cloud Custom Code SDK
 License-Expression: Apache-2.0
 License-File: LICENSE.txt