fhir-sdc-testkit 3.0.0a1__tar.gz

fhir_sdc_testkit-3.0.0a1/.gitignore

@@ -0,0 +1,5 @@
+dist/
+.venv/
+.mypy_cache/
+.ruff_cache/
+fhir_sdc_testkit/_version.py

fhir_sdc_testkit-3.0.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 beda.software
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fhir_sdc_testkit-3.0.0a1/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.5
+Name: fhir-sdc-testkit
+Version: 3.0.0a1
+Summary: Drive an SDC Questionnaire through $populate, answers and $extract in tests
+Project-URL: Homepage, https://github.com/beda-software/fhir-sdc
+Project-URL: Source, https://github.com/beda-software/fhir-sdc/tree/master/fhir-sdc-testkit
+Author-email: "beda.software" <hi@beda.software>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: fhir,pytest,questionnaire,sdc,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.11
+Requires-Dist: fhirpy-types-r4b>=0.1.1
+Requires-Dist: fhirpy>=2.2.0
+Description-Content-Type: text/markdown
+
+# fhir-sdc-testkit
+
+Test an SDC Questionnaire and its extraction the way a form is really filled: `$populate` runs, answers are placed at
+each `linkId`'s nesting, then `QuestionnaireResponse/$extract` runs. With `submit=True` the QuestionnaireResponse is
+saved before extraction and the bundle is submitted after it. Only what a user types (or the frontend calculates) is
+faked; everything else runs on
+a real server implementing the [SDC](https://build.fhir.org/ig/HL7/sdc/) operations, such as
+[fhir-sdc](../README.md).
+
+```sh
+pip install fhir-sdc-testkit
+```
+
+It is released from the fhir-sdc repository, with the same version as the fhir-sdc release it is tested against.
+
+## The client
+
+Everything takes an `AsyncFHIRClient` rooted at the server's `/fhir` base, built with `dump_resource` — fhirpy cannot
+serialize pydantic resources without it:
+
+```python
+fhir_client = AsyncFHIRClient(
+    f"{base_url}/fhir",
+    authorization=authorization,
+    dump_resource=lambda resource: resource.model_dump(),
+)
+```
+
+## Usage
+
+```python
+import fhirpy_types_r4b as r4b
+from fhir_sdc_testkit import answer, launch_context, populate_and_extract
+
+
+async def test_intake_records_the_address(fhir_client):
+    patient = await fhir_client.create(r4b.Patient(name=[r4b.HumanName(family="Test")]))
+
+    await populate_and_extract(
+        fhir_client,
+        "patient-intake",
+        parameters=launch_context(
+            {"Patient": patient}, subject=r4b.Reference(reference=f"Patient/{patient.id}")
+        ),
+        answers={"postal-code": [answer(valueString="75001")]},
+        submit=True,
+    )
+
+    updated = await fhir_client.get(r4b.Patient, patient.id)
+    assert updated.address[0].postalCode == "75001"
+```
+
+`populate_and_extract` returns the QuestionnaireResponse and the bundle `$extract` returned (`None` when there is
+nothing to extract). Without `submit` neither is saved, so the bundle can be asserted on directly. With it, the
+response is the saved one — saved first, since a Mapping may reference it by id — and the bundle has been submitted.
+
+`populate` and `extract` run the two operations on their own and save nothing.
+
+### Answers
+
+Keys are `linkId`s, addressed flatly — groups in between are created for you:
+
+```python
+answers={
+    "country": [answer(valueCoding=r4b.Coding(code="FR"))],
+    "postal-code": [answer(valueString="75001")],
+}
+```
+
+A repeating group takes one answer set per occurrence, filled positionally over the occurrences `$populate` produced,
+appending any that are missing and leaving extra populated ones alone:
+
+```python
+answers={
+    "contacts": [
+        {"phone": [answer(valueString="+1 555 0100")], "label": [answer(valueString="home")]},
+        {"phone": [answer(valueString="+1 555 0111")], "label": [answer(valueString="work")]},
+    ],
+}
+```
+
+Inside a set, `linkId`s are flat again. A `linkId` that does not belong to the group raises, naming it.
+
+### Parameters
+
+`parameters` is required: it is passed to `$populate` and merged into the `$extract` call, so anything the server
+accepts can go in it. `launch_context()` builds the SDC `$populate` input — a resource or a `Reference` under each
+context name, and the optional `subject`. Pass at least one of them: a `$populate` reply that is not `Parameters`
+raises `ValueError`.
+
+```python
+parameters=launch_context({"Patient": patient, "Author": r4b.Reference(reference="Practitioner/1")})
+```
+
+A list under a name builds one `context` with a `content` part per value, as SDC defines it. fhir-sdc uses only the
+first `content` for now.
+
+## Failures
+
+An error response from the server raises fhirpy's exception for its status — `OperationOutcome` for most 4xx and 5xx
+responses. A violated `itemConstraint` the server checks during `$extract` and a rejected transaction both arrive this
+way; they differ in `issue[].code`. fhir-sdc reports a constraint's `key`, and a server's own validation code, such as
+`invalid`, for a transaction. An `error` or `fatal` issue in the `$extract` result and, with `submit`, a batch entry
+the server rejects raise `ExtractionError`.
+
+```python
+with pytest.raises(OperationOutcome) as refused:
+    await populate_and_extract(fhir_client, "patient-intake", parameters=parameters, answers=answers)
+assert refused.value.resource["issue"][0]["code"] == "postal-code-required"
+```
+
+## Development
+
+```sh
+uv sync
+uv run pytest
+uv run ruff format . && uv run ruff check . && uv run mypy
+```
+
+That suite runs without a server. `$populate`, constraints and extraction are covered against a running Aidbox and
+fhir-sdc by `tests/testkit/` in the repository root — `./run_test.sh tests/testkit`.

fhir_sdc_testkit-3.0.0a1/README.md

@@ -0,0 +1,121 @@
+# fhir-sdc-testkit
+
+Test an SDC Questionnaire and its extraction the way a form is really filled: `$populate` runs, answers are placed at
+each `linkId`'s nesting, then `QuestionnaireResponse/$extract` runs. With `submit=True` the QuestionnaireResponse is
+saved before extraction and the bundle is submitted after it. Only what a user types (or the frontend calculates) is
+faked; everything else runs on
+a real server implementing the [SDC](https://build.fhir.org/ig/HL7/sdc/) operations, such as
+[fhir-sdc](../README.md).
+
+```sh
+pip install fhir-sdc-testkit
+```
+
+It is released from the fhir-sdc repository, with the same version as the fhir-sdc release it is tested against.
+
+## The client
+
+Everything takes an `AsyncFHIRClient` rooted at the server's `/fhir` base, built with `dump_resource` — fhirpy cannot
+serialize pydantic resources without it:
+
+```python
+fhir_client = AsyncFHIRClient(
+    f"{base_url}/fhir",
+    authorization=authorization,
+    dump_resource=lambda resource: resource.model_dump(),
+)
+```
+
+## Usage
+
+```python
+import fhirpy_types_r4b as r4b
+from fhir_sdc_testkit import answer, launch_context, populate_and_extract
+
+
+async def test_intake_records_the_address(fhir_client):
+    patient = await fhir_client.create(r4b.Patient(name=[r4b.HumanName(family="Test")]))
+
+    await populate_and_extract(
+        fhir_client,
+        "patient-intake",
+        parameters=launch_context(
+            {"Patient": patient}, subject=r4b.Reference(reference=f"Patient/{patient.id}")
+        ),
+        answers={"postal-code": [answer(valueString="75001")]},
+        submit=True,
+    )
+
+    updated = await fhir_client.get(r4b.Patient, patient.id)
+    assert updated.address[0].postalCode == "75001"
+```
+
+`populate_and_extract` returns the QuestionnaireResponse and the bundle `$extract` returned (`None` when there is
+nothing to extract). Without `submit` neither is saved, so the bundle can be asserted on directly. With it, the
+response is the saved one — saved first, since a Mapping may reference it by id — and the bundle has been submitted.
+
+`populate` and `extract` run the two operations on their own and save nothing.
+
+### Answers
+
+Keys are `linkId`s, addressed flatly — groups in between are created for you:
+
+```python
+answers={
+    "country": [answer(valueCoding=r4b.Coding(code="FR"))],
+    "postal-code": [answer(valueString="75001")],
+}
+```
+
+A repeating group takes one answer set per occurrence, filled positionally over the occurrences `$populate` produced,
+appending any that are missing and leaving extra populated ones alone:
+
+```python
+answers={
+    "contacts": [
+        {"phone": [answer(valueString="+1 555 0100")], "label": [answer(valueString="home")]},
+        {"phone": [answer(valueString="+1 555 0111")], "label": [answer(valueString="work")]},
+    ],
+}
+```
+
+Inside a set, `linkId`s are flat again. A `linkId` that does not belong to the group raises, naming it.
+
+### Parameters
+
+`parameters` is required: it is passed to `$populate` and merged into the `$extract` call, so anything the server
+accepts can go in it. `launch_context()` builds the SDC `$populate` input — a resource or a `Reference` under each
+context name, and the optional `subject`. Pass at least one of them: a `$populate` reply that is not `Parameters`
+raises `ValueError`.
+
+```python
+parameters=launch_context({"Patient": patient, "Author": r4b.Reference(reference="Practitioner/1")})
+```
+
+A list under a name builds one `context` with a `content` part per value, as SDC defines it. fhir-sdc uses only the
+first `content` for now.
+
+## Failures
+
+An error response from the server raises fhirpy's exception for its status — `OperationOutcome` for most 4xx and 5xx
+responses. A violated `itemConstraint` the server checks during `$extract` and a rejected transaction both arrive this
+way; they differ in `issue[].code`. fhir-sdc reports a constraint's `key`, and a server's own validation code, such as
+`invalid`, for a transaction. An `error` or `fatal` issue in the `$extract` result and, with `submit`, a batch entry
+the server rejects raise `ExtractionError`.
+
+```python
+with pytest.raises(OperationOutcome) as refused:
+    await populate_and_extract(fhir_client, "patient-intake", parameters=parameters, answers=answers)
+assert refused.value.resource["issue"][0]["code"] == "postal-code-required"
+```
+
+## Development
+
+```sh
+uv sync
+uv run pytest
+uv run ruff format . && uv run ruff check . && uv run mypy
+```
+
+That suite runs without a server. `$populate`, constraints and extraction are covered against a running Aidbox and
+fhir-sdc by `tests/testkit/` in the repository root — `./run_test.sh tests/testkit`.

fhir_sdc_testkit-3.0.0a1/fhir_sdc_testkit/__init__.py

@@ -0,0 +1,14 @@
+from fhir_sdc_testkit.extraction import ExtractionError
+from fhir_sdc_testkit.forms import extract, populate, populate_and_extract
+from fhir_sdc_testkit.sugar import Answers, LaunchContext, answer, launch_context
+
+__all__ = [
+    "Answers",
+    "ExtractionError",
+    "LaunchContext",
+    "answer",
+    "extract",
+    "launch_context",
+    "populate",
+    "populate_and_extract",
+]

fhir_sdc_testkit-3.0.0a1/fhir_sdc_testkit/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '3.0.0a1'
+__version_tuple__ = version_tuple = (3, 0, 0, 'a1')
+
+__commit_id__ = commit_id = None

fhir_sdc_testkit-3.0.0a1/fhir_sdc_testkit/extraction.py

@@ -0,0 +1,48 @@
+"""Raising for a failed SDC `QuestionnaireResponse/$extract` and for a rejected submission."""
+
+from collections.abc import Mapping
+from typing import Any
+
+import fhirpy_types_r4b as r4b
+
+# $extract returns what the mappers created, which may be resources R4B does not model.
+Json = Mapping[str, Any]
+FAILED_SEVERITIES = ("error", "fatal")
+SUCCESSFUL_CODES = range(200, 300)
+
+
+class ExtractionError(Exception):
+    """A failure the server reported in a successful response."""
+
+
+def raise_for_failed_issues(extracted: Json) -> None:
+    """SDC puts hints and warnings in `issues` on success, so only error and fatal are failures."""
+    for parameter in extracted.get("parameter") or []:
+        if parameter["name"] == "issues":
+            issues = r4b.OperationOutcome.model_validate(parameter["resource"]).issue
+            failures = [issue for issue in issues if issue.severity in FAILED_SEVERITIES]
+            if failures:
+                raise ExtractionError(str(failures))
+
+
+def find_bundle_to_submit(extracted: Json) -> dict[str, Any] | None:
+    return next(
+        (
+            parameter["resource"]
+            for parameter in extracted.get("parameter") or []
+            if parameter["name"] == "return"
+        ),
+        None,
+    )
+
+
+def raise_for_rejected_entries(bundle: Json) -> None:
+    """A batch reports a rejected entry in the entry's response, under HTTP 200 for the bundle."""
+    for entry in bundle.get("entry") or []:
+        if not is_successful_status(entry["response"]["status"]):
+            raise ExtractionError(f"{entry.get('request', {})} -> {entry['response']}")
+
+
+def is_successful_status(status: str) -> bool:
+    """An entry status leads with the HTTP code, as in `201 Created`."""
+    return int(status.split(maxsplit=1)[0]) in SUCCESSFUL_CODES

fhir_sdc_testkit-3.0.0a1/fhir_sdc_testkit/forms.py

@@ -0,0 +1,202 @@
+"""Only user-entered answers are faked; $populate, constraints and the Mapping run for real."""
+
+from collections.abc import Mapping, Sequence
+from typing import Any, NamedTuple, cast
+
+import fhirpy_types_r4b as r4b
+from fhirpy import AsyncFHIRClient
+
+from fhir_sdc_testkit.extraction import (
+    find_bundle_to_submit,
+    raise_for_failed_issues,
+    raise_for_rejected_entries,
+)
+from fhir_sdc_testkit.sugar import Answers
+
+
+class ItemPath(NamedTuple):
+    path: tuple[str, ...]
+    item: r4b.QuestionnaireItem
+
+
+async def populate_and_extract(
+    fhir_client: AsyncFHIRClient,
+    questionnaire_id: str,
+    *,
+    parameters: r4b.Parameters,
+    answers: Answers,
+    submit: bool = False,
+) -> tuple[r4b.QuestionnaireResponse, dict[str, Any] | None]:
+    """The filled QuestionnaireResponse and its extracted bundle; `submit` saves both, as a form does."""
+    questionnaire = await fhir_client.get(r4b.Questionnaire, questionnaire_id)
+    populated = await populate(fhir_client, questionnaire_id, parameters=parameters)
+    response = fill_questionnaire_response(questionnaire, populated, answers)
+    if submit:
+        # A Mapping may reference the response by id, so it is saved before extraction.
+        response = await fhir_client.create(response)
+    bundle = await extract(fhir_client, questionnaire, response, parameters=parameters)
+    if submit and bundle is not None:
+        raise_for_rejected_entries(await fhir_client.execute("/", data=bundle))
+    return response, bundle
+
+
+async def populate(
+    fhir_client: AsyncFHIRClient, questionnaire_id: str, *, parameters: r4b.Parameters
+) -> r4b.QuestionnaireResponse:
+    """SDC `Questionnaire/{id}/$populate`: the populated response, not saved."""
+    populated = await fhir_client.execute(
+        f"Questionnaire/{questionnaire_id}/$populate", data=parameters.model_dump()
+    )
+    return get_populated_response(populated)
+
+
+def get_populated_response(populated: Mapping[str, Any]) -> r4b.QuestionnaireResponse:
+    if populated.get("resourceType") != "Parameters":
+        raise ValueError(
+            f"$populate returned {populated.get('resourceType')}, not SDC Parameters: "
+            "pass a subject or a launch context"
+        )
+
+    response = next(p for p in populated["parameter"] if p["name"] == "response")
+    return r4b.QuestionnaireResponse.model_validate(response["resource"])
+
+
+def fill_questionnaire_response(
+    questionnaire: r4b.Questionnaire, populated: r4b.QuestionnaireResponse, answers: Answers
+) -> r4b.QuestionnaireResponse:
+    """Set each answer at its linkId's nesting in the Questionnaire, replacing a populated one."""
+    response = populated.model_copy(deep=True, update={"status": "completed"})
+    children = get_or_create_children(response)
+    fill_items(
+        questionnaire.item or [], children, answers, scope=f"Questionnaire/{questionnaire.id}"
+    )
+    sort_items(questionnaire.item or [], children)
+    return response
+
+
+def fill_items(
+    items: list[r4b.QuestionnaireItem],
+    children: list[r4b.QuestionnaireResponseItem],
+    answers: Answers,
+    *,
+    scope: str,
+) -> None:
+    paths = build_link_id_paths(items)
+    for link_id, value in answers.items():
+        if link_id not in paths:
+            raise KeyError(f"{link_id!r} is not an item of {scope} outside a repeating group")
+
+        path, item = paths[link_id]
+        siblings = find_or_create_siblings(children, path)
+        if is_repeating_group(item):
+            fill_occurrences(item, siblings, cast(Sequence[Answers], value))
+        else:
+            find_or_append_item(siblings, link_id).answer = list(
+                cast(Sequence[r4b.QuestionnaireResponseItemAnswer], value)
+            )
+
+
+def build_link_id_paths(
+    items: list[r4b.QuestionnaireItem], ancestors: tuple[str, ...] = ()
+) -> dict[str, ItemPath]:
+    """linkId → the linkIds from the top-level item down to it. Repeating items are not descended."""
+    paths: dict[str, ItemPath] = {}
+    for item in items:
+        path = (*ancestors, item.linkId)
+        paths[item.linkId] = ItemPath(path, item)
+        if not item.repeats:
+            paths.update(build_link_id_paths(item.item or [], path))
+    return paths
+
+
+def find_or_create_siblings(
+    children: list[r4b.QuestionnaireResponseItem], path: tuple[str, ...]
+) -> list[r4b.QuestionnaireResponseItem]:
+    """The item list holding the path's last linkId, creating the groups above it."""
+    for link_id in path[:-1]:
+        children = get_or_create_children(find_or_append_item(children, link_id))
+    return children
+
+
+def is_repeating_group(item: r4b.QuestionnaireItem) -> bool:
+    return item.type == "group" and bool(item.repeats)
+
+
+def fill_occurrences(
+    group: r4b.QuestionnaireItem,
+    siblings: list[r4b.QuestionnaireResponseItem],
+    answer_sets: Sequence[Answers],
+) -> None:
+    """One answer set per occurrence, positionally over the populated ones. Extra ones are kept."""
+    occurrences = find_or_append_occurrences(siblings, group.linkId, len(answer_sets))
+    for occurrence, answers in zip(occurrences, answer_sets, strict=True):
+        fill_items(
+            group.item or [],
+            get_or_create_children(occurrence),
+            answers,
+            scope=f"repeating group {group.linkId!r}",
+        )
+
+
+def find_or_append_occurrences(
+    children: list[r4b.QuestionnaireResponseItem], link_id: str, count: int
+) -> list[r4b.QuestionnaireResponseItem]:
+    occurrences = [child for child in children if child.linkId == link_id]
+    while len(occurrences) < count:
+        item = r4b.QuestionnaireResponseItem(linkId=link_id)
+        children.append(item)
+        occurrences.append(item)
+    return occurrences[:count]
+
+
+def find_or_append_item(
+    children: list[r4b.QuestionnaireResponseItem], link_id: str
+) -> r4b.QuestionnaireResponseItem:
+    for child in children:
+        if child.linkId == link_id:
+            return child
+
+    item = r4b.QuestionnaireResponseItem(linkId=link_id)
+    children.append(item)
+    return item
+
+
+def get_or_create_children(
+    parent: r4b.QuestionnaireResponse | r4b.QuestionnaireResponseItem,
+) -> list[r4b.QuestionnaireResponseItem]:
+    if parent.item is None:
+        parent.item = []
+    return parent.item
+
+
+def sort_items(
+    items: list[r4b.QuestionnaireItem], children: list[r4b.QuestionnaireResponseItem]
+) -> None:
+    """Answered items are appended as they come; a response follows the Questionnaire's order."""
+    order = {item.linkId: index for index, item in enumerate(items)}
+    children.sort(key=lambda child: order[child.linkId])
+    definitions = {item.linkId: item for item in items}
+    for child in children:
+        if child.item:
+            sort_items(definitions[child.linkId].item or [], child.item)
+
+
+async def extract(
+    fhir_client: AsyncFHIRClient,
+    questionnaire: r4b.Questionnaire,
+    questionnaire_response: r4b.QuestionnaireResponse,
+    *,
+    parameters: r4b.Parameters,
+) -> dict[str, Any] | None:
+    """SDC `QuestionnaireResponse/$extract`: the bundle to submit, not submitted."""
+    extract_parameters = [
+        r4b.ParametersParameter(name="questionnaire", resource=questionnaire),
+        r4b.ParametersParameter(name="questionnaire-response", resource=questionnaire_response),
+        *(parameters.parameter or []),
+    ]
+    extracted = await fhir_client.execute(
+        "QuestionnaireResponse/$extract",
+        data=r4b.Parameters(parameter=extract_parameters).model_dump(),
+    )
+    raise_for_failed_issues(extracted)
+    return find_bundle_to_submit(extracted)

fhir_sdc_testkit-3.0.0a1/fhir_sdc_testkit/sugar.py

@@ -0,0 +1,43 @@
+"""What a test writes: an answer, a set of answers, and the launch context to populate with."""
+
+from collections.abc import Mapping, Sequence
+
+import fhirpy_types_r4b as r4b
+
+answer = r4b.QuestionnaireResponseItemAnswer
+Answers = Mapping[str, "Sequence[r4b.QuestionnaireResponseItemAnswer] | Sequence[Answers]"]
+LaunchContextValue = r4b.AnyResource | r4b.Reference
+LaunchContext = dict[str, "LaunchContextValue | list[LaunchContextValue]"]
+
+
+def launch_context(
+    context: LaunchContext, *, subject: r4b.Reference | None = None
+) -> r4b.Parameters:
+    """SDC `$populate` input: one `context` parameter per name, with a `content` part per value."""
+    parameters = [
+        build_context_parameter(name, values if isinstance(values, list) else [values])
+        for name, values in context.items()
+    ]
+    if subject is not None:
+        parameters.append(r4b.ParametersParameter(name="subject", valueReference=subject))
+    return r4b.Parameters(parameter=parameters)
+
+
+def build_context_parameter(name: str, values: list[LaunchContextValue]) -> r4b.ParametersParameter:
+    if not values:
+        raise ValueError(f"Launch context {name!r} needs at least one value")
+
+    return r4b.ParametersParameter(
+        name="context",
+        part=[
+            r4b.ParametersParameter(name="name", valueString=name),
+            *(build_content_part(value) for value in values),
+        ],
+    )
+
+
+def build_content_part(value: LaunchContextValue) -> r4b.ParametersParameter:
+    if isinstance(value, r4b.Reference):
+        return r4b.ParametersParameter(name="content", valueReference=value)
+
+    return r4b.ParametersParameter(name="content", resource=value)