salesforce-data-customcode 6.0.3.dev2__tar.gz → 6.0.4.dev1__tar.gz

{salesforce_data_customcode-6.0.3.dev2 → salesforce_data_customcode-6.0.4.dev1}/PKG-INFO

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

{salesforce_data_customcode-6.0.3.dev2 → salesforce_data_customcode-6.0.4.dev1}/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.0.3.dev2"
+version = "6.0.4.dev1"
 
 [tool.black]
 exclude = '''
@@ -114,6 +114,7 @@ build = "*"
 coverage = ">=7.0.0,<8.0.0"
 ipykernel = "^6.29.5"
 mypy = "*"
+pipreqs = "*"
 poetry-dynamic-versioning = {extras = ["plugin"], version = "^1.8.2"}
 pre-commit = "*"
 pytest = "*"

{salesforce_data_customcode-6.0.3.dev2 → salesforce_data_customcode-6.0.4.dev1}/src/datacustomcode/cli.py

@@ -198,6 +198,7 @@ def zip(path: str, network: str):
     default=None,
     help="SF CLI org alias or username. Fetches credentials via `sf org display`.",
 )
+@click.option("--use-in-feature", default=None, hidden=True, deprecated=True)
 def deploy(
     path: str,
     name: str,
@@ -207,6 +208,7 @@ def deploy(
     profile: str,
     network: str,
     sf_cli_org: Optional[str],
+    use_in_feature: Optional[str],
 ):
     from datacustomcode.constants import USE_IN_FEATURE_MAPPING_FOR_CONNECT_API
     from datacustomcode.deploy import (
@@ -249,13 +251,14 @@ def deploy(
             logger.info(f"Inferred use_in_feature: {use_in_feature}")
         else:
             click.secho(
-                "Error: Could not infer function invoke options. "
-                "Please provide --use-in-feature",
+                "Error: Function signature does not match a supported type. "
+                "Use SearchIndexChunkingV1Request and "
+                "SearchIndexChunkingV1Response in function signature.",
                 fg="red",
             )
             raise click.Abort()
 
-        # Map user-provided feature names to API names
+        # Map feature names to Connect API names
         mapped_feature = USE_IN_FEATURE_MAPPING_FOR_CONNECT_API.get(
             use_in_feature, use_in_feature
         )

{salesforce_data_customcode-6.0.3.dev2 → salesforce_data_customcode-6.0.4.dev1}/src/datacustomcode/deploy.py

@@ -26,12 +26,13 @@ from typing import (
     Callable,
     Dict,
     List,
+    Optional,
     Union,
 )
 
 from loguru import logger
 import pydantic
-from pydantic import BaseModel
+from pydantic import BaseModel, model_validator
 import requests
 
 from datacustomcode.cmd import cmd_output
@@ -366,23 +367,86 @@ class BaseConfig(BaseModel):
     entryPoint: str
 
 
+class DataObjectField(BaseModel):
+    name: str
+    label: str
+    dataType: str
+    isPrimaryKey: bool = False
+    keyQualifierFieldName: Optional[str] = None
+
+
+class DataObject(BaseModel):
+    name: str
+    label: str
+    type: str
+    category: str
+    fields: list[DataObjectField]
+
+
 class DataTransformConfig(BaseConfig):
     sdkVersion: str
     dataspace: str
     permissions: Permissions
+    dataObjects: Optional[list[DataObject]] = None
 
 
 class FunctionConfig(BaseConfig):
     pass
 
 
+class DloPermission(BaseModel):
+    dlo: list[str]
+
+
+class DmoPermission(BaseModel):
+    dmo: list[str]
+
+
 class Permissions(BaseModel):
-    read: Union[DloPermission]
-    write: Union[DloPermission]
+    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
 
 
-class DloPermission(BaseModel):
-    dlo: list[str]
+def _permission_entries(perm: Union[DloPermission, DmoPermission]) -> list[str]:
+    """Return the list of object names regardless of layer (DLO or DMO)."""
+    if isinstance(perm, DloPermission):
+        return perm.dlo
+    return perm.dmo
+
+
+def _data_object_to_output(obj: DataObject) -> dict[str, Any]:
+    """Convert a config.json DataObject into an outputDataObjects entry."""
+    fields: list[dict[str, Any]] = []
+    for field in obj.fields:
+        entry: dict[str, Any] = {
+            "isPrimaryKey": field.isPrimaryKey,
+            "label": field.label,
+            "name": field.name,
+            "type": field.dataType,
+        }
+        if field.keyQualifierFieldName is not None:
+            entry["keyQualifierField"] = field.keyQualifierFieldName
+        fields.append(entry)
+    return {
+        "category": obj.category,
+        "fields": fields,
+        "label": obj.label,
+        "name": obj.name,
+        "type": obj.type,
+    }
 
 
 def get_config(directory: str) -> BaseConfig:
@@ -404,10 +468,17 @@ def get_config(directory: str) -> BaseConfig:
     except json.JSONDecodeError as err:
         raise ValueError(f"config.json at {config_path} is not valid JSON") from err
     except pydantic.ValidationError as err:
-        missing_fields = [str(err["loc"][0]) for err in err.errors()]
+        errors = err.errors()
+        missing = [e for e in errors if e.get("type") == "missing"]
+        if missing and len(missing) == len(errors):
+            missing_fields = [str(e["loc"][0]) for e in missing]
+            raise ValueError(
+                f"config.json at {config_path} is missing required "
+                f"fields: {', '.join(missing_fields)}"
+            ) from err
+        messages = [str(e.get("msg", "")) for e in errors]
         raise ValueError(
-            f"config.json at {config_path} is missing required "
-            f"fields: {', '.join(missing_fields)}"
+            f"config.json at {config_path} is invalid: {'; '.join(messages)}"
         ) from err
 
 
@@ -421,26 +492,45 @@ def create_data_transform(
     script_name = metadata.name
     request_hydrated = DATA_TRANSFORM_REQUEST_TEMPLATE.copy()
 
-    # Add nodes for each write DLO
-    for i, dlo in enumerate(data_transform_config.permissions.write.dlo, 1):
+    # Add nodes for each write entry (DLO or DMO)
+    for i, name in enumerate(
+        _permission_entries(data_transform_config.permissions.write), 1
+    ):
         request_hydrated["nodes"][f"node{i}"] = {
-            "relation_name": dlo,
+            "relation_name": name,
             "config": {"materialized": "table"},
             "compiled_code": "",
         }
 
-    # Add sources for each read DLO
-    for i, dlo in enumerate(data_transform_config.permissions.read.dlo, 1):
-        request_hydrated["sources"][f"source{i}"] = {"relation_name": dlo}
+    # Add sources for each read entry (DLO or DMO)
+    for i, name in enumerate(
+        _permission_entries(data_transform_config.permissions.read), 1
+    ):
+        request_hydrated["sources"][f"source{i}"] = {"relation_name": name}
 
     request_hydrated["macros"]["macro.byoc"]["arguments"][0]["name"] = script_name
 
+    definition: dict[str, Any] = {
+        "type": "DCSQL",
+        "manifest": request_hydrated,
+        "version": "56.0",
+    }
+
+    # outputDataObjects is only set for DMO-backed transforms. The server requires
+    # the schema of any DMO created/updated by the transform; DLO transforms use
+    # an existing materialized table and must not include this field.
+    if isinstance(data_transform_config.permissions.write, DmoPermission):
+        if not data_transform_config.dataObjects:
+            raise ValueError(
+                "DMO transforms require 'dataObjects' in config.json describing "
+                "the schema of each output DMO."
+            )
+        definition["outputDataObjects"] = [
+            _data_object_to_output(obj) for obj in data_transform_config.dataObjects
+        ]
+
     body = {
-        "definition": {
-            "type": "DCSQL",
-            "manifest": request_hydrated,
-            "version": "56.0",
-        },
+        "definition": definition,
         "label": f"{metadata.name}",
         "name": f"{metadata.name}",
         "type": "BATCH",

{salesforce_data_customcode-6.0.3.dev2 → salesforce_data_customcode-6.0.4.dev1}/src/datacustomcode/io/writer/base.py

@@ -27,11 +27,21 @@ if TYPE_CHECKING:
 class WriteMode(str, Enum):
     APPEND = "append"
     OVERWRITE = "overwrite"
-    OVERWRITE_PARTITIONS = "overwrite_partitions"
+    OVERWRITE_PARTITIONS = "overwrite_partitions"  # Deprecated: raises error if used
     MERGE = "merge"
     MERGE_UPSERT_DELETE = "merge_upsert_delete"
 
 
+class MergeRecordType(str, Enum):
+    """Values for the _merge_record_type column used by MERGE_UPSERT_DELETE."""
+
+    UPSERT = "UPSERT"
+    DELETE = "DELETE"
+
+
+MERGE_RECORD_TYPE_COLUMN = "_merge_record_type"
+
+
 class BaseDataCloudWriter(BaseDataAccessLayer):
     """Base class for Data Cloud writers."""
 

{salesforce_data_customcode-6.0.3.dev2 → salesforce_data_customcode-6.0.4.dev1}/src/datacustomcode/run.py

@@ -201,8 +201,20 @@ def run_function_with_test(entrypoint: str, test_file: str) -> None:
 
 
 def add_py_folder(entrypoint: str):
-    default_py_folder = "py-files"  # Hardcoded folder name
+    """Add py-files subfolder and entrypoint directory to sys.path.
+
+    This ensures:
+    1. py-files/ is available for additional dependencies
+    2. The entrypoint directory is available for local module imports
+    """
+    default_py_folder = "py-files"
     cwd = Path.cwd().joinpath(entrypoint)
-    py_folder = cwd.parent.joinpath(default_py_folder)
+    entrypoint_dir = cwd.parent
+    py_folder = entrypoint_dir.joinpath(default_py_folder)
+
+    # Add py-files folder if it exists
+    if py_folder.exists():
+        sys.path.insert(0, str(py_folder))
 
-    sys.path.append(str(py_folder))
+    # Add entrypoint directory to allow local module imports
+    sys.path.insert(0, str(entrypoint_dir))

{salesforce_data_customcode-6.0.3.dev2 → salesforce_data_customcode-6.0.4.dev1}/src/datacustomcode/templates/function/.devcontainer/devcontainer.json

@@ -5,6 +5,6 @@
 		"dockerfile": "../Dockerfile"
 	},
 	"features": {
-		"ghcr.io/devcontainers/features/git:1": {},
+		"ghcr.io/devcontainers/features/git:1": {}
 	}
 }

salesforce_data_customcode-6.0.4.dev1/src/datacustomcode/templates/function/payload/entrypoint.py

@@ -0,0 +1,67 @@
+import logging
+
+from utility import extract_citations, split_text_into_chunks
+
+from datacustomcode.function import Runtime
+from datacustomcode.function.feature_types.chunking import (
+    ChunkType,
+    SearchIndexChunkingV1Output,
+    SearchIndexChunkingV1Request,
+    SearchIndexChunkingV1Response,
+)
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+# Default max chunk size (can be overridden if contract adds max_characters field)
+DEFAULT_MAX_CHUNK_SIZE = 50
+
+
+def function(
+    request: SearchIndexChunkingV1Request, runtime: Runtime
+) -> SearchIndexChunkingV1Response:
+    """Chunk documents into smaller pieces for search indexing.
+
+    Args:
+        request: SearchIndexChunkingV1Request with input documents
+        runtime: Runtime context (unused but required by contract)
+
+    Returns:
+        SearchIndexChunkingV1Response with chunked output
+    """
+    print(f"Received {len(request.input)} documents to chunk")
+
+    chunks = []
+    seq_no = 1
+
+    # Use default max chunk size
+    max_chunk_size = DEFAULT_MAX_CHUNK_SIZE
+
+    # Process each document
+    for doc_idx, doc in enumerate(request.input):
+        text = doc.text
+        metadata = doc.metadata
+
+        print(f"Processing document {doc_idx + 1}: {len(text)} characters")
+
+        # Split the text using our simple chunking algorithm
+        text_chunks = split_text_into_chunks(text, max_chunk_size, overlap=20)
+
+        # Create chunk outputs
+        for chunk_text in text_chunks:
+            citations = extract_citations(metadata)
+
+            chunk_output = SearchIndexChunkingV1Output(
+                chunk_type=ChunkType.TEXT,
+                text=chunk_text.strip(),
+                seq_no=seq_no,
+                citations=citations,
+            )
+            chunks.append(chunk_output)
+
+            print(f"Chunk {seq_no}: {len(chunk_text)} chars")
+            seq_no += 1
+
+    print(f"Generated {len(chunks)} chunks total")
+
+    return SearchIndexChunkingV1Response(output=chunks)

salesforce_data_customcode-6.0.4.dev1/src/datacustomcode/templates/function/payload/utility.py

@@ -0,0 +1,104 @@
+"""Utility functions for text chunking operations."""
+
+import logging
+from typing import (
+    Dict,
+    List,
+    Optional,
+)
+
+from datacustomcode.function.feature_types.chunking import SearchIndexChunkingV1Metadata
+
+logger = logging.getLogger(__name__)
+
+
+def split_text_into_chunks(text: str, max_size: int, overlap: int = 20) -> List[str]:
+    """Split text into chunks with overlap, trying to break at natural boundaries.
+
+    Tries to break at natural boundaries in order of preference:
+    1. Paragraph boundaries (\\n\\n)
+    2. Line boundaries (\\n)
+    3. Sentence boundaries (. ! ?)
+    4. Word boundaries (space)
+    5. Hard cut if no good boundary found
+
+    Args:
+        text: Text to split
+        max_size: Maximum characters per chunk
+        overlap: Number of characters to overlap between chunks
+
+    Returns:
+        List of text chunks
+    """
+    if len(text) <= max_size:
+        return [text]
+
+    chunks = []
+    start = 0
+
+    while start < len(text):
+        # Determine end position for this chunk
+        end = start + max_size
+
+        if end >= len(text):
+            # Last chunk
+            chunks.append(text[start:])
+            break
+
+        # Try to find a good breaking point (in order of preference)
+        chunk_text = text[start:end]
+        break_point = None
+
+        # Try to break at paragraph boundary (\n\n)
+        last_paragraph = chunk_text.rfind("\n\n")
+        if last_paragraph > max_size * 0.5:  # Only if it's past halfway
+            break_point = start + last_paragraph + 2  # +2 to skip the \n\n
+
+        # Try to break at line boundary (\n)
+        if break_point is None:
+            last_newline = chunk_text.rfind("\n")
+            if last_newline > max_size * 0.5:
+                break_point = start + last_newline + 1
+
+        # Try to break at sentence boundary (. ! ?)
+        if break_point is None:
+            for punct in [". ", "! ", "? "]:
+                last_sentence = chunk_text.rfind(punct)
+                if last_sentence > max_size * 0.5:
+                    break_point = start + last_sentence + len(punct)
+                    break
+
+        # Try to break at word boundary (space)
+        if break_point is None:
+            last_space = chunk_text.rfind(" ")
+            if last_space > max_size * 0.5:
+                break_point = start + last_space + 1
+
+        # If no good breaking point, just hard cut
+        if break_point is None:
+            break_point = end
+
+        chunks.append(text[start:break_point].strip())
+
+        # Move start position with overlap
+        start = max(break_point - overlap, start + 1)
+
+    return chunks
+
+
+def extract_citations(
+    metadata: Optional[SearchIndexChunkingV1Metadata],
+) -> Dict[str, str]:
+    """Extract citations from document metadata.
+
+    Args:
+        metadata: Document metadata containing source DMO fields
+
+    Returns:
+        Dictionary of citation key-value pairs
+    """
+    citations = {}
+    if metadata and metadata.source_dmo_fields:
+        for key, value in metadata.source_dmo_fields.items():
+            citations[key] = str(value)
+    return citations

{salesforce_data_customcode-6.0.3.dev2 → salesforce_data_customcode-6.0.4.dev1}/src/datacustomcode/templates/script/.devcontainer/devcontainer.json

@@ -5,6 +5,6 @@
 		"dockerfile": "../Dockerfile"
 	},
 	"features": {
-		"ghcr.io/devcontainers/features/git:1": {},
+		"ghcr.io/devcontainers/features/git:1": {}
 	}
 }

{salesforce_data_customcode-6.0.3.dev2 → salesforce_data_customcode-6.0.4.dev1}/src/datacustomcode/token_provider.py

@@ -101,49 +101,83 @@ class SFCLITokenProvider(TokenProvider):
 
         from datacustomcode.deploy import AccessTokenResponse
 
-        try:
-            result = subprocess.run(
-                ["sf", "org", "display", "--target-org", self.sf_cli_org, "--json"],
-                capture_output=True,
-                text=True,
-                check=True,
-                timeout=30,
-            )
-        except FileNotFoundError as exc:
-            raise RuntimeError(
-                "The 'sf' command was not found. "
-                "Install Salesforce CLI: https://developer.salesforce.com/tools/salesforcecli"
-            ) from exc
-        except subprocess.TimeoutExpired as exc:
-            raise RuntimeError(
-                f"'sf org display' timed out for org '{self.sf_cli_org}'"
-            ) from exc
-        except subprocess.CalledProcessError as exc:
-            raise RuntimeError(
-                f"'sf org display' failed for org '{self.sf_cli_org}': {exc.stderr}"
-            ) from exc
+        def _run_sf_command(args: list[str], description: str) -> dict:
+            try:
+                result = subprocess.run(
+                    args,
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                    timeout=30,
+                )
+            except FileNotFoundError as exc:
+                raise RuntimeError(
+                    "The 'sf' command was not found. "
+                    "Install Salesforce CLI: "
+                    "https://developer.salesforce.com/tools/salesforcecli"
+                ) from exc
+            except subprocess.TimeoutExpired as exc:
+                raise RuntimeError(
+                    f"'{description}' timed out for org '{self.sf_cli_org}'"
+                ) from exc
+            except subprocess.CalledProcessError as exc:
+                raise RuntimeError(
+                    f"'{description}' failed for org '{self.sf_cli_org}': "
+                    f"{exc.stderr}"
+                ) from exc
 
-        try:
-            data = json.loads(result.stdout)
-        except json.JSONDecodeError as exc:
-            raise RuntimeError(
-                f"Failed to parse JSON from 'sf org display': {result.stdout}"
-            ) from exc
+            try:
+                data = json.loads(result.stdout)
+            except json.JSONDecodeError as exc:
+                raise RuntimeError(
+                    f"Failed to parse JSON from '{description}': {result.stdout}"
+                ) from exc
 
-        if data.get("status") != 0:
+            if data.get("status") != 0:
+                raise RuntimeError(
+                    f"SF CLI error for org '{self.sf_cli_org}': "
+                    f"{data.get('message', 'unknown error')}"
+                )
+            return dict(data)
+
+        # Get org info from sf org display
+        display_data = _run_sf_command(
+            ["sf", "org", "display", "--target-org", self.sf_cli_org, "--json"],
+            "sf org display",
+        )
+        result_data = display_data.get("result", {})
+        instance_url = result_data.get("instanceUrl")
+        if not instance_url:
             raise RuntimeError(
-                f"SF CLI error for org '{self.sf_cli_org}': "
-                f"{data.get('message', 'unknown error')}"
+                f"'sf org display' did not return an instance URL "
+                f"for org '{self.sf_cli_org}'"
             )
 
-        result_data = data.get("result", {})
-        access_token = result_data.get("accessToken")
-        instance_url = result_data.get("instanceUrl")
+        # Try show-access-token first (SF CLI >= 2.136.6); fall back to the
+        # token from sf org display (older CLIs don't redact it).
+        access_token = None
+        try:
+            token_data = _run_sf_command(
+                [
+                    "sf",
+                    "org",
+                    "auth",
+                    "show-access-token",
+                    "--target-org",
+                    self.sf_cli_org,
+                    "--json",
+                ],
+                "sf org auth show-access-token",
+            )
+            access_token = token_data.get("result", {}).get("accessToken")
+        except RuntimeError:
+            # Command not available on older SF CLI versions
+            access_token = result_data.get("accessToken")
 
-        if not access_token or not instance_url:
+        if not access_token:
             raise RuntimeError(
-                f"'sf org display' did not return an access token or instance URL "
-                f"for org '{self.sf_cli_org}'"
+                f"Could not obtain an access token for org '{self.sf_cli_org}'. "
+                f"Upgrade SF CLI to 2.136.6+ or ensure the org is authenticated."
             )
 
         return AccessTokenResponse(access_token=access_token, instance_url=instance_url)

salesforce_data_customcode-6.0.3.dev2/src/datacustomcode/templates/function/payload/entrypoint.py

@@ -1,173 +0,0 @@
-import logging
-from typing import List
-from uuid import uuid4
-
-from datacustomcode.einstein_predictions.types import (
-    PredictionColumBuilder,
-    PredictionRequestBuilder,
-    PredictionType,
-)
-from datacustomcode.function import Runtime
-from datacustomcode.llm_gateway.types.generate_text_request_builder import (
-    GenerateTextRequestBuilder,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def chunk_text(text: str, chunk_size: int = 1000) -> List[str]:
-    """
-    Split text into chunks of approximately chunk_size characters.
-    Tries to split at sentence boundaries when possible.
-    """
-    if not text:
-        return []
-
-    chunks = []
-    current_chunk = ""
-
-    # Split text into sentences (simple split by period)
-    sentences = text.split(". ")
-
-    for sentence in sentences:
-        if len(current_chunk) + len(sentence) <= chunk_size:
-            current_chunk += sentence + ". "
-        else:
-            if current_chunk:
-                chunks.append(current_chunk.strip())
-            current_chunk = sentence + ". "
-
-    if current_chunk:
-        chunks.append(current_chunk.strip())
-
-    return chunks
-
-
-def make_einstein_prediction(runtime: Runtime) -> None:
-    column = (
-        PredictionColumBuilder()
-        .set_column_name("col1")
-        .set_string_values(["str1", "str2"])
-        .build()
-    )
-    prediction_request = (
-        PredictionRequestBuilder()
-        .set_prediction_type(PredictionType.REGRESSION)
-        .set_model_api_name("regressionModel")
-        .set_prediction_columns([column])
-        .build()
-    )
-
-    prediction_response = runtime.einstein_predictions.predict(prediction_request)
-    logger.info(
-        f"Einstein prediction results - success: [{prediction_response.is_success}] "
-        f"response data: {prediction_response.data}"
-    )
-
-
-def generate_text(runtime: Runtime, prompt: str, model: str = "sfdc_ai__DefaultGPT52"):
-    builder = GenerateTextRequestBuilder()
-    llm_request = builder.set_prompt(prompt).set_model(model).build()
-    llm_response = runtime.llm_gateway.generate_text(llm_request)
-    logger.info(
-        f"LLM Gateway generate text results - success: [{llm_response.is_success}] "
-        f"response data: {llm_response.data}"
-    )
-
-
-def function(request: dict, runtime: Runtime) -> dict:
-    logger.info("Inside Function")
-    logger.info(request)
-
-    items = request["input"]
-    output_chunks = []
-    current_seq_no = 1  # Start sequence number from 1
-
-    """
-    You can use your AI models configured in Salesforce to generate texts
-    or predict an outcome. See README.md for how to test locally before
-    deploying to Data Cloud.
-
-    Example:
-
-        >>> generated_text = generate_text(runtime, "Generate a greeting message")
-        ... prediction = make_einstein_prediction(runtime)
-
-    """
-
-    for item in items:
-        # Item is DocElement as dict
-        logger.info(f"Processing item: {item}")
-
-        text = item.get("text", "")
-        metadata = item.get("metadata", {})
-
-        # Create chunks from the text
-        text_chunks = chunk_text(text, chunk_size=100)  # Using a larger chunk size
-
-        # Create chunk dictionaries for each text chunk
-        for chunk_content in text_chunks:
-            chunk_dict = {
-                "text": chunk_content,
-                "metadata": metadata,
-                "seq_no": current_seq_no,
-                "chunk_type": "text",
-                "chunk_id": str(uuid4()),
-                "tag_metadata": {},
-                "citations": {},
-                "source_record": item,
-            }
-            output_chunks.append(chunk_dict)
-            current_seq_no += 1  # Increment sequence number for next chunk
-
-    logger.info("Completed chunking")
-    response = {
-        "output": output_chunks,
-        "status": {"status_type": "success", "status_message": "Chunking completed"},
-    }
-    logger.info(response)
-    return response
-
-
-# Test the function
-if __name__ == "__main__":
-    # Configure logging
-    logging.basicConfig(level=logging.INFO)
-
-    # Create test data with two DocElements
-    test_request = {
-        "input": [
-            {
-                "text": (
-                    """This is the first sentence of the first document, which is
-                    intentionally made longer to test chunking. """
-                    """Here is the second sentence of the first document, which is also
-                     quite long and should ensure that the chunking function splits
-                     this text into two chunks when the chunk size is set to 100."""
-                ),
-                "metadata": {"source": "test1", "type": "document"},
-            },
-            {
-                "text": (
-                    """This is the first sentence of the second document, and it is
-                    also extended to be longer than usual for testing purposes. """
-                    """The second sentence of the second document is similarly lengthy,
-                     so that the chunking function will again create two chunks for
-                     this document."""
-                ),
-                "metadata": {"source": "test2", "type": "document"},
-            },
-        ]
-    }
-
-    # Run the function
-    result = function(test_request, Runtime())
-
-    # Print the results in a more readable format
-    print("\nChunking Results:")
-    print("----------------")
-    for chunk in result["output"]:
-        print(f"\nChunk #{chunk['seq_no']}:")
-        print(f"Text: {chunk['text'][:100]}...")  # Print first 100 chars of each chunk
-        print(f"Source: {chunk['metadata']['source']}")
-        print(f"Chunk ID: {chunk['chunk_id']}")