FHIR Mapping Language Parser

FHIR Mapping Language parser and lexer utilities.

FhirMappingLanguageLexer
Path: `fhircraft.fhir.mapper.lexer.FhirMappingLanguageLexer`

FhirMappingLanguageLexer(debug=False)

Bases: FhirPathLexer

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_METADATA_DECLARATION`	\/\/\/
`t_ignore_DOCUMENTATION`	\/{2}(.*)
`t_RIGHT_ARROW`	->
`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_BOOLEAN`	true\|false
`t_TIME`	\@T\d{2}(?::\d{2}(?::\d{2}(?:.\d{3}(?:[+\|-]\d{2}(?::\d{2})?)?)?)?)?
`t_NUMBER`	-?\d+(.\d+)?
`t_STRING`	(\'([^\'])?\')\|(\"([^\"])?\")
`t_GROUPTYPE`	<>\|<>
`t_DOUBLE_EQUAL`	==
`t_DELIMITEDIDENTIFIER`	`[a-zA-Z][a-zA-Z0-9-][^`]*`
`t_error_invalid_function`	"

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

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

tokenize

tokenize(string)

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

Source code in fhircraft/fhir/mapper/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 FhirMappingLanguageLexerError(
            "Unexpected EOF in string literal or identifier"
        )

t_ignore_WHITESPACE

t_ignore_WHITESPACE(t)

[\s]

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

def t_ignore_WHITESPACE(self, t):
    r"[\s]"
    if t.value == "\n":
        t.lexer.lineno += 1
        t.lexer.latest_newline = t.lexpos

t_METADATA_DECLARATION

t_METADATA_DECLARATION(t)

\/\/\/

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

def t_METADATA_DECLARATION(self, t):
    r"\/\/\/"
    return t

t_ignore_DOCUMENTATION

t_ignore_DOCUMENTATION(t)

\/{2}(.*)

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

def t_ignore_DOCUMENTATION(self, t):
    r"\/{2}(.*)"
    for substring in ["//", "/*", "*/"]:
        t.value = t.value.replace(substring, "")
    t.value = t.value.strip()

t_RIGHT_ARROW

t_RIGHT_ARROW(t)

->

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

def t_RIGHT_ARROW(self, t):
    r"->"
    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/mapper/lexer.py

def t_DATETIME(self, t):
    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/mapper/lexer.py

def t_DATE(self, t):
    r"@\d{4}(?:-\d{2}(?:-\d{2})?)?"
    return t

t_BOOLEAN

t_BOOLEAN(t)

true|false

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

def t_BOOLEAN(self, t):
    r"true|false"
    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/mapper/lexer.py

def t_TIME(self, t):
    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/mapper/lexer.py

def t_NUMBER(self, t):
    r"-?\d+(\.\d+)?"
    if "." in t.value:
        t.value = float(t.value)
        t.type = "DECIMAL"
    else:
        t.value = int(t.value)
        t.type = "INTEGER"
    return t

t_STRING

t_STRING(t)

(\'([^\'])?\')|(\"([^\"])?\")

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

def t_STRING(self, t):
    r"(\'([^\']*)?\')|(\"([^\"]*)?\")"
    if t.value.startswith("'") and t.value.endswith("'"):
        t.value = t.value.strip("'")
    else:
        t.value = t.value.strip('"')
    return t

t_GROUPTYPE

t_GROUPTYPE(t)

<>|<>

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

def t_GROUPTYPE(self, t):
    r"<<types>>|<<type\+>>"
    t.value = t.value.strip("<").strip(">")
    t.value = {"types": "types", "type+": "type-and-types"}[t.value]
    return t

t_DOUBLE_EQUAL

t_DOUBLE_EQUAL(t)

==

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

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

t_DELIMITEDIDENTIFIER

t_DELIMITEDIDENTIFIER(t)

`[a-zA-Z][a-zA-Z0-9-][^`]*`

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

def t_DELIMITEDIDENTIFIER(self, t):
    r"\`[a-zA-Z][a-zA-Z0-9\-][^\`]*\`"
    t.value = t.value.strip("`")
    return t

t_error_invalid_function

t_error_invalid_function(t)

"

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

def t_error_invalid_function(self, t):
    r""" " """
    pass

FhirMappingLanguageLexerError
Path: `fhircraft.fhir.mapper.lexer.FhirMappingLanguageLexerError`

Bases: Exception

FhirMappingLanguageParser
Path: `fhircraft.fhir.mapper.parser.FhirMappingLanguageParser`

FhirMappingLanguageParser(debug=False, lexer_class=None)

Bases: FhirPathParser

An LALR-parser for the FHIR Mapping Language

Methods:

Name	Description
`p_mapper_structureMap`	structureMap : m_metadata m_mapId m_conceptmap m_structure_list m_imports_list m_const_list m_group_mapper_list
`p_mapper_metadata`	m_metadata : m_metadata m_metadata_entry
`p_mapper_metadata_entry`	m_metadata_entry : METADATA_DECLARATION m_identifier EQUAL m_metadata_value
`p_mapper_metadata_value`	m_metadata_value : m_literal
`p_mapper_mapId`	m_mapId : MAP m_url EQUAL m_identifier
`p_conceptmap`	m_conceptmap : CONCEPTMAP m_conceptmap_name '{' m_conceptmap_prefix_list m_conceptmap_mapping_list '}'
`p_conceptmap_name`	m_conceptmap_name : m_identifier
`p_conceptmap_prefix_list`	m_conceptmap_prefix_list : m_conceptmap_prefix_list m_conceptmap_prefix
`p_conceptmap_prefix`	m_conceptmap_prefix : PREFIX m_identifier EQUAL m_url
`p_conceptmap_mapping_list`	m_conceptmap_mapping_list : m_conceptmap_mapping_list m_conceptmap_mapping
`p_conceptmap_mapping`	m_conceptmap_mapping : m_identifier ':' m_conceptmap_code m_conceptmap_operator m_identifier ':' m_conceptmap_code
`p_conceptmap_code`	m_conceptmap_code : m_identifier
`p_conceptmap_operator`	m_conceptmap_operator : EQUAL
`p_mapper_structure_list`	m_structure_list : m_structure_list m_structure
`p_mapper_imports_list`	m_imports_list : m_imports_list m_imports
`p_mapper_const_list`	m_const_list : m_const_list m_const
`p_mapper_group_mapper_list`	m_group_mapper_list : m_group_mapper_list m_group
`p_mapper_structure`	m_structure : USES m_url m_structureAlias AS m_model_mode
`p_mapper_structureAlias`	m_structureAlias : ALIAS m_identifier
`p_mapper_model_mode`	m_model_mode : SOURCE
`p_mapper_imports`	m_imports : IMPORTS m_url
`p_mapper_const`	m_const : LET m_identifier EQUAL m_fhirpath ';'
`p_mapper_extending_group`	m_group : GROUP m_identifier m_parameters m_extends GROUPTYPE m_rules
`p_mapper_group`	m_group : GROUP m_identifier m_parameters GROUPTYPE m_rules
`p_mapper_parameters`	m_parameters : '(' m_parameter_list ')'
`p_mapper_parameter_list`	m_parameter_list : m_parameter ',' m_parameter
`p_mapper_parameter`	m_parameter : m_inputMode m_identifier m_type
`p_mapper_type`	m_type : ':' m_identifier
`p_mapper_inputMode`	m_inputMode : SOURCE
`p_mapper_extends`	m_extends : EXTENDS m_identifier
`p_mapper_empty_rules`	m_rules : '{' '}'
`p_mapper_rules`	m_rules : '{' m_rule_list '}'
`p_mapper_rule_list`	m_rule_list : m_rule_delimited
`p_mapper_rule_delimited`	m_rule_delimited : m_rule ';'
`p_mapper_rule_named`	m_rule : m_rule m_rule_name
`p_mapping_rule`	m_rule : m_rule_only_sources
`p_mapper_rule_only_sources`	m_rule_only_sources : m_rule_source_list m_dependent
`p_identifier_list`	m_identifier_list : m_identifier_list ',' m_identifier
`p_mapper_rule_full`	m_rule : m_rule_source_list RIGHT_ARROW m_rule_target_list m_dependent
`p_mapper_rule_name`	m_rule_name : m_identifier
`p_mapper_rule_source_list`	m_rule_source_list : m_rule_source_list ',' m_rule_source
`p_mapper_rule_source`	m_rule_source : m_rule_path m_source_modifiers
`p_mapper_source_modifiers`	m_source_modifiers : m_source_modifiers m_source_modifier
`p_mapper_source_modifier`	m_source_modifier : m_sourceType
`p_mapper_rule_context`	m_rule_path : m_identifier
`p_mapper_rule_context_with_element`	m_rule_path : m_identifier '.' m_identifier
`p_mapper_rule_context_with_subelements`	m_rule_path : m_rule_path '.' m_identifier
`p_mapper_sourceType`	m_sourceType : ':' m_identifier
`p_mapper_sourceCardinality`	m_sourceCardinality : INTEGER '.' '.' INTEGER
`p_mapper_sourceDefault`	m_sourceDefault : DEFAULT '(' m_fhirpath ')'
`p_mapper_sourceListMode`	m_sourceListMode : FIRST
`p_mapper_alias`	m_alias : AS m_identifier
`p_mapper_whereClause`	m_whereClause : WHERE '(' m_fhirpath ')'
`p_mapper_checkClause`	m_checkClause : CHECK '(' m_fhirpath ')'
`p_mapper_log`	m_log : LOG '(' m_fhirpath ')'
`p_mapper_rule_target_list`	m_rule_target_list : m_rule_target_list ',' m_rule_target
`p_mapper_rule_target_with_invocation`	m_rule_target : m_invocation m_target_modifier_list
`p_mapper_rule_target`	m_rule_target : m_rule_path EQUAL m_transform m_target_modifier_list
`p_mapper_target_modifier_list`	m_target_modifier_list : m_target_modifier_list m_target_modifier
`p_mapper_target_modifier`	m_target_modifier : m_alias
`p_mapper_targetListMode`	m_targetListMode : FIRST
`p_mapper_transform`	m_transform : m_transform_fhirpath
`p_mapper_transform_rule_path`	m_transform_rule_path : m_rule_path
`p_mapper_transform_fhirpath`	m_transform_fhirpath : '(' m_fhirpath ')'
`p_mapper_transform_literal`	m_transform_literal : m_literal
`p_mapper_transform_invocation`	m_transform_invocation : m_invocation
`p_mapper_dependent_rules`	m_dependent : THEN m_rules
`p_mapper_dependent_invocation_list`	m_dependent : THEN m_invocation_list
`p_mapper_dependent_mixed`	m_dependent : THEN m_invocation_list m_rules
`p_mapper_invocation_list`	m_invocation_list : m_invocation_list ',' m_invocation
`p_mapper_invocation_with_parameters`	m_invocation : m_identifier '(' m_param_list ')'
`p_mapper_invocation`	m_invocation : m_identifier '(' ')'
`p_mapper_param_list`	m_param_list : m_param_list ',' m_param
`p_mapper_param`	m_param : m_param_id
`p_mapper_param_literal`	m_param_literal : m_literal
`p_mapper_param_id`	m_param_id : m_identifier
`p_mapper_fhirPath`	m_fhirpath : expression
`p_mapper_url`	m_url : DELIMITEDIDENTIFIER
`p_mapper_identifier`	m_identifier : IDENTIFIER
`p_mapper_literal`	m_literal : INTEGER
`p_mapper_time`	m_time : TIME
`p_mapper_date`	m_date : DATE
`p_mapper_datetime`	m_datetime : DATETIME
`p_mapper_empty`	m_empty :