FHIRPath Parser & Lexer

FHIRPath lexer and parser components

FhirPathLexer
Path: `fhircraft.fhir.path.lexer.FhirPathLexer`

FhirPathLexer(debug=False)

A Lexical analyzer for JsonPath.

Methods:

Name	Description
`tokenize`	Maps a string to an iterator over tokens. In other words: [char] -> [token]
`t_ignore_WHITESPACE`	[\s]
`t_ignore_COMMENT`	\/([\s\S]?)\/\|\/\/(.)
`t_CHOICE_ELEMENT`	(?:`[a-zA-Z][a-zA-Z0-9-][^`][x]`)\|(?:(?:\|[a-zA-Z])[a-zA-Z0-9][x])
`t_ENVIRONMENTAL_VARIABLE`	(?:\%[a-zA-Z][a-zA-Z0-9-]\|\%`[a-zA-Z][a-zA-Z0-9-][^`]`)
`t_CONTEXTUAL_OPERATOR`	\$(\w*)?
`t_DATETIME`	@\d{4}(?:-\d{2}(?:-\d{2})?)?T(?:\d{2}(?::\d{2}(?::\d{2}(?:.\d{3}(?:[+\|-]\d{2}(?::\d{2})?)?)?)?)?)?
`t_DATE`	@\d{4}(?:-\d{2}(?:-\d{2})?)?
`t_TIME`	\@T\d{2}(?::\d{2}(?::\d{2}(?:.\d{3}(?:[+\|-]\d{2}(?::\d{2})?)?)?)?)?
`t_NUMBER`	-?\d+(.\d+)?
`t_STRING`	\'((?:[^\'\]\|\.)*)\'
`t_IDENTIFIER`	(?:`[a-zA-Z][a-zA-Z0-9-][^`]`)\|(?:(?:\|[a-zA-Z])[a-zA-Z0-9])
`t_NOT_EQUAL`	!=
`t_NOT_EQUIVALENT`	!~
`t_GREATER_EQUAL_THAN`	=
`t_LESS_EQUAL_THAN`	<=
`t_LESS_THAN`	<
`t_GREATER_THAN`
`t_EQUAL`	=
`t_EQUIVALENT`	~
`t_error_invalid_function`	[a-zA-Z][a-zA-Z_0-9]((?:.)?)
`t_error_doublequote_string`	\"([^\"]*)?\"

Source code in fhircraft/fhir/path/lexer.py

def __init__(self, debug=False):
    self.debug = debug
    if self.__doc__ is None:
        raise FhirPathLexerError("Docstrings have been removed by design of PLY.")
    # Create the lexer once during initialization for better performance
    self.lexer = ply.lex.lex(module=self)

tokenize

tokenize(string)

Maps a string to an iterator over tokens. In other words: [char] -> [token]

Source code in fhircraft/fhir/path/lexer.py

def tokenize(self, string):
    """
    Maps a string to an iterator over tokens. In other words: [char] -> [token]
    """

    # Reuse the existing lexer instead of creating a new one each time
    self.lexer.latest_newline = 0
    self.lexer.string_value = None
    self.lexer.input(string)

    while True:
        t = self.lexer.token()
        if t is None:
            break
        t.col = t.lexpos - self.lexer.latest_newline
        yield t

    if self.lexer.string_value is not None:
        raise FhirPathLexerError("Unexpected EOF in string literal or identifier")

t_ignore_WHITESPACE

t_ignore_WHITESPACE(t)

[\s]

Source code in fhircraft/fhir/path/lexer.py

def t_ignore_WHITESPACE(self, t):
    # Whitespace (http://hl7.org/fhirpath/N1/#whitespace)
    # -------------------------------------------------------------------------------
    # FHIRPath defines tab (\t), space ( ), line feed (\n) and carriage return (\r) as whitespace,
    # meaning they are only used to separate other tokens within the language. Any number
    # of whitespace characters can appear, and the language does not use whitespace for
    # anything other than delimiting tokens.
    r"[\s]"
    if t.value == "\n":
        t.lexer.lineno += 1
        t.lexer.latest_newline = t.lexpos

t_ignore_COMMENT

t_ignore_COMMENT(t)

\/*([\s\S]?)*\/|\/\/(.)

Source code in fhircraft/fhir/path/lexer.py

def t_ignore_COMMENT(self, t):
    # Comments (http://hl7.org/fhirpath/N1/#comments)
    # -------------------------------------------------------------------------------
    # FHIRPath defines two styles of comments, single-line, and multi-line.
    # - A single-line comment consists of two forward slashes, followed by any
    #   text up to the end of the line
    # - To begin a multi-line comment, the typical forward slash-asterisk token
    #   is used. The comment is closed with an asterisk-forward slash, and everything enclosed is ignored
    r"\/\*([\s\S]*?)\*\/|\/\/(.*)"
    for substring in ["//", "/*", "*/"]:
        t.value = t.value.replace(substring, "")
    t.value = t.value.strip()

t_CHOICE_ELEMENT

t_CHOICE_ELEMENT(t)

(?:`[a-zA-Z][a-zA-Z0-9-][^`][x]`)|(?:(?:|[a-zA-Z])[a-zA-Z0-9][x])

