def handle_tuple(context, phenotype: PhenotypeModel, define_name, final):
log('tuple')
obj = get_obj_context(context.getChild(0).getChild(1), to_string=True)
num_children = len(context.children)
op_raw_text = ''
tuple_name = '{}_Step1'.format(define_name)
if num_children == 2:
operation = parse_operation(context.getChild(1), tuple_name, final)
if operation:
if not phenotype.operations:
phenotype.operations = list()
phenotype.operations.append(operation)
op_raw_text = operation.get('raw_text')
else:
operation = None
raw_text = '''
Tuple {}
{}
'''
if not operation:
where = ''
else:
where = 'where {}'.format(op_raw_text)
tuple_str = json.dumps(obj, indent=4)
pe = PhenotypeEntity(tuple_name, 'define', final=final, tuple_=True, tuple_object=obj, tuple_predicate=operation,
raw_text=raw_text.format(tuple_str, where), tuple_raw_text='Tuple {}'.format(tuple_str))
if not phenotype.tuples:
phenotype.tuples = list()
phenotype.tuples.append(pe)
def handle_operation(context, phenotype: PhenotypeModel, define_name, final):
print('operation')
# SepsisState = PhenotypeOperations('SepsisState', 'OR', ['onVentilator', 'hasSepsis'], final=True)
# : notOperator=(NOT | BANG) expression
# | expression logicalOperator expression
# | predicate IS NOT? BOOL
expression_context = context.getChild(1)
first = expression_context.getChild(0)
res = None
if type(first) == nlpql_parserParser.NotOperatorContext:
res = get_not_expression(expression_context, define_name, final)
elif type(first) == nlpql_parserParser.ExpressionContext:
res = get_logical_expression(expression_context, define_name, final)
elif type(first) == nlpql_parserParser.PredicateBooleanContext:
res = get_predicate_boolean(expression_context, define_name, final)
elif type(first) == nlpql_parserParser.PredicateContext:
res = get_predicate_expression(expression_context.getChild(0),
define_name, final)
if not phenotype.operations:
phenotype.operations = list()
if res:
phenotype.operations.append(res)
def handle_operation(context, phenotype: PhenotypeModel, define_name, final):
print('operation')
# SepsisState = PhenotypeOperations('SepsisState', 'OR', ['onVentilator', 'hasSepsis'], final=True)
# : notOperator=(NOT | BANG) expression
# | expression logicalOperator expression
# | predicate IS NOT? BOOL
expression_context = context.getChild(1)
first = expression_context.getChild(0)
res = None
if type(first) == nlpql_parserParser.NotOperatorContext:
res = get_not_expression(expression_context, define_name, final)
elif type(first) == nlpql_parserParser.ExpressionContext:
res = get_logical_expression(expression_context, define_name, final)
elif type(first) == nlpql_parserParser.PredicateBooleanContext:
res = get_predicate_boolean(expression_context, define_name, final)
elif type(first) == nlpql_parserParser.PredicateContext:
res = get_predicate_expression(expression_context.getChild(0), define_name, final)
if not phenotype.operations:
phenotype.operations = list()
if res:
phenotype.operations.append(res)
def handle_include(context, phenotype: PhenotypeModel):
print('include')
# ohdsi_helpers = PhenotypeDefine('OHDSIHelpers', 'include', version='1.0', alias='OHDSI')
# include OHDSIHelpers version "1.0" called OHDSI;
phenotype_def = None
previous = ''
for c in context.getChildren():
if previous == 'include':
desc = c.getText()
phenotype_def = PhenotypeDefine(desc, previous)
elif previous == 'called':
alias = c.getText()
phenotype_def['alias'] = alias
elif type(c) == nlpql_parserParser.VersionContext:
version = c.getChild(1).getText().strip('"')
phenotype_def['version'] = version
previous = c.getText()
if not phenotype.includes:
phenotype.includes = list()
phenotype.includes.append(phenotype_def)
def handle_data_entity(context, phenotype: PhenotypeModel, define_name, final):
print('data entity')
pe = PhenotypeEntity(define_name, 'define', final=final)
call = get_method_call(context.getChild(0))
# hasSepsis = PhenotypeEntity('hasSepsis', 'define',
# library='ClarityNLP',
# funct='ProviderAssertion',
# named_arguments={
# "termsets": ['Sepsis'],
# "documentsets": [
# 'ProviderNotes',
# "Radiology"
# ]
# })
pe["funct"] = call["funct"]
pe["library"] = call["library"]
named_args = call["named_arguments"]
args = call["arguments"]
if named_args:
pe["named_arguments"] = named_args
if args and len(args) > 0:
pe["arguments"] = args
if not phenotype.data_entities:
phenotype.data_entities = list()
phenotype.data_entities.append(pe)
def handle_include(context, phenotype: PhenotypeModel):
print('include')
# ohdsi_helpers = PhenotypeDefine('OHDSIHelpers', 'include', version='1.0', alias='OHDSI')
# include OHDSIHelpers version "1.0" called OHDSI;
phenotype_def = None
previous = ''
for c in context.getChildren():
if previous == 'include':
desc = c.getText()
phenotype_def = PhenotypeDefine(desc, previous)
elif previous == 'called':
alias = c.getText()
phenotype_def['alias'] = alias
elif type(c) == nlpql_parserParser.VersionContext:
version = c.getChild(1).getText().strip('"')
phenotype_def['version'] = version
previous = c.getText()
if not phenotype.includes:
phenotype.includes = list()
phenotype.includes.append(phenotype_def)
def handle_data_entity(context, phenotype: PhenotypeModel, define_name, final):
print('data entity')
pe = PhenotypeEntity(define_name, 'define', final=final)
call = get_method_call(context.getChild(0))
# hasSepsis = PhenotypeEntity('hasSepsis', 'define',
# library='ClarityNLP',
# funct='ProviderAssertion',
# named_arguments={
# "termsets": ['Sepsis'],
# "documentsets": [
# 'ProviderNotes',
# "Radiology"
# ]
# })
pe["funct"] = call["funct"]
pe["library"] = call["library"]
named_args = call["named_arguments"]
args = call["arguments"]
if named_args:
pe["named_arguments"] = named_args
if args and len(args) > 0:
pe["arguments"] = args
if not phenotype.data_entities:
phenotype.data_entities = list()
phenotype.data_entities.append(pe)
def handle_phenotype_name(context, phenotype: PhenotypeModel):
print('phenotype_name')
previous = ''
phenotype_def = None
name = ''
for c in context.getChildren():
if previous == 'phenotype':
desc = c.getText().replace('"', '').strip()
phenotype_def = PhenotypeDefine(desc, previous)
name = desc
elif type(c) == nlpql_parserParser.VersionContext:
version = c.getChild(1).getText().strip('"')
phenotype_def['version'] = version
previous = c.getText()
phenotype.name = name
phenotype.phenotype = phenotype_def
def handle_phenotype_name(context, phenotype: PhenotypeModel):
print('phenotype_name')
previous = ''
phenotype_def = None
name = ''
for c in context.getChildren():
if previous == 'phenotype':
desc = c.getText().replace('"', '').strip()
phenotype_def = PhenotypeDefine(desc, previous)
name = desc
elif type(c) == nlpql_parserParser.VersionContext:
version = c.getChild(1).getText().strip('"')
phenotype_def['version'] = version
previous = c.getText()
phenotype.name = name
phenotype.phenotype = phenotype_def
def handle_operation(context, phenotype: PhenotypeModel, define_name, final):
log('operation')
# SepsisState = PhenotypeOperations('SepsisState', 'OR', ['onVentilator', 'hasSepsis'], final=True)
# : notOperator=(NOT | BANG) expression
# | expression logicalOperator expression
# | predicate IS NOT? BOOL
res = parse_operation(context, define_name, final)
if not phenotype.operations:
phenotype.operations = list()
if res:
phenotype.operations.append(res)
def handle_cohort(context, phenotype: PhenotypeModel):
print('cohort')
call = get_pair_method(context.getChild(1))
name = call["name"]
library = call["method"]["library"]
funct = call["method"]["funct"]
arguments = call["method"]["arguments"]
named_arguments = call["method"]["named_arguments"]
phenotype_def = PhenotypeDefine(name, 'cohort', library=library,
funct=funct, arguments=arguments,
named_arguments=named_arguments)
if not phenotype.cohorts:
phenotype.cohorts = list()
phenotype.cohorts.append(phenotype_def)
def handle_cohort(context, phenotype: PhenotypeModel):
print('cohort')
call = get_pair_method(context.getChild(1))
name = call["name"]
library = call["method"]["library"]
funct = call["method"]["funct"]
arguments = call["method"]["arguments"]
named_arguments = call["method"]["named_arguments"]
phenotype_def = PhenotypeDefine(name, 'cohort', library=library,
funct=funct, arguments=arguments,
named_arguments=named_arguments)
if not phenotype.cohorts:
phenotype.cohorts = list()
phenotype.cohorts.append(phenotype_def)
def handle_document_set(context, phenotype: PhenotypeModel):
print('document set')
# documentset ProviderNotes: Clarity.createDocumentList("'Physician' OR 'Nurse' OR 'Note' OR 'Discharge Summary'");
call = get_pair_method(context.getChild(1))
name = call["name"]
library = call["method"]["library"]
funct = call["method"]["funct"]
arguments = call["method"]["arguments"]
named_arguments = call["method"]["named_arguments"]
phenotype_def = PhenotypeDefine(name, 'documentset', library=library,
funct=funct, arguments=arguments, named_arguments=named_arguments)
if not phenotype.document_sets:
phenotype.document_sets = list()
phenotype.document_sets.append(phenotype_def)
def handle_data_model(context, phenotype: PhenotypeModel):
print('data model')
previous = ''
phenotype_def = None
for c in context.getChildren():
if previous == 'datamodel':
desc = c.getText()
phenotype_def = PhenotypeDefine(desc, previous)
elif type(c) == nlpql_parserParser.VersionContext:
version = c.getChild(1).getText().strip('"')
phenotype_def['version'] = version
previous = c.getText()
if not phenotype.data_models:
phenotype.data_models = list()
phenotype.data_models.append(phenotype_def)
def handle_data_model(context, phenotype: PhenotypeModel):
print('data model')
previous = ''
phenotype_def = None
for c in context.getChildren():
if previous == 'datamodel':
desc = c.getText()
phenotype_def = PhenotypeDefine(desc, previous)
elif type(c) == nlpql_parserParser.VersionContext:
version = c.getChild(1).getText().strip('"')
phenotype_def['version'] = version
previous = c.getText()
if not phenotype.data_models:
phenotype.data_models = list()
phenotype.data_models.append(phenotype_def)
def handle_document_set(context, phenotype: PhenotypeModel):
print('document set')
# documentset ProviderNotes: Clarity.createDocumentList("'Physician' OR 'Nurse' OR 'Note' OR 'Discharge Summary'");
call = get_pair_method(context.getChild(1))
name = call["name"]
library = call["method"]["library"]
funct = call["method"]["funct"]
arguments = call["method"]["arguments"]
named_arguments = call["method"]["named_arguments"]
phenotype_def = PhenotypeDefine(name, 'documentset', library=library,
funct=funct, arguments=arguments, named_arguments=named_arguments)
if not phenotype.document_sets:
phenotype.document_sets = list()
phenotype.document_sets.append(phenotype_def)
def validate_phenotype(p_cfg: PhenotypeModel):
error = None
try:
if not error:
if not p_cfg:
error = "Empty phenotype object"
if not error and len(p_cfg.data_entities) == 0:
error = "Must have at least one data entity (define)"
if not error and len(p_cfg.operations) > 0 and len(
p_cfg.data_entities) == 0:
error = "Operations (define) require at least one data entity (define)"
except Exception as ex:
log(ex)
error = ''.join(traceback.format_stack())
# Run validity and syntax checks on all expressions, ensure that only
# defined names are used as variables, etc.
name_list = get_all_names(p_cfg)
# get raw text of all expressions
KEY_RAW = 'raw_text'
expression_list = []
for i, op in enumerate(p_cfg.operations):
if KEY_RAW in op:
# save expression index and raw text
expression_list.append((i, op[KEY_RAW]))
for i, expr in expression_list:
# The 'parse_result' is a string of whitespace-separated expression
# tokens. Invalid expressions cause an empty string to be returned.
parse_result = expr_eval.parse_expression(expr, name_list)
if 0 == len(parse_result):
error = 'Invalid expression: {0}'.format(expr)
break
else:
# saved the parse result for later use
p_cfg.operations[i]['normalized_expr'] = parse_result
if not error:
return {"success": True}
else:
return {"success": False, "error": error}
def handle_term_set(context, phenotype: PhenotypeModel):
print('term set')
# termset RigorsTerms: ["Rigors",
# "Rigoring",
# "Rigours",
# "Rigouring",
# "Chill",
# "Chills",
# "Shivers",
# "Shivering",
# "Teeth chattering"];
# Sepsis = PhenotypeDefine("Sepsis", "termset", values=['Sepsis', 'Systemic infection'])
ts = get_pair_array(context.getChild(1))
pd = PhenotypeDefine(ts["name"], "termset", values=ts["array"])
if not phenotype.term_sets:
phenotype.term_sets = list()
phenotype.term_sets.append(pd)
def handle_term_set(context, phenotype: PhenotypeModel):
print('term set')
# termset RigorsTerms: ["Rigors",
# "Rigoring",
# "Rigours",
# "Rigouring",
# "Chill",
# "Chills",
# "Shivers",
# "Shivering",
# "Teeth chattering"];
# Sepsis = PhenotypeDefine("Sepsis", "termset", values=['Sepsis', 'Systemic infection'])
ts = get_pair_array(context.getChild(1))
pd = PhenotypeDefine(ts["name"], "termset", values=ts["array"])
if not phenotype.term_sets:
phenotype.term_sets = list()
phenotype.term_sets.append(pd)
def handle_value_set(context, phenotype: PhenotypeModel):
print('value set')
# Sepsis = PhenotypeDefine('Sepsis', 'valueset', library='OHDSI',
# funct='getConceptSet',
# arguments=['assets/Sepsis.json'])
# valueset RigorsConcepts:OHDSI.getConceptSet("assets/RigorsConcepts.json");
call = get_pair_method(context.getChild(1))
name = call["name"]
library = call["method"]["library"]
funct = call["method"]["funct"]
arguments = call["method"]["arguments"]
phenotype_def = PhenotypeDefine(name, 'valueset', library=library,
funct=funct, arguments=arguments)
if not phenotype.value_sets:
phenotype.value_sets = list()
phenotype.value_sets.append(phenotype_def)
def handle_value_set(context, phenotype: PhenotypeModel):
print('value set')
# Sepsis = PhenotypeDefine('Sepsis', 'valueset', library='OHDSI',
# funct='getConceptSet',
# arguments=['assets/Sepsis.json'])
# valueset RigorsConcepts:OHDSI.getConceptSet("assets/RigorsConcepts.json");
call = get_pair_method(context.getChild(1))
name = call["name"]
library = call["method"]["library"]
funct = call["method"]["funct"]
arguments = call["method"]["arguments"]
phenotype_def = PhenotypeDefine(name, 'valueset', library=library,
funct=funct, arguments=arguments)
if not phenotype.value_sets:
phenotype.value_sets = list()
phenotype.value_sets.append(phenotype_def)
def handle_code_system(context, phenotype: PhenotypeModel):
print('code system')
# codesystem OMOP: "http://omop.org";
# omop = PhenotypeDefine('OMOP', 'codesystem', values=['http://omop.org'])
identifier = context.getChild(1)
kv = get_identifier_pair(identifier)
if type(kv['value']) == list:
phenotype_def = PhenotypeDefine(kv['name'], 'codesystem', values=kv['value'])
else:
vals = list()
vals.append(kv['value'])
phenotype_def = PhenotypeDefine(kv['name'], 'codesystem', values=vals)
if not phenotype.code_systems:
phenotype.code_systems = list()
phenotype.code_systems.append(phenotype_def)
def handle_code_system(context, phenotype: PhenotypeModel):
print('code system')
# codesystem OMOP: "http://omop.org";
# omop = PhenotypeDefine('OMOP', 'codesystem', values=['http://omop.org'])
identifier = context.getChild(1)
kv = get_identifier_pair(identifier)
if type(kv['value']) == list:
phenotype_def = PhenotypeDefine(kv['name'], 'codesystem', values=kv['value'])
else:
vals = list()
vals.append(kv['value'])
phenotype_def = PhenotypeDefine(kv['name'], 'codesystem', values=vals)
if not phenotype.code_systems:
phenotype.code_systems = list()
phenotype.code_systems.append(phenotype_def)
def handle_expression(expr):
has_errors = False
has_warnings = False
errors = []
unknown = []
p = PhenotypeModel()
for child in expr.getChildren():
if type(child) == nlpql_parserParser.StatementContext:
statement_members = child.getChildren()
for stmt in statement_members:
stmt_type = type(stmt)
if not stmt_type == antlr4.tree.Tree.TerminalNodeImpl:
if stmt_type == antlr4.tree.Tree.ErrorNodeImpl:
has_errors = True
errors.append(stmt)
elif stmt_type in handlers:
try:
handlers[stmt_type](stmt, p)
except Exception as ex:
has_errors = True
print(ex)
traceback.print_exc(file=sys.stderr)
error = ''.join(traceback.format_stack())
errors.append(error)
else:
has_warnings = True
unknown.append(child)
print('UNKNOWN child: ' + child.getText())
return {
"has_warnings": has_warnings,
"has_errors": has_errors,
"errors": errors,
"warnings": unknown,
"phenotype": p,
"valid": not has_errors and not has_warnings
}
def handle_context(context, phenotype: PhenotypeModel):
phenotype.context = context.getChild(1).getText()
def handle_description(context, phenotype: PhenotypeModel):
phenotype.description = context.getChild(1).getText()
def handle_limit(context, phenotype: PhenotypeModel):
limit = context.getChild(1).getText()
if len(limit) > 0:
phenotype.limit = int(limit)
def handle_debug(context, phenotype: PhenotypeModel):
phenotype.debug = True
def handle_debug(context, phenotype: PhenotypeModel):
phenotype.debug = True
def handle_limit(context, phenotype: PhenotypeModel):
limit = context.getChild(1).getText()
if len(limit) > 0:
phenotype.limit = int(limit)
def handle_context(context, phenotype: PhenotypeModel):
phenotype.context = context.getChild(1).getText()
def handle_description(context, phenotype: PhenotypeModel):
phenotype.description = context.getChild(1).getText()