Skip to content

Builders API Reference

Document and common builders.

Document Builder

ClinicalDocument

Bases: CDAElement

Top-level C-CDA Clinical Document builder.

Functions

__init__(patient, author, custodian, sections=None, document_id=None, title='Clinical Summary', effective_time=None, **kwargs)

Initialize ClinicalDocument builder.

Parameters:

Name Type Description Default
patient PatientProtocol

Patient data satisfying PatientProtocol

 required
author AuthorProtocol

Author data satisfying AuthorProtocol

 required
custodian OrganizationProtocol

Custodian organization data satisfying OrganizationProtocol

 required
sections Optional[Sequence[CDAElement]]

List of section builders (optional)

 None
document_id Optional[str]

Document UUID (generated if not provided)

 None
title str

Document title

 'Clinical Summary'
effective_time Optional[datetime]

Document creation time (current time if not provided)

 None
**kwargs

Additional arguments passed to CDAElement

 {}

build()

Build ClinicalDocument XML element.

Returns:

Type Description
Element

lxml Element for ClinicalDocument

to_xml_string(pretty=True)

Convert to XML string with declaration.

Parameters:

Name Type Description Default
pretty bool

Whether to pretty-print XML

 True

Returns:

Type Description
str

Complete XML document with declaration

Common Builders

Code

Bases: CDAElement

Reusable code element builder.

Source code in ccdakit/builders/common.py 
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
class Code(CDAElement):
    """Reusable code element builder."""

    # Standard code system OIDs
    SYSTEM_OIDS = {
        # Clinical terminology systems
        "LOINC": "2.16.840.1.113883.6.1",
        "SNOMED": "2.16.840.1.113883.6.96",
        "RxNorm": "2.16.840.1.113883.6.88",
        "ICD-10": "2.16.840.1.113883.6.90",
        "ICD-10-CM": "2.16.840.1.113883.6.90",
        "ICD-10-PCS": "2.16.840.1.113883.6.4",
        "ICD-9-CM": "2.16.840.1.113883.6.103",
        "ICD-9-PCS": "2.16.840.1.113883.6.104",
        "CPT": "2.16.840.1.113883.6.12",
        "CVX": "2.16.840.1.113883.12.292",
        "NDC": "2.16.840.1.113883.6.69",
        "HCPCS": "2.16.840.1.113883.6.285",
        "NCI": "2.16.840.1.113883.3.26.1.1",
        "UNII": "2.16.840.1.113883.4.9",
        # Units of measure
        "UCUM": "2.16.840.1.113883.6.8",
        # HL7 vocabulary systems
        "HL7": "2.16.840.1.113883.5.1",
        "ActClass": "2.16.840.1.113883.5.6",
        "ActCode": "2.16.840.1.113883.5.4",
        "ActMood": "2.16.840.1.113883.5.1001",
        "ActStatus": "2.16.840.1.113883.5.14",
        "ObservationInterpretation": "2.16.840.1.113883.5.83",
        "ParticipationType": "2.16.840.1.113883.5.90",
        "RoleClass": "2.16.840.1.113883.5.110",
        "EntityNameUse": "2.16.840.1.113883.5.45",
        "PostalAddressUse": "2.16.840.1.113883.5.1119",
        "TelecomAddressUse": "2.16.840.1.113883.5.1119",
        "MaritalStatus": "2.16.840.1.113883.5.2",
        "ReligiousAffiliation": "2.16.840.1.113883.5.1076",
        "AdministrativeGender": "2.16.840.1.113883.5.1",
        "NullFlavor": "2.16.840.1.113883.5.1008",
        # CDC and demographic systems
        "Race": "2.16.840.1.113883.6.238",
        "Ethnicity": "2.16.840.1.113883.6.238",
        # International standards
        "Language": "2.16.840.1.113883.6.121",
        "ISO3166": "1.0.3166.1.2.2",
        # Healthcare facility and billing
        "NUBC": "2.16.840.1.113883.6.301",
        "DischargeDisposition": "2.16.840.1.113883.12.112",
        "AdmitSource": "2.16.840.1.113883.12.23",
        "ProcedureCode": "2.16.840.1.113883.6.96",
        # Additional HL7 vocabulary
        "RouteOfAdministration": "2.16.840.1.113883.5.112",
        "DoseForm": "2.16.840.1.113883.3.26.1.1",
        "BodySite": "2.16.840.1.113883.6.96",
        "Confidentiality": "2.16.840.1.113883.5.25",
        "EncounterType": "2.16.840.1.113883.5.4",
        "ProblemType": "2.16.840.1.113883.3.88.12.3221.7.2",
        "AllergyCategory": "2.16.840.1.113883.3.88.12.3221.6.2",
        "AllergySeverity": "2.16.840.1.113883.6.96",
        "ReactionSeverity": "2.16.840.1.113883.6.96",
        "MedicationStatus": "2.16.840.1.113883.3.88.12.80.20",
        "VitalSignResult": "2.16.840.1.113883.6.1",
        "LabResultStatus": "2.16.840.1.113883.5.14",
        "ResultInterpretation": "2.16.840.1.113883.5.83",
        "SpecimenType": "2.16.840.1.113883.6.96",
    }

    def __init__(
        self,
        code: Optional[str] = None,
        system: Optional[str] = None,
        display_name: Optional[str] = None,
        null_flavor: Optional[str] = None,
        **kwargs,
    ):
        """
        Initialize Code builder.

        Args:
            code: Code value
            system: Code system (name or OID)
            display_name: Human-readable display name
            null_flavor: Null flavor if code is not available
            **kwargs: Additional arguments passed to CDAElement
        """
        super().__init__(**kwargs)
        self.code = code
        self.system = system
        self.display_name = display_name
        self.null_flavor = null_flavor

    def build(self) -> etree.Element:
        """
        Build code XML element.

        Returns:
            lxml Element for code

        Raises:
            ValueError: If both code and null_flavor are missing
        """
        elem = etree.Element(f"{{{NS}}}code")

        if self.null_flavor:
            elem.set("nullFlavor", self.null_flavor)
        else:
            if not self.code or not self.system:
                raise ValueError("code and system required when null_flavor not provided")

            elem.set("code", self.code)

            # Handle system OID lookup
            if self.system in self.SYSTEM_OIDS:
                elem.set("codeSystem", self.SYSTEM_OIDS[self.system])
                elem.set("codeSystemName", self.system)
            else:
                elem.set("codeSystem", self.system)

            if self.display_name:
                elem.set("displayName", self.display_name)

        return elem

Functions

__init__(code=None, system=None, display_name=None, null_flavor=None, **kwargs)

Initialize Code builder.

Parameters:

Name Type Description Default
code Optional[str]

Code value

 None
system Optional[str]

Code system (name or OID)

 None
display_name Optional[str]

Human-readable display name

 None
null_flavor Optional[str]

Null flavor if code is not available

 None
**kwargs

Additional arguments passed to CDAElement

 {}
Source code in ccdakit/builders/common.py 
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
def __init__(
    self,
    code: Optional[str] = None,
    system: Optional[str] = None,
    display_name: Optional[str] = None,
    null_flavor: Optional[str] = None,
    **kwargs,
):
    """
    Initialize Code builder.

    Args:
        code: Code value
        system: Code system (name or OID)
        display_name: Human-readable display name
        null_flavor: Null flavor if code is not available
        **kwargs: Additional arguments passed to CDAElement
    """
    super().__init__(**kwargs)
    self.code = code
    self.system = system
    self.display_name = display_name
    self.null_flavor = null_flavor

build()

Build code XML element.

Returns:

Type Description
Element

lxml Element for code

Raises:

Type Description
ValueError

If both code and null_flavor are missing
Source code in ccdakit/builders/common.py 
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
def build(self) -> etree.Element:
    """
    Build code XML element.

    Returns:
        lxml Element for code

    Raises:
        ValueError: If both code and null_flavor are missing
    """
    elem = etree.Element(f"{{{NS}}}code")

    if self.null_flavor:
        elem.set("nullFlavor", self.null_flavor)
    else:
        if not self.code or not self.system:
            raise ValueError("code and system required when null_flavor not provided")

        elem.set("code", self.code)

        # Handle system OID lookup
        if self.system in self.SYSTEM_OIDS:
            elem.set("codeSystem", self.SYSTEM_OIDS[self.system])
            elem.set("codeSystemName", self.system)
        else:
            elem.set("codeSystem", self.system)

        if self.display_name:
            elem.set("displayName", self.display_name)

    return elem

EffectiveTime

Bases: CDAElement

Reusable effectiveTime element with support for points and intervals.

Source code in ccdakit/builders/common.py 
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
class EffectiveTime(CDAElement):
    """Reusable effectiveTime element with support for points and intervals."""

    def __init__(
        self,
        value: Optional[datetime] = None,
        low: Optional[datetime] = None,
        high: Optional[datetime] = None,
        null_flavor: Optional[str] = None,
        **kwargs,
    ):
        """
        Initialize EffectiveTime builder.

        Args:
            value: Point in time
            low: Start of interval
            high: End of interval
            null_flavor: Null flavor if time is not available
            **kwargs: Additional arguments passed to CDAElement
        """
        super().__init__(**kwargs)
        self.value = value
        self.low = low
        self.high = high
        self.null_flavor = null_flavor

    def build(self) -> etree.Element:
        """
        Build effectiveTime XML element.

        Returns:
            lxml Element for effectiveTime
        """
        elem = etree.Element(f"{{{NS}}}effectiveTime")

        if self.null_flavor:
            elem.set("nullFlavor", self.null_flavor)
        elif self.value:
            # Point in time
            elem.set("value", self._format_datetime(self.value))
        else:
            # Interval
            if self.low:
                low = etree.SubElement(elem, f"{{{NS}}}low")
                low.set("value", self._format_datetime(self.low))

            if self.high:
                high = etree.SubElement(elem, f"{{{NS}}}high")
                high.set("value", self._format_datetime(self.high))
            elif self.low and not self.high:
                # Ongoing - use nullFlavor for high
                high = etree.SubElement(elem, f"{{{NS}}}high")
                high.set("nullFlavor", "UNK")

        return elem

    @staticmethod
    def _format_datetime(dt: datetime) -> str:
        """
        Format datetime to CDA format: YYYYMMDDHHMMSS.

        Args:
            dt: datetime or date object

        Returns:
            Formatted string
        """
        if isinstance(dt, date) and not isinstance(dt, datetime):
            # Date only
            return dt.strftime("%Y%m%d")
        # Full datetime with precision
        return dt.strftime("%Y%m%d%H%M%S")

Functions

__init__(value=None, low=None, high=None, null_flavor=None, **kwargs)

Initialize EffectiveTime builder.

Parameters:

Name Type Description Default
value Optional[datetime]

Point in time

 None
low Optional[datetime]

Start of interval

 None
high Optional[datetime]

End of interval

 None
null_flavor Optional[str]

Null flavor if time is not available

 None
**kwargs

Additional arguments passed to CDAElement

 {}
Source code in ccdakit/builders/common.py 
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
def __init__(
    self,
    value: Optional[datetime] = None,
    low: Optional[datetime] = None,
    high: Optional[datetime] = None,
    null_flavor: Optional[str] = None,
    **kwargs,
):
    """
    Initialize EffectiveTime builder.

    Args:
        value: Point in time
        low: Start of interval
        high: End of interval
        null_flavor: Null flavor if time is not available
        **kwargs: Additional arguments passed to CDAElement
    """
    super().__init__(**kwargs)
    self.value = value
    self.low = low
    self.high = high
    self.null_flavor = null_flavor

build()

Build effectiveTime XML element.

Returns:

Type Description
Element

lxml Element for effectiveTime
Source code in ccdakit/builders/common.py 
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
def build(self) -> etree.Element:
    """
    Build effectiveTime XML element.

    Returns:
        lxml Element for effectiveTime
    """
    elem = etree.Element(f"{{{NS}}}effectiveTime")

    if self.null_flavor:
        elem.set("nullFlavor", self.null_flavor)
    elif self.value:
        # Point in time
        elem.set("value", self._format_datetime(self.value))
    else:
        # Interval
        if self.low:
            low = etree.SubElement(elem, f"{{{NS}}}low")
            low.set("value", self._format_datetime(self.low))

        if self.high:
            high = etree.SubElement(elem, f"{{{NS}}}high")
            high.set("value", self._format_datetime(self.high))
        elif self.low and not self.high:
            # Ongoing - use nullFlavor for high
            high = etree.SubElement(elem, f"{{{NS}}}high")
            high.set("nullFlavor", "UNK")

    return elem

Identifier

Bases: CDAElement

Reusable ID element builder.

Source code in ccdakit/builders/common.py 
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
class Identifier(CDAElement):
    """Reusable ID element builder."""

    def __init__(
        self,
        root: str,
        extension: Optional[str] = None,
        null_flavor: Optional[str] = None,
        **kwargs,
    ):
        """
        Initialize Identifier builder.

        Args:
            root: OID or UUID root
            extension: Extension within the root namespace
            null_flavor: Null flavor if ID is not available
            **kwargs: Additional arguments passed to CDAElement
        """
        super().__init__(**kwargs)
        self.root = root
        self.extension = extension
        self.null_flavor = null_flavor

    def build(self) -> etree.Element:
        """
        Build id XML element.

        Returns:
            lxml Element for id
        """
        elem = etree.Element(f"{{{NS}}}id")

        if self.null_flavor:
            elem.set("nullFlavor", self.null_flavor)
        else:
            elem.set("root", self.root)
            if self.extension:
                elem.set("extension", self.extension)

        return elem

Functions

__init__(root, extension=None, null_flavor=None, **kwargs)

Initialize Identifier builder.

Parameters:

Name Type Description Default
root str

OID or UUID root

 required
extension Optional[str]

Extension within the root namespace

 None
null_flavor Optional[str]

Null flavor if ID is not available

 None
**kwargs

Additional arguments passed to CDAElement

 {}
Source code in ccdakit/builders/common.py 
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
def __init__(
    self,
    root: str,
    extension: Optional[str] = None,
    null_flavor: Optional[str] = None,
    **kwargs,
):
    """
    Initialize Identifier builder.

    Args:
        root: OID or UUID root
        extension: Extension within the root namespace
        null_flavor: Null flavor if ID is not available
        **kwargs: Additional arguments passed to CDAElement
    """
    super().__init__(**kwargs)
    self.root = root
    self.extension = extension
    self.null_flavor = null_flavor

build()

Build id XML element.

Returns:

Type Description
Element

lxml Element for id
Source code in ccdakit/builders/common.py 
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
def build(self) -> etree.Element:
    """
    Build id XML element.

    Returns:
        lxml Element for id
    """
    elem = etree.Element(f"{{{NS}}}id")

    if self.null_flavor:
        elem.set("nullFlavor", self.null_flavor)
    else:
        elem.set("root", self.root)
        if self.extension:
            elem.set("extension", self.extension)

    return elem

StatusCode

Bases: CDAElement

Reusable statusCode element builder.

Source code in ccdakit/builders/common.py 
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
class StatusCode(CDAElement):
    """Reusable statusCode element builder."""

    def __init__(self, code: str, **kwargs):
        """
        Initialize StatusCode builder.

        Args:
            code: Status code value (e.g., 'completed', 'active')
            **kwargs: Additional arguments passed to CDAElement
        """
        super().__init__(**kwargs)
        self.code = code

    def build(self) -> etree.Element:
        """
        Build statusCode XML element.

        Returns:
            lxml Element for statusCode
        """
        elem = etree.Element(f"{{{NS}}}statusCode")
        elem.set("code", self.code)
        return elem

Functions

__init__(code, **kwargs)

Initialize StatusCode builder.

Parameters:

Name Type Description Default
code str

Status code value (e.g., 'completed', 'active')

 required
**kwargs

Additional arguments passed to CDAElement

 {}
Source code in ccdakit/builders/common.py 
259
260
261
262
263
264
265
266
267
268
def __init__(self, code: str, **kwargs):
    """
    Initialize StatusCode builder.

    Args:
        code: Status code value (e.g., 'completed', 'active')
        **kwargs: Additional arguments passed to CDAElement
    """
    super().__init__(**kwargs)
    self.code = code

build()

Build statusCode XML element.

Returns:

Type Description
Element

lxml Element for statusCode
Source code in ccdakit/builders/common.py 
270
271
272
273
274
275
276
277
278
279
def build(self) -> etree.Element:
    """
    Build statusCode XML element.

    Returns:
        lxml Element for statusCode
    """
    elem = etree.Element(f"{{{NS}}}statusCode")
    elem.set("code", self.code)
    return elem

Demographic Builders

Address

Bases: CDAElement

Builder for CDA address elements.

Source code in ccdakit/builders/demographics.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
class Address(CDAElement):
    """Builder for CDA address elements."""

    # HL7 AddressUse codes
    USE_CODES = {
        "home": "HP",  # Primary home
        "work": "WP",  # Work place
        "temp": "TMP",  # Temporary
        "old": "OLD",  # No longer in use
        "physical": "PHYS",  # Physical visit address
        "postal": "PST",  # Postal address
    }

    def __init__(self, address: AddressProtocol, use: str = None, **kwargs):
        """
        Initialize Address builder.

        Args:
            address: Address data satisfying AddressProtocol
            use: Use code ('home', 'work', etc.) or HL7 code directly
            **kwargs: Additional arguments passed to CDAElement
        """
        super().__init__(**kwargs)
        self.address = address
        self.use = use

    def build(self) -> etree.Element:
        """
        Build address XML element.

        Returns:
            lxml Element for addr
        """
        elem = etree.Element(f"{{{NS}}}addr")

        # Add use attribute if specified
        if self.use:
            use_code = self.USE_CODES.get(self.use, self.use)
            elem.set("use", use_code)

        # Add street lines
        for line in self.address.street_lines:
            street = etree.SubElement(elem, f"{{{NS}}}streetAddressLine")
            street.text = line

        # Add city
        city = etree.SubElement(elem, f"{{{NS}}}city")
        city.text = self.address.city

        # Add state
        state = etree.SubElement(elem, f"{{{NS}}}state")
        state.text = self.address.state

        # Add postal code
        postal = etree.SubElement(elem, f"{{{NS}}}postalCode")
        postal.text = self.address.postal_code

        # Add country
        country = etree.SubElement(elem, f"{{{NS}}}country")
        country.text = self.address.country

        return elem

Functions

__init__(address, use=None, **kwargs)

Initialize Address builder.

Parameters:

Name Type Description Default
address AddressProtocol

Address data satisfying AddressProtocol

 required
use str

Use code ('home', 'work', etc.) or HL7 code directly

 None
**kwargs

Additional arguments passed to CDAElement

 {}
Source code in ccdakit/builders/demographics.py 
26
27
28
29
30
31
32
33
34
35
36
37
def __init__(self, address: AddressProtocol, use: str = None, **kwargs):
    """
    Initialize Address builder.

    Args:
        address: Address data satisfying AddressProtocol
        use: Use code ('home', 'work', etc.) or HL7 code directly
        **kwargs: Additional arguments passed to CDAElement
    """
    super().__init__(**kwargs)
    self.address = address
    self.use = use

build()

Build address XML element.

Returns:

Type Description
Element

lxml Element for addr
Source code in ccdakit/builders/demographics.py 
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
def build(self) -> etree.Element:
    """
    Build address XML element.

    Returns:
        lxml Element for addr
    """
    elem = etree.Element(f"{{{NS}}}addr")

    # Add use attribute if specified
    if self.use:
        use_code = self.USE_CODES.get(self.use, self.use)
        elem.set("use", use_code)

    # Add street lines
    for line in self.address.street_lines:
        street = etree.SubElement(elem, f"{{{NS}}}streetAddressLine")
        street.text = line

    # Add city
    city = etree.SubElement(elem, f"{{{NS}}}city")
    city.text = self.address.city

    # Add state
    state = etree.SubElement(elem, f"{{{NS}}}state")
    state.text = self.address.state

    # Add postal code
    postal = etree.SubElement(elem, f"{{{NS}}}postalCode")
    postal.text = self.address.postal_code

    # Add country
    country = etree.SubElement(elem, f"{{{NS}}}country")
    country.text = self.address.country

    return elem

Telecom

Bases: CDAElement

Builder for CDA telecom (contact) elements.

Source code in ccdakit/builders/demographics.py 
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
class Telecom(CDAElement):
    """Builder for CDA telecom (contact) elements."""

    # HL7 TelecomUse codes
    USE_CODES = {
        "home": "HP",  # Primary home
        "work": "WP",  # Work place
        "mobile": "MC",  # Mobile contact
        "emergency": "EC",  # Emergency contact
    }

    def __init__(self, telecom: TelecomProtocol, **kwargs):
        """
        Initialize Telecom builder.

        Args:
            telecom: Telecom data satisfying TelecomProtocol
            **kwargs: Additional arguments passed to CDAElement
        """
        super().__init__(**kwargs)
        self.telecom = telecom

    def build(self) -> etree.Element:
        """
        Build telecom XML element.

        Returns:
            lxml Element for telecom
        """
        elem = etree.Element(f"{{{NS}}}telecom")

        # Build value based on type
        value = self._build_value()
        elem.set("value", value)

        # Add use attribute if specified
        if self.telecom.use:
            use_code = self.USE_CODES.get(self.telecom.use, self.telecom.use)
            elem.set("use", use_code)

        return elem

    def _build_value(self) -> str:
        """
        Build the value attribute based on telecom type.

        Returns:
            Formatted value string (e.g., 'tel:+1-617-555-1234', 'mailto:[email protected]')
        """
        telecom_type = self.telecom.type.lower()
        value = self.telecom.value

        if telecom_type == "phone":
            # Format: tel:+1-555-555-5555
            return f"tel:{value}"
        elif telecom_type == "fax":
            # Format: fax:+1-555-555-5555
            return f"tel:{value}"
        elif telecom_type == "email":
            # Format: mailto:[email protected]
            return f"mailto:{value}"
        elif telecom_type == "url":
            # Format: http://example.com or https://example.com
            if not value.startswith(("http://", "https://")):
                return f"http://{value}"
            return value
        else:
            # Default: return as-is
            return value

Functions

__init__(telecom, **kwargs)

Initialize Telecom builder.

Parameters:

Name Type Description Default
telecom TelecomProtocol

Telecom data satisfying TelecomProtocol

 required
**kwargs

Additional arguments passed to CDAElement

 {}
Source code in ccdakit/builders/demographics.py 
88
89
90
91
92
93
94
95
96
97
def __init__(self, telecom: TelecomProtocol, **kwargs):
    """
    Initialize Telecom builder.

    Args:
        telecom: Telecom data satisfying TelecomProtocol
        **kwargs: Additional arguments passed to CDAElement
    """
    super().__init__(**kwargs)
    self.telecom = telecom

build()

Build telecom XML element.

Returns:

Type Description
Element

lxml Element for telecom
Source code in ccdakit/builders/demographics.py 
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
def build(self) -> etree.Element:
    """
    Build telecom XML element.

    Returns:
        lxml Element for telecom
    """
    elem = etree.Element(f"{{{NS}}}telecom")

    # Build value based on type
    value = self._build_value()
    elem.set("value", value)

    # Add use attribute if specified
    if self.telecom.use:
        use_code = self.USE_CODES.get(self.telecom.use, self.telecom.use)
        elem.set("use", use_code)

    return elem

Header Builders

Header builders are used internally by the ClinicalDocument builder.

See the ClinicalDocument API for usage.