Source code in fhircraft/fhir/path/lexer.py

def t_CHOICE_ELEMENT(self, t):
    r"(?:\`[a-zA-Z][a-zA-Z0-9\-][^\`]*\[x\]\`)|(?:(?:_|[a-zA-Z])[a-zA-Z0-9_]*\[x\])"
    t.value = t.value.replace("[x]", "")
    return t

t_ENVIRONMENTAL_VARIABLE

t_ENVIRONMENTAL_VARIABLE(t)

(?:\%[a-zA-Z][a-zA-Z0-9-]|\%`[a-zA-Z][a-zA-Z0-9-][^`]`)

Source code in fhircraft/fhir/path/lexer.py

def t_ENVIRONMENTAL_VARIABLE(self, t):
    # Environmental variable (http://hl7.org/fhirpath/N1/#environment-variables)
    # -------------------------------------------------------------------------------
    # A token introduced by a % refers to a value that is passed into the evaluation
    # engine by the calling environment.
    r"(?:\%[a-zA-Z][a-zA-Z0-9\-]*|\%\`[a-zA-Z][a-zA-Z0-9\-][^\`]*\`)"
    return t

t_CONTEXTUAL_OPERATOR

t_CONTEXTUAL_OPERATOR(t)

\$(\w*)?

Source code in fhircraft/fhir/path/lexer.py

def t_CONTEXTUAL_OPERATOR(self, t):
    # Contextual Operators (http://hl7.org/fhirpath/N1/#functions)
    # -------------------------------------------------------------------------------
    # Special elements within a funciton that refere to the input collection under evalution
    r"\$(\w*)?"
    return t

t_DATETIME

t_DATETIME(t)

@\d{4}(?:-\d{2}(?:-\d{2})?)?T(?:\d{2}(?::\d{2}(?::\d{2}(?:.\d{3}(?:[+|-]\d{2}(?::\d{2})?)?)?)?)?)?

Source code in fhircraft/fhir/path/lexer.py

def t_DATETIME(self, t):
    # DateTime (http://hl7.org/fhirpath/N1/#datetime)
    # -------------------------------------------------------------------------------
    # The Date type represents date and partial date values.
    # - The date literal is a subset of [ISO8601]:
    # - A date being with a @
    # - It uses the format YYYY-MM-DD format, though month and day parts are optional
    # - Months must be present if a day is present
    # The Time type represents time-of-day and partial time-of-day values.
    # - A time begins with a @T
    # - It uses the Thh:mm:ss.fff format
    r"@\d{4}(?:-\d{2}(?:-\d{2})?)?T(?:\d{2}(?:\:\d{2}(?:\:\d{2}(?:.\d{3}(?:[\+|\-]\d{2}(?:\:\d{2})?)?)?)?)?)?"
    return t

t_DATE

t_DATE(t)

@\d{4}(?:-\d{2}(?:-\d{2})?)?

Source code in fhircraft/fhir/path/lexer.py

def t_DATE(self, t):
    # Date (http://hl7.org/fhirpath/N1/#date)
    # -------------------------------------------------------------------------------
    # The Date type represents date and partial date values.
    # - The date literal is a subset of [ISO8601]:
    # - A date being with a @
    # - It uses the format YYYY-MM-DD format, though month and day parts are optional
    # - Months must be present if a day is present
    r"@\d{4}(?:-\d{2}(?:-\d{2})?)?"
    return t

t_TIME

t_TIME(t)

\@T\d{2}(?::\d{2}(?::\d{2}(?:.\d{3}(?:[+|-]\d{2}(?::\d{2})?)?)?)?)?

Source code in fhircraft/fhir/path/lexer.py

def t_TIME(self, t):
    # Time (http://hl7.org/fhirpath/N1/#time)
    # -------------------------------------------------------------------------------
    # The Time type represents time-of-day and partial time-of-day values.
    # - A time begins with a @T
    # - It uses the Thh:mm:ss.fff format
    r"\@T\d{2}(?:\:\d{2}(?:\:\d{2}(?:\.\d{3}(?:[+|-]\d{2}(?:\:\d{2})?)?)?)?)?"
    return t

t_NUMBER

t_NUMBER(t)

-?\d+(.\d+)?

Source code in fhircraft/fhir/path/lexer.py

def t_NUMBER(self, t):
    r"-?\d+(\.\d+)?"
    if "." in t.value:
        # Decimal (http://hl7.org/fhirpath/N1/#decimal)
        # -------------------------------------------------------------------------------
        t.value = float(t.value)
        t.type = "DECIMAL"
    else:
        # Integer (http://hl7.org/fhirpath/N1/#integer)
        # -------------------------------------------------------------------------------
        t.value = int(t.value)
        t.type = "INTEGER"
    return t

t_STRING

t_STRING(t)

\'((?:[^\'\]|\.)*)\'

Source code in fhircraft/fhir/path/lexer.py

def t_STRING(self, t):
    # String (http://hl7.org/fhirpath/N1/#string)
    # -------------------------------------------------------------------------------
    # The String type represents string values up to 231-1 characters in length. String
    # literals are surrounded by single-quotes and may use \-escapes to escape quotes
    # and represent Unicode characters
    r"\'((?:[^\'\\]|\\.)*)\'"
    t.value = t.value.strip("'")
    return t

t_IDENTIFIER

t_IDENTIFIER(t)

(?:`[a-zA-Z][a-zA-Z0-9-][^`]`)|(?:(?:|[a-zA-Z])[a-zA-Z0-9])

Source code in fhircraft/fhir/path/lexer.py

def t_IDENTIFIER(self, t):
    # Identifiers (http://hl7.org/fhirpath/N1/#identifiers)
    # -------------------------------------------------------------------------------
    # Identifiers are used as labels to allow expressions to reference elements such
    # as model types and properties. FHIRPath supports two types of identifiers, simple
    # and delimited.
    # - A simple identifier is any alphabetical character or an underscore, followed by
    #   any number of alpha-numeric characters or underscores
    # - A delimited identifier is any sequence of characters enclosed in backticks ( ` ):
    r"(?:\`[a-zA-Z][a-zA-Z0-9\-][^\`]*\`)|(?:(?:_|[a-zA-Z])[a-zA-Z0-9_]*)"
    if t.value.startswith("`") and t.value.endswith("`"):
        t.value = t.value.strip("`")
        t.type = "IDENTIFIER"
    else:
        t.type = self.reserved_words.get(t.value, "IDENTIFIER")
    return t

t_NOT_EQUAL

t_NOT_EQUAL(t)

!=

Source code in fhircraft/fhir/path/lexer.py

def t_NOT_EQUAL(self, t):
    r"!="
    return t

t_NOT_EQUIVALENT

t_NOT_EQUIVALENT(t)

!~

Source code in fhircraft/fhir/path/lexer.py

def t_NOT_EQUIVALENT(self, t):
    r"!~"
    return t

t_GREATER_EQUAL_THAN

t_GREATER_EQUAL_THAN(t)

=

Source code in fhircraft/fhir/path/lexer.py

def t_GREATER_EQUAL_THAN(self, t):
    r">="
    return t

t_LESS_EQUAL_THAN

t_LESS_EQUAL_THAN(t)

<=

Source code in fhircraft/fhir/path/lexer.py

def t_LESS_EQUAL_THAN(self, t):
    r"<="
    return t

t_LESS_THAN

t_LESS_THAN(t)

<

Source code in fhircraft/fhir/path/lexer.py

def t_LESS_THAN(self, t):
    r"<"
    return t

t_GREATER_THAN

t_GREATER_THAN(t)

Source code in fhircraft/fhir/path/lexer.py

def t_GREATER_THAN(self, t):
    r">"
    return t

t_EQUAL

t_EQUAL(t)

=

Source code in fhircraft/fhir/path/lexer.py

def t_EQUAL(self, t):
    r"="
    return t

t_EQUIVALENT

t_EQUIVALENT(t)

~

Source code in fhircraft/fhir/path/lexer.py

def t_EQUIVALENT(self, t):
    r"~"
    return t

t_error_invalid_function

t_error_invalid_function(t)

[a-zA-Z][a-zA-Z_0-9]((?:.)?)

Source code in fhircraft/fhir/path/lexer.py

def t_error_invalid_function(self, t):
    r"[a-zA-Z][a-zA-Z_0-9]*\((?:.*)?\)"
    t.value = t.value.split("(")[0]
    pos = t.lexpos - t.lexer.latest_newline
    raise FhirPathLexerError(
        f'FHIRPath lexer error at {t.lexer.lineno}:{pos} - Invalid function: "{t.value}".\n{_underline_error_in_fhir_path(t.lexer.lexdata, t.value, pos)}'
    )

t_error_doublequote_string

t_error_doublequote_string(t)

\"([^\"]*)?\"

Source code in fhircraft/fhir/path/lexer.py

def t_error_doublequote_string(self, t):
    r"\"([^\"]*)?\" "
    pos = t.lexpos - t.lexer.latest_newline
    raise FhirPathLexerError(
        f"FHIRPath lexer error at {t.lexer.lineno}:{pos} - Double-quoted strings are not valid in FHIRPath: {t.value}\n{_underline_error_in_fhir_path(t.lexer.lexdata, t.value, pos)}"
    )

MergeLexerMetaclass
Path: `fhircraft.fhir.path.lexer.MergeLexerMetaclass`

Bases: type

FhirPathParser
Path: `fhircraft.fhir.path.parser.FhirPathParser`

FhirPathParser(debug=False, lexer_class=None)

An LALR-parser for FHIRPath

Methods:

Name	Description
`p_fhirpath_term_expression`	expression : term
`p_fhirpath_invocation_expression`	expression : expression '.' invocation
`p_fhirpath_indexer_expression`	expression : expression '[' expression ']'
`p_fhirpath_multiplicative_operation`	expression : expression '*' expression
`p_fhirpath_additive_operation`	expression : expression '+' expression
`p_fhirpath_type_operation`	expression : expression IS type_specifier
`p_fhirpath_union_operation`	expression : expression '\|' expression
`p_fhirpath_equality_operation`	expression : expression EQUAL expression
`p_fhirpath_inequality_operation`	expression : expression GREATER_THAN expression
`p_fhirpath_membership_fhirpath_operation`	expression : expression IN expression
`p_fhirpath_and_operation`	expression : expression AND expression
`p_fhirpath_or_operation`	expression : expression OR expression
`p_fhirpath_implies_operation`	expression : expression IMPLIES expression
`p_fhirpath_term`	term : invocation
`p_fhirpath_parenthesized_expression`	parenthesized_expression : '(' expression ')'
`p_fhirpath_invocation`	invocation : element
`p_fhirpath_root`	root : ROOT_NODE
`p_fhirpath_element`	element : identifier
`p_fhirpath_typechoice_invocation`	type_choice : CHOICE_ELEMENT
`p_fhirpath_constant`	constant : ENVIRONMENTAL_VARIABLE
`p_fhirpath_contextual`	contextual : CONTEXTUAL_OPERATOR
`p_fhirpath_type_specifier`	type_specifier : identifier
`p_fhirpath_type_specifier_context`	type_specifier : identifier '.' identifier
`p_fhirpath_function`	function : function_name '(' arguments ')'
`p_fhirpath_type_function`	function : OFTYPE '(' type_specifier ')'
`p_fhirpath_function_name`	function_name : identifier
`p_fhirpath_function_arguments`	arguments : arguments ',' argument
`p_fhirpath_function_argument`	argument : expression
`p_fhirpath_identifier`	identifier : IDENTIFIER
`p_fhirpath_literal`	literal : number
`p_fhirpath_literal_empty`	literal : '{' '}'
`p_fhirpath_boolean`	boolean : BOOLEAN
`p_fhirpath_datetime`	datetime : DATETIME
`p_fhirpath_time`	time : TIME
`p_fhirpath_date`	date : DATE
`p_fhirpath_quantity`	quantity : number unit
`p_fhirpath_unit`	unit : STRING
`p_fhirpath_number`	number : INTEGER
`p_fhirpath_empty`	empty :