Skip to content

Conversion

FHIRPath defines both implicit and explicit conversion. Implicit conversions occur automatically, as opposed to explicit conversions that require a function in this section to be called explicitly.

ConvertsToBoolean

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath convertsToBoolean() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
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
class ConvertsToBoolean(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`convertsToBoolean()`](http://hl7.org/fhirpath/N1/#convertstoboolean-boolean) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        If the input collection contains a single item, this function will return `True` if the item can be converted to a Boolean, `False` otherwise.
        If the input collection is empty, the result is empty.

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.
        """
        self.validate_collection(collection)
        if not collection:
            return []
        return [
            FHIRPathCollectionItem.wrap(
                ToBoolean().evaluate(collection, environment, create) != []
            )
        ]

evaluate(collection, environment, create=False)

If the input collection contains a single item, this function will return True if the item can be converted to a Boolean, False otherwise. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
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
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    If the input collection contains a single item, this function will return `True` if the item can be converted to a Boolean, `False` otherwise.
    If the input collection is empty, the result is empty.

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.
    """
    self.validate_collection(collection)
    if not collection:
        return []
    return [
        FHIRPathCollectionItem.wrap(
            ToBoolean().evaluate(collection, environment, create) != []
        )
    ]

ConvertsToDate

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath convertsToDate() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
class ConvertsToDate(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`convertsToDate()`](http://hl7.org/fhirpath/N1/#convertstodate-boolean) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        If the input collection contains a single item, this function will return `True` if:
            - the item is a `Date`
            - the item is a `DateTime`
            - the item is a `String` and is convertible to a `Date`
        If the item is not one of the above types, or is not convertible to a `Date` (using the format `YYYY-MM-DD`), the result is `False`.
        If the item contains a partial date (e.g. `'2012-01'`), the result is a partial date.
        If the input collection is empty, the result is empty.

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.
        """
        self.validate_collection(collection)
        if not collection:
            return []
        return [
            FHIRPathCollectionItem.wrap(
                ToDate().evaluate(collection, environment, create) != []
            )
        ]

evaluate(collection, environment, create=False)

If the input collection contains a single item, this function will return True if: - the item is a Date - the item is a DateTime - the item is a String and is convertible to a Date If the item is not one of the above types, or is not convertible to a Date (using the format YYYY-MM-DD), the result is False. If the item contains a partial date (e.g. '2012-01'), the result is a partial date. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    If the input collection contains a single item, this function will return `True` if:
        - the item is a `Date`
        - the item is a `DateTime`
        - the item is a `String` and is convertible to a `Date`
    If the item is not one of the above types, or is not convertible to a `Date` (using the format `YYYY-MM-DD`), the result is `False`.
    If the item contains a partial date (e.g. `'2012-01'`), the result is a partial date.
    If the input collection is empty, the result is empty.

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.
    """
    self.validate_collection(collection)
    if not collection:
        return []
    return [
        FHIRPathCollectionItem.wrap(
            ToDate().evaluate(collection, environment, create) != []
        )
    ]

ConvertsToDateTime

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath convertsToDateTime() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
class ConvertsToDateTime(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`convertsToDateTime()`](http://hl7.org/fhirpath/N1/#convertstodatetime-boolean) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        If the input collection contains a single item, this function will return `True` if:
            - the item is a `DateTime`
            - the item is a `Date`, in which case the result is a `DateTime` with the year, month, and day of the `Date`, and the time components empty (not set to zero)
            - the item is a `String` and is convertible to a `DateTime`
        If the item is a `String`, but the string is not convertible to a `DateTime` (using the format `YYYY-MM-DDThh:mm:ss.fff(+|-)hh:mm`), the result is `False`.
        If the item contains a partial datetime (e.g. `'2012-01-01T10:00'`), the result is 'True'.
        If the input collection is empty, the result is empty.

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.
        """
        self.validate_collection(collection)
        if not collection:
            return []
        return [
            FHIRPathCollectionItem.wrap(
                ToDateTime().evaluate(collection, environment, create) != []
            )
        ]

evaluate(collection, environment, create=False)

If the input collection contains a single item, this function will return True if: - the item is a DateTime - the item is a Date, in which case the result is a DateTime with the year, month, and day of the Date, and the time components empty (not set to zero) - the item is a String and is convertible to a DateTime If the item is a String, but the string is not convertible to a DateTime (using the format YYYY-MM-DDThh:mm:ss.fff(+|-)hh:mm), the result is False. If the item contains a partial datetime (e.g. '2012-01-01T10:00'), the result is 'True'. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    If the input collection contains a single item, this function will return `True` if:
        - the item is a `DateTime`
        - the item is a `Date`, in which case the result is a `DateTime` with the year, month, and day of the `Date`, and the time components empty (not set to zero)
        - the item is a `String` and is convertible to a `DateTime`
    If the item is a `String`, but the string is not convertible to a `DateTime` (using the format `YYYY-MM-DDThh:mm:ss.fff(+|-)hh:mm`), the result is `False`.
    If the item contains a partial datetime (e.g. `'2012-01-01T10:00'`), the result is 'True'.
    If the input collection is empty, the result is empty.

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.
    """
    self.validate_collection(collection)
    if not collection:
        return []
    return [
        FHIRPathCollectionItem.wrap(
            ToDateTime().evaluate(collection, environment, create) != []
        )
    ]

ConvertsToDecimal

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath convertsToDecimal() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
class ConvertsToDecimal(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`convertsToDecimal()`](http://hl7.org/fhirpath/N1/#convertstodecimal-boolean) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        If the input collection contains a single item, this function will return `True` if:
            - the item is an `Integer` or `Decimal`
            - the item is a `String` and is convertible to a `Decimal`
            - the item is a `Boolean`, where `True` results in a `1.0` and `False` results in a `0.0`.
        If the item is not one of the above types, or is not convertible to a `Decimal`, the result is `False`.
        If the input collection is empty, the result is empty ('[]').

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.
        """
        self.validate_collection(collection)
        if not collection:
            return []
        return [
            FHIRPathCollectionItem.wrap(
                ToDecimal().evaluate(collection, environment, create) != []
            )
        ]

evaluate(collection, environment, create=False)

If the input collection contains a single item, this function will return True if: - the item is an Integer or Decimal - the item is a String and is convertible to a Decimal - the item is a Boolean, where True results in a 1.0 and False results in a 0.0. If the item is not one of the above types, or is not convertible to a Decimal, the result is False. If the input collection is empty, the result is empty ('[]').

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    If the input collection contains a single item, this function will return `True` if:
        - the item is an `Integer` or `Decimal`
        - the item is a `String` and is convertible to a `Decimal`
        - the item is a `Boolean`, where `True` results in a `1.0` and `False` results in a `0.0`.
    If the item is not one of the above types, or is not convertible to a `Decimal`, the result is `False`.
    If the input collection is empty, the result is empty ('[]').

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.
    """
    self.validate_collection(collection)
    if not collection:
        return []
    return [
        FHIRPathCollectionItem.wrap(
            ToDecimal().evaluate(collection, environment, create) != []
        )
    ]

ConvertsToInteger

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath convertsToInteger() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
class ConvertsToInteger(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`convertsToInteger()`](http://hl7.org/fhirpath/N1/#convertstointeger-boolean) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        If the input collection contains a single item, this function will return `True` if the item can be converted to an Integer, `False` otherwise.
        If the input collection is empty, the result is empty.

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.

        """
        self.validate_collection(collection)
        if not collection:
            return []
        return [
            FHIRPathCollectionItem.wrap(
                ToInteger().evaluate(collection, environment, create) != []
            )
        ]

evaluate(collection, environment, create=False)

If the input collection contains a single item, this function will return True if the item can be converted to an Integer, False otherwise. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    If the input collection contains a single item, this function will return `True` if the item can be converted to an Integer, `False` otherwise.
    If the input collection is empty, the result is empty.

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.

    """
    self.validate_collection(collection)
    if not collection:
        return []
    return [
        FHIRPathCollectionItem.wrap(
            ToInteger().evaluate(collection, environment, create) != []
        )
    ]

ConvertsToQuantity

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath convertsToQuantity() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
class ConvertsToQuantity(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`convertsToQuantity()`](http://hl7.org/fhirpath/N1/#convertstoquantity-boolean) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        If the input collection contains a single item, this function will return `True` if:
            - the item is an `Integer`, or `Decimal`, where the resulting quantity will have the default unit (`'1'`)
            - the item is a `Quantity`
            - the item is a `String` and is convertible to a `Quantity`
            - the item is a `Boolean`, where true results in the quantity `1.0 '1'`, and false results in the quantity `0.0 '1'`
        If the item is not one of the above types, the result is `False`.
        If the input collection is empty, the result is empty.

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.
        """
        self.validate_collection(collection)
        if not collection:
            return []
        return [
            FHIRPathCollectionItem.wrap(
                ToQuantity().evaluate(collection, environment, create) != []
            )
        ]

evaluate(collection, environment, create=False)

If the input collection contains a single item, this function will return True if: - the item is an Integer, or Decimal, where the resulting quantity will have the default unit ('1') - the item is a Quantity - the item is a String and is convertible to a Quantity - the item is a Boolean, where true results in the quantity 1.0 '1', and false results in the quantity 0.0 '1' If the item is not one of the above types, the result is False. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    If the input collection contains a single item, this function will return `True` if:
        - the item is an `Integer`, or `Decimal`, where the resulting quantity will have the default unit (`'1'`)
        - the item is a `Quantity`
        - the item is a `String` and is convertible to a `Quantity`
        - the item is a `Boolean`, where true results in the quantity `1.0 '1'`, and false results in the quantity `0.0 '1'`
    If the item is not one of the above types, the result is `False`.
    If the input collection is empty, the result is empty.

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.
    """
    self.validate_collection(collection)
    if not collection:
        return []
    return [
        FHIRPathCollectionItem.wrap(
            ToQuantity().evaluate(collection, environment, create) != []
        )
    ]

ConvertsToString

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath convertsToString() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
class ConvertsToString(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`convertsToString()`](http://hl7.org/fhirpath/N1/#convertstostring-boolean) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        If the input collection contains a single item, this function will return `True` if:
            - the item in the input collection is a `String`
            - the item in the input collection is an `Integer`, `Decimal`, `Date`, `Time`, `DateTime`, or `Quantity` the output will contain its `String` representation
            - the item is a `Boolean`, where true results in `'true'` and false in `'false'`.
        If the item is not one of the above types, the result is `False`.
        If the input collection is empty, the result is empty.

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.
        """
        self.validate_collection(collection)
        if not collection:
            return []
        return [
            FHIRPathCollectionItem.wrap(
                ToString().evaluate(collection, environment, create) != []
            )
        ]

evaluate(collection, environment, create=False)

If the input collection contains a single item, this function will return True if: - the item in the input collection is a String - the item in the input collection is an Integer, Decimal, Date, Time, DateTime, or Quantity the output will contain its String representation - the item is a Boolean, where true results in 'true' and false in 'false'. If the item is not one of the above types, the result is False. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    If the input collection contains a single item, this function will return `True` if:
        - the item in the input collection is a `String`
        - the item in the input collection is an `Integer`, `Decimal`, `Date`, `Time`, `DateTime`, or `Quantity` the output will contain its `String` representation
        - the item is a `Boolean`, where true results in `'true'` and false in `'false'`.
    If the item is not one of the above types, the result is `False`.
    If the input collection is empty, the result is empty.

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.
    """
    self.validate_collection(collection)
    if not collection:
        return []
    return [
        FHIRPathCollectionItem.wrap(
            ToString().evaluate(collection, environment, create) != []
        )
    ]

ConvertsToTime

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath convertsToTime() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
class ConvertsToTime(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`convertsToTime()`](http://hl7.org/fhirpath/N1/#convertstotime-boolean) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        If the input collection contains a single item, this function will return `True` if:
            - the item is a `Time`
            - the item is a `String` and is convertible to a `Time`
        If the item is a `String`, but the string is not convertible to a `DateTime` (using the format `hh:mm:ss.fff(+|-)hh:mm`), the result is `False`.
        If the item contains a partial datetime (e.g. `'10:00'`), the result is 'True'.
        If the input collection is empty, the result is empty.

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.
        """
        self.validate_collection(collection)
        if not collection:
            return []
        return [
            FHIRPathCollectionItem.wrap(
                ToTime().evaluate(collection, environment, create) != []
            )
        ]

evaluate(collection, environment, create=False)

If the input collection contains a single item, this function will return True if: - the item is a Time - the item is a String and is convertible to a Time If the item is a String, but the string is not convertible to a DateTime (using the format hh:mm:ss.fff(+|-)hh:mm), the result is False. If the item contains a partial datetime (e.g. '10:00'), the result is 'True'. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    If the input collection contains a single item, this function will return `True` if:
        - the item is a `Time`
        - the item is a `String` and is convertible to a `Time`
    If the item is a `String`, but the string is not convertible to a `DateTime` (using the format `hh:mm:ss.fff(+|-)hh:mm`), the result is `False`.
    If the item contains a partial datetime (e.g. `'10:00'`), the result is 'True'.
    If the input collection is empty, the result is empty.

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.
    """
    self.validate_collection(collection)
    if not collection:
        return []
    return [
        FHIRPathCollectionItem.wrap(
            ToTime().evaluate(collection, environment, create) != []
        )
    ]

FHIRTypeConversionFunction

Bases: FHIRPathFunction

Abstract class definition for the category of type conversion FHIRPath functions.

Source code in fhircraft/fhir/path/engine/conversion.py 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
class FHIRTypeConversionFunction(FHIRPathFunction):
    """
    Abstract class definition for the category of type conversion FHIRPath functions.
    """

    def validate_collection(self, collection: FHIRPathCollection):
        """
        Validates the input collection of a FHIRPath type conversion function.

        Args:
            collection (FHIRPathCollection): Collection to be validated.

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.
        """
        if len(collection) > 1:
            raise FHIRPathRuntimeError(
                f"FHIRPath function {self.__str__()} expected a single-item collection, instead got a {len(collection)}-items collection."
            )

validate_collection(collection)

Validates the input collection of a FHIRPath type conversion function.

Parameters:

Name Type Description Default
collection FHIRPathCollection

Collection to be validated.

 required

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
def validate_collection(self, collection: FHIRPathCollection):
    """
    Validates the input collection of a FHIRPath type conversion function.

    Args:
        collection (FHIRPathCollection): Collection to be validated.

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.
    """
    if len(collection) > 1:
        raise FHIRPathRuntimeError(
            f"FHIRPath function {self.__str__()} expected a single-item collection, instead got a {len(collection)}-items collection."
        )

Iif

Bases: FHIRPathFunction

A representation of the FHIRPath iif() function.

Parameters:

Name Type Description Default
criterion FHIRPath

The criterion expression, is expected to evaluate to a Boolean.

 required
true_result Union[FHIRPath, Any]

Value to be returned if criterion evaluates to True

 required
otherwise_result Optional[Union[FHIRPath, Any]]

Value to be returned if criterion evaluates to False. Defaults to an empty collection.

 list()
Source code in fhircraft/fhir/path/engine/conversion.py 
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
class Iif(FHIRPathFunction):
    """
    A representation of the FHIRPath [`iif()`](http://hl7.org/fhirpath/N1/#iifcriterion-expression-true-result-collection-otherwise-result-collection-collection) function.

    Args:
        criterion (FHIRPath): The criterion expression,  is expected to evaluate to a `Boolean`.
        true_result (Union[FHIRPath, Any]): Value to be returned if `criterion` evaluates to `True`
        otherwise_result (Optional[Union[FHIRPath, Any]]): Value to be returned if `criterion` evaluates to `False`. Defaults to an empty collection.
    """

    def __init__(
        self,
        criterion: FHIRPath,
        true_result: FHIRPath | FHIRPathCollection,
        otherwise_result: FHIRPath | FHIRPathCollection = list(),
    ):
        self.criterion = criterion
        self.true_result = true_result
        self.otherwise_result = otherwise_result

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        This function acts as an immediate if, also known as a conditional operator.

        If `criterion` evaluates to `True`, the function returns the value of the `true_result` argument.
        If `true_result` is a FHIRPath expression it is evaluated.

        If `criterion` is `False` or an empty collection, the function returns the `otherwise_result` argument,
        unless the optional `otherwise_result` is not given, in which case the function returns an empty collection.
        If `otherwise_result` is a FHIRPath expression it is evaluated.

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.

        """
        criterion_collection = []
        for index, item in enumerate(collection):
            criterion_collection.extend(
                self.criterion.evaluate(
                    [item], get_expression_context(environment, item, index), create
                )
            )

        if not criterion_collection:
            criterion = False
        else:
            criterion = criterion_collection[0].value

        if criterion:
            if isinstance(self.true_result, FHIRPath):
                return self.true_result.evaluate(collection, environment, create)
            else:
                return self.true_result
        else:
            if self.otherwise_result:
                if isinstance(self.otherwise_result, FHIRPath):
                    return self.otherwise_result.evaluate(
                        collection, environment, create
                    )
                else:
                    return self.otherwise_result
            else:
                return []

evaluate(collection, environment, create=False)

This function acts as an immediate if, also known as a conditional operator.

If criterion evaluates to True, the function returns the value of the true_result argument. If true_result is a FHIRPath expression it is evaluated.

If criterion is False or an empty collection, the function returns the otherwise_result argument, unless the optional otherwise_result is not given, in which case the function returns an empty collection. If otherwise_result is a FHIRPath expression it is evaluated.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    This function acts as an immediate if, also known as a conditional operator.

    If `criterion` evaluates to `True`, the function returns the value of the `true_result` argument.
    If `true_result` is a FHIRPath expression it is evaluated.

    If `criterion` is `False` or an empty collection, the function returns the `otherwise_result` argument,
    unless the optional `otherwise_result` is not given, in which case the function returns an empty collection.
    If `otherwise_result` is a FHIRPath expression it is evaluated.

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.

    """
    criterion_collection = []
    for index, item in enumerate(collection):
        criterion_collection.extend(
            self.criterion.evaluate(
                [item], get_expression_context(environment, item, index), create
            )
        )

    if not criterion_collection:
        criterion = False
    else:
        criterion = criterion_collection[0].value

    if criterion:
        if isinstance(self.true_result, FHIRPath):
            return self.true_result.evaluate(collection, environment, create)
        else:
            return self.true_result
    else:
        if self.otherwise_result:
            if isinstance(self.otherwise_result, FHIRPath):
                return self.otherwise_result.evaluate(
                    collection, environment, create
                )
            else:
                return self.otherwise_result
        else:
            return []

ToBoolean

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath toBoolean() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
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
146
147
148
149
150
151
152
153
154
155
156
157
158
class ToBoolean(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`toBoolean()`](http://hl7.org/fhirpath/N1/#boolean-conversion-functions) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        If the input collection contains a single item, this function will return a single `Boolean` if:
            - the item is a `Boolean`
            - the item is an `Integer` that is equal to one of the possible integer representations of `Boolean` values
            - the item is a `Decimal` that is equal to one of the possible decimal representations of `Boolean` values
            - the item is a `String` that is equal to one of the possible string representations of `Boolean` values

        If the item is not one of the above types, or the item is a `String`, `Integer`, or `Decimal`, but is not equal to one of the possible values convertible to a `Boolean`, the result is false.
        If the input collection is empty, the result is empty ('[]').

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.

        """
        self.validate_collection(collection)
        if not collection:
            return []

        # Use type_utils for conversion
        from fhircraft.fhir.resources.datatypes.utils import to_boolean

        value = collection[0].value
        result = to_boolean(value)

        if result is not None:
            return [FHIRPathCollectionItem.wrap(result)]
        else:
            return []

evaluate(collection, environment, create=False)

If the input collection contains a single item, this function will return a single Boolean if: - the item is a Boolean - the item is an Integer that is equal to one of the possible integer representations of Boolean values - the item is a Decimal that is equal to one of the possible decimal representations of Boolean values - the item is a String that is equal to one of the possible string representations of Boolean values

If the item is not one of the above types, or the item is a String, Integer, or Decimal, but is not equal to one of the possible values convertible to a Boolean, the result is false. If the input collection is empty, the result is empty ('[]').

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
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
146
147
148
149
150
151
152
153
154
155
156
157
158
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    If the input collection contains a single item, this function will return a single `Boolean` if:
        - the item is a `Boolean`
        - the item is an `Integer` that is equal to one of the possible integer representations of `Boolean` values
        - the item is a `Decimal` that is equal to one of the possible decimal representations of `Boolean` values
        - the item is a `String` that is equal to one of the possible string representations of `Boolean` values

    If the item is not one of the above types, or the item is a `String`, `Integer`, or `Decimal`, but is not equal to one of the possible values convertible to a `Boolean`, the result is false.
    If the input collection is empty, the result is empty ('[]').

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.

    """
    self.validate_collection(collection)
    if not collection:
        return []

    # Use type_utils for conversion
    from fhircraft.fhir.resources.datatypes.utils import to_boolean

    value = collection[0].value
    result = to_boolean(value)

    if result is not None:
        return [FHIRPathCollectionItem.wrap(result)]
    else:
        return []

ToDate

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath toDate() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
class ToDate(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`toDate()`](http://hl7.org/fhirpath/N1/#todate-date) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        If the input collection contains a single item, this function will return a single date if:
            - the item is a `Date`
            - the item is a `DateTime`
            - the item is a `String` and is convertible to a `Date`
        If the item is not one of the above types, or is not convertible to a `Date` (using the format `YYYY-MM-DD`), the result is empty.
        If the item contains a partial date (e.g. `'2012-01'`), the result is a partial date.
        If the input collection is empty, the result is empty.

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.
        """
        self.validate_collection(collection)
        if not collection:
            return []
        value = collection[0].value
        if isinstance(value, str):
            date_match = re.match(
                rf"^{primitives.YEAR_REGEX}(-{primitives.MONTH_REGEX}(-{primitives.DAY_REGEX})?)?$",
                value,
            )
            datetime_match = re.match(
                rf"^({primitives.YEAR_REGEX}(-{primitives.MONTH_REGEX}(-{primitives.DAY_REGEX})?)?)(T{primitives.HOUR_REGEX}(:{primitives.MINUTES_REGEX}(:{primitives.SECONDS_REGEX}({primitives.TIMEZONE_REGEX})?)?)?)?",
                value,
            )
            if date_match:
                return [FHIRPathCollectionItem.wrap(value)]
            elif datetime_match:
                return [FHIRPathCollectionItem.wrap(datetime_match.group(1))]
            else:
                return []
        else:
            return []

evaluate(collection, environment, create=False)

If the input collection contains a single item, this function will return a single date if: - the item is a Date - the item is a DateTime - the item is a String and is convertible to a Date If the item is not one of the above types, or is not convertible to a Date (using the format YYYY-MM-DD), the result is empty. If the item contains a partial date (e.g. '2012-01'), the result is a partial date. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    If the input collection contains a single item, this function will return a single date if:
        - the item is a `Date`
        - the item is a `DateTime`
        - the item is a `String` and is convertible to a `Date`
    If the item is not one of the above types, or is not convertible to a `Date` (using the format `YYYY-MM-DD`), the result is empty.
    If the item contains a partial date (e.g. `'2012-01'`), the result is a partial date.
    If the input collection is empty, the result is empty.

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.
    """
    self.validate_collection(collection)
    if not collection:
        return []
    value = collection[0].value
    if isinstance(value, str):
        date_match = re.match(
            rf"^{primitives.YEAR_REGEX}(-{primitives.MONTH_REGEX}(-{primitives.DAY_REGEX})?)?$",
            value,
        )
        datetime_match = re.match(
            rf"^({primitives.YEAR_REGEX}(-{primitives.MONTH_REGEX}(-{primitives.DAY_REGEX})?)?)(T{primitives.HOUR_REGEX}(:{primitives.MINUTES_REGEX}(:{primitives.SECONDS_REGEX}({primitives.TIMEZONE_REGEX})?)?)?)?",
            value,
        )
        if date_match:
            return [FHIRPathCollectionItem.wrap(value)]
        elif datetime_match:
            return [FHIRPathCollectionItem.wrap(datetime_match.group(1))]
        else:
            return []
    else:
        return []

ToDateTime

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath toDateTime() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
class ToDateTime(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`toDateTime()`](http://hl7.org/fhirpath/N1/#todatetime-datetime) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        If the input collection contains a single item, this function will return a single datetime if:
            - the item is a `DateTime`
            - the item is a `Date`, in which case the result is a `DateTime` with the year, month, and day of the `Date`, and the time components empty (not set to zero)
            - the item is a `String` and is convertible to a `DateTime`
        If the item is a `String`, but the string is not convertible to a `DateTime` (using the format `YYYY-MM-DDThh:mm:ss.fff(+|-)hh:mm`), the result is empty.
        If the item contains a partial datetime (e.g. `'2012-01-01T10:00'`), the result is a partial datetime.
        If the input collection is empty, the result is empty.

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.
        """
        self.validate_collection(collection)
        if not collection:
            return []
        value = collection[0].value
        if isinstance(value, str):
            date_match = re.match(
                rf"^{primitives.YEAR_REGEX}(-{primitives.MONTH_REGEX}(-{primitives.DAY_REGEX})?)?$",
                value,
            )
            datetime_match = re.match(
                rf"^({primitives.YEAR_REGEX}(-{primitives.MONTH_REGEX}(-{primitives.DAY_REGEX})?)?)(T{primitives.HOUR_REGEX}(:{primitives.MINUTES_REGEX}(:{primitives.SECONDS_REGEX}({primitives.TIMEZONE_REGEX})?)?)?)?",
                value,
            )
            if date_match or datetime_match:
                return [FHIRPathCollectionItem.wrap(value)]
            else:
                return []
        else:
            return []

evaluate(collection, environment, create=False)

If the input collection contains a single item, this function will return a single datetime if: - the item is a DateTime - the item is a Date, in which case the result is a DateTime with the year, month, and day of the Date, and the time components empty (not set to zero) - the item is a String and is convertible to a DateTime If the item is a String, but the string is not convertible to a DateTime (using the format YYYY-MM-DDThh:mm:ss.fff(+|-)hh:mm), the result is empty. If the item contains a partial datetime (e.g. '2012-01-01T10:00'), the result is a partial datetime. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    If the input collection contains a single item, this function will return a single datetime if:
        - the item is a `DateTime`
        - the item is a `Date`, in which case the result is a `DateTime` with the year, month, and day of the `Date`, and the time components empty (not set to zero)
        - the item is a `String` and is convertible to a `DateTime`
    If the item is a `String`, but the string is not convertible to a `DateTime` (using the format `YYYY-MM-DDThh:mm:ss.fff(+|-)hh:mm`), the result is empty.
    If the item contains a partial datetime (e.g. `'2012-01-01T10:00'`), the result is a partial datetime.
    If the input collection is empty, the result is empty.

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.
    """
    self.validate_collection(collection)
    if not collection:
        return []
    value = collection[0].value
    if isinstance(value, str):
        date_match = re.match(
            rf"^{primitives.YEAR_REGEX}(-{primitives.MONTH_REGEX}(-{primitives.DAY_REGEX})?)?$",
            value,
        )
        datetime_match = re.match(
            rf"^({primitives.YEAR_REGEX}(-{primitives.MONTH_REGEX}(-{primitives.DAY_REGEX})?)?)(T{primitives.HOUR_REGEX}(:{primitives.MINUTES_REGEX}(:{primitives.SECONDS_REGEX}({primitives.TIMEZONE_REGEX})?)?)?)?",
            value,
        )
        if date_match or datetime_match:
            return [FHIRPathCollectionItem.wrap(value)]
        else:
            return []
    else:
        return []

ToDecimal

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath toDecimal() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
class ToDecimal(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`toDecimal()`](http://hl7.org/fhirpath/N1/#todecimal-decimal) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        If the input collection contains a single item, this function will return a single decimal if:
            - the item is an `Integer` or `Decimal`
            - the item is a `String` and is convertible to a `Decimal`
            - the item is a `Boolean`, where `True` results in a `1.0` and `False` results in a `0.0`.
        If the item is not one of the above types, the result is empty (`[]`).
        If the item is a `String`, but the string is not convertible to a `Decimal`, the result is empty.

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.
        """
        self.validate_collection(collection)
        if not collection:
            return []
        value = collection[0].value
        if isinstance(value, (int, float, bool)):
            return [FHIRPathCollectionItem.wrap(float(value))]
        elif isinstance(value, str):
            if re.match(r"(\\+|-)?\d+(\.\d+)?", value):
                return [FHIRPathCollectionItem.wrap(float(value))]
            else:
                return []
        else:
            return []

evaluate(collection, environment, create=False)

If the input collection contains a single item, this function will return a single decimal if: - the item is an Integer or Decimal - the item is a String and is convertible to a Decimal - the item is a Boolean, where True results in a 1.0 and False results in a 0.0. If the item is not one of the above types, the result is empty ([]). If the item is a String, but the string is not convertible to a Decimal, the result is empty.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    If the input collection contains a single item, this function will return a single decimal if:
        - the item is an `Integer` or `Decimal`
        - the item is a `String` and is convertible to a `Decimal`
        - the item is a `Boolean`, where `True` results in a `1.0` and `False` results in a `0.0`.
    If the item is not one of the above types, the result is empty (`[]`).
    If the item is a `String`, but the string is not convertible to a `Decimal`, the result is empty.

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.
    """
    self.validate_collection(collection)
    if not collection:
        return []
    value = collection[0].value
    if isinstance(value, (int, float, bool)):
        return [FHIRPathCollectionItem.wrap(float(value))]
    elif isinstance(value, str):
        if re.match(r"(\\+|-)?\d+(\.\d+)?", value):
            return [FHIRPathCollectionItem.wrap(float(value))]
        else:
            return []
    else:
        return []

ToInteger

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath toInteger() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
class ToInteger(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`toInteger()`](http://hl7.org/fhirpath/N1/#tointeger-integer) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        If the input collection contains a single item, this function will return a single `Integer` if:
            - the item is an `Integer`
            - the item is a `String` and is convertible to an integer
            - the item is a `Boolean`, where `True` results in a 1 and `False` results in a 0.
        If the item is not one the above types, the result is empty (`[]`).

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.
        """
        self.validate_collection(collection)
        if not collection:
            return []

        # Use type_utils for conversion
        from fhircraft.fhir.resources.datatypes.utils import to_integer

        value = collection[0].value
        result = to_integer(value)

        if result is not None:
            return [FHIRPathCollectionItem.wrap(result)]
        else:
            return []

evaluate(collection, environment, create=False)

If the input collection contains a single item, this function will return a single Integer if: - the item is an Integer - the item is a String and is convertible to an integer - the item is a Boolean, where True results in a 1 and False results in a 0. If the item is not one the above types, the result is empty ([]).

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    If the input collection contains a single item, this function will return a single `Integer` if:
        - the item is an `Integer`
        - the item is a `String` and is convertible to an integer
        - the item is a `Boolean`, where `True` results in a 1 and `False` results in a 0.
    If the item is not one the above types, the result is empty (`[]`).

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.
    """
    self.validate_collection(collection)
    if not collection:
        return []

    # Use type_utils for conversion
    from fhircraft.fhir.resources.datatypes.utils import to_integer

    value = collection[0].value
    result = to_integer(value)

    if result is not None:
        return [FHIRPathCollectionItem.wrap(result)]
    else:
        return []

ToQuantity

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath toQuantity() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
class ToQuantity(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`toQuantity()`](http://hl7.org/fhirpath/N1/#toquantity-string) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        If the input collection contains a single item, this function will return a single quantity if:
            - the item is an `Integer`, or `Decimal`, where the resulting quantity will have the default unit (`'1'`)
            - the item is a `Quantity`
            - the item is a `String` and is convertible to a `Quantity`
            - the item is a `Boolean`, where true results in the quantity `1.0 '1'`, and false results in the quantity `0.0 '1'`
        If the item is not one of the above types, the result is empty.
        If the input collection is empty, the result is empty.

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.
        """
        from fhircraft.fhir.resources.datatypes.utils import get_complex_FHIR_type

        self.validate_collection(collection)
        Quantity = get_complex_FHIR_type("Quantity")
        if not collection:
            return []
        value = collection[0].value
        if isinstance(value, (bool, int, float)):
            return [FHIRPathCollectionItem.wrap(Quantity(value=float(value), unit="1"))]
        elif isinstance(value, str):
            quantity_match = re.match(
                r"((\+|-)?\d+(\.\d+)?)\s*(('([^']+)'|([a-zA-Z]+))?)", value
            )
            if quantity_match:
                return [
                    FHIRPathCollectionItem.wrap(
                        Quantity(
                            value=quantity_match.group(1), unit=quantity_match.group(4)
                        )
                    )
                ]
            else:
                return []
        elif isinstance(value, Quantity):
            return [FHIRPathCollectionItem.wrap(value)]
        else:
            return []

evaluate(collection, environment, create=False)

If the input collection contains a single item, this function will return a single quantity if: - the item is an Integer, or Decimal, where the resulting quantity will have the default unit ('1') - the item is a Quantity - the item is a String and is convertible to a Quantity - the item is a Boolean, where true results in the quantity 1.0 '1', and false results in the quantity 0.0 '1' If the item is not one of the above types, the result is empty. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    If the input collection contains a single item, this function will return a single quantity if:
        - the item is an `Integer`, or `Decimal`, where the resulting quantity will have the default unit (`'1'`)
        - the item is a `Quantity`
        - the item is a `String` and is convertible to a `Quantity`
        - the item is a `Boolean`, where true results in the quantity `1.0 '1'`, and false results in the quantity `0.0 '1'`
    If the item is not one of the above types, the result is empty.
    If the input collection is empty, the result is empty.

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.
    """
    from fhircraft.fhir.resources.datatypes.utils import get_complex_FHIR_type

    self.validate_collection(collection)
    Quantity = get_complex_FHIR_type("Quantity")
    if not collection:
        return []
    value = collection[0].value
    if isinstance(value, (bool, int, float)):
        return [FHIRPathCollectionItem.wrap(Quantity(value=float(value), unit="1"))]
    elif isinstance(value, str):
        quantity_match = re.match(
            r"((\+|-)?\d+(\.\d+)?)\s*(('([^']+)'|([a-zA-Z]+))?)", value
        )
        if quantity_match:
            return [
                FHIRPathCollectionItem.wrap(
                    Quantity(
                        value=quantity_match.group(1), unit=quantity_match.group(4)
                    )
                )
            ]
        else:
            return []
    elif isinstance(value, Quantity):
        return [FHIRPathCollectionItem.wrap(value)]
    else:
        return []

ToString

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath toString() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
class ToString(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`toString()`](http://hl7.org/fhirpath/N1/#tostring-string) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        If the input collection contains a single item, this function will return a single string if:
            - the item in the input collection is a `String`
            - the item in the input collection is an `Integer`, `Decimal`, `Date`, `Time`, `DateTime`, or `Quantity` the output will contain its `String` representation
            - the item is a `Boolean`, where true results in `'true'` and false in `'false'`.
        If the item is not one of the above types, the result is empty.
        If the input collection is empty, the result is empty.

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.
        """
        from fhircraft.fhir.resources.datatypes.utils import get_complex_FHIR_type

        self.validate_collection(collection)
        if not collection:
            return []
        value = collection[0].value
        if isinstance(value, bool):
            return [FHIRPathCollectionItem.wrap("true" if value else "false")]
        elif isinstance(value, (str, int, float)):
            return [FHIRPathCollectionItem.wrap(str(value))]
        elif isinstance(value, get_complex_FHIR_type("Quantity")):
            return [FHIRPathCollectionItem.wrap(f"{value.value} {value.unit}")]
        else:
            return []

evaluate(collection, environment, create=False)

If the input collection contains a single item, this function will return a single string if: - the item in the input collection is a String - the item in the input collection is an Integer, Decimal, Date, Time, DateTime, or Quantity the output will contain its String representation - the item is a Boolean, where true results in 'true' and false in 'false'. If the item is not one of the above types, the result is empty. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    If the input collection contains a single item, this function will return a single string if:
        - the item in the input collection is a `String`
        - the item in the input collection is an `Integer`, `Decimal`, `Date`, `Time`, `DateTime`, or `Quantity` the output will contain its `String` representation
        - the item is a `Boolean`, where true results in `'true'` and false in `'false'`.
    If the item is not one of the above types, the result is empty.
    If the input collection is empty, the result is empty.

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.
    """
    from fhircraft.fhir.resources.datatypes.utils import get_complex_FHIR_type

    self.validate_collection(collection)
    if not collection:
        return []
    value = collection[0].value
    if isinstance(value, bool):
        return [FHIRPathCollectionItem.wrap("true" if value else "false")]
    elif isinstance(value, (str, int, float)):
        return [FHIRPathCollectionItem.wrap(str(value))]
    elif isinstance(value, get_complex_FHIR_type("Quantity")):
        return [FHIRPathCollectionItem.wrap(f"{value.value} {value.unit}")]
    else:
        return []

ToTime

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath toTime() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
class ToTime(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`toTime()`](http://hl7.org/fhirpath/N1/#totime-time) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, environment: dict, create: bool = False
    ) -> FHIRPathCollection:
        """
        If the input collection contains a single item, this function will return a single time if:
            - the item is a `Time`
            - the item is a `String` and is convertible to a `Time`
        If the item is a `String`, but the string is not convertible to a `Time` (using the format `hh:mm:ss.fff(+|-)hh:mm`), the result is empty.
        If the item contains a partial datetime (e.g. `'10:00'`), the result is a partial datetime.
        If the input collection is empty, the result is empty.

        Args:
            collection (FHIRPathCollection): The input collection.
            environment (dict): The environment context for the evaluation.
            create (bool): Whether to create new elements during evaluation if necessary.

        Returns:
            FHIRPathCollection: The output collection

        Raises:
            FHIRPathRuntimeError: If input collection has more than one item.
        """
        self.validate_collection(collection)
        if not collection:
            return []
        value = collection[0].value
        if isinstance(value, str):
            time_match = re.match(
                rf"^{primitives.HOUR_REGEX}(:{primitives.MINUTES_REGEX}(:{primitives.SECONDS_REGEX}({primitives.TIMEZONE_REGEX})?)?)?",
                value,
            )
            if time_match:
                return [FHIRPathCollectionItem.wrap(value)]
            else:
                return []
        else:
            return []

evaluate(collection, environment, create=False)

If the input collection contains a single item, this function will return a single time if: - the item is a Time - the item is a String and is convertible to a Time If the item is a String, but the string is not convertible to a Time (using the format hh:mm:ss.fff(+|-)hh:mm), the result is empty. If the item contains a partial datetime (e.g. '10:00'), the result is a partial datetime. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection.

 required
environment dict

The environment context for the evaluation.

 required
create bool

Whether to create new elements during evaluation if necessary.

 False

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection

Raises:

Type Description
FHIRPathRuntimeError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
def evaluate(
    self, collection: FHIRPathCollection, environment: dict, create: bool = False
) -> FHIRPathCollection:
    """
    If the input collection contains a single item, this function will return a single time if:
        - the item is a `Time`
        - the item is a `String` and is convertible to a `Time`
    If the item is a `String`, but the string is not convertible to a `Time` (using the format `hh:mm:ss.fff(+|-)hh:mm`), the result is empty.
    If the item contains a partial datetime (e.g. `'10:00'`), the result is a partial datetime.
    If the input collection is empty, the result is empty.

    Args:
        collection (FHIRPathCollection): The input collection.
        environment (dict): The environment context for the evaluation.
        create (bool): Whether to create new elements during evaluation if necessary.

    Returns:
        FHIRPathCollection: The output collection

    Raises:
        FHIRPathRuntimeError: If input collection has more than one item.
    """
    self.validate_collection(collection)
    if not collection:
        return []
    value = collection[0].value
    if isinstance(value, str):
        time_match = re.match(
            rf"^{primitives.HOUR_REGEX}(:{primitives.MINUTES_REGEX}(:{primitives.SECONDS_REGEX}({primitives.TIMEZONE_REGEX})?)?)?",
            value,
        )
        if time_match:
            return [FHIRPathCollectionItem.wrap(value)]
        else:
            return []
    else:
        return []