sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_regulate_amounts; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 10; 5, 21; 5, 25; 5, 37; 5, 41; 5, 52; 5, 64; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:qstr; 9, string:"$.events.frames[(@.type is 'transcription')]"; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:res; 13, call; 13, 14; 13, 19; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:tree; 18, identifier:execute; 19, argument_list; 19, 20; 20, identifier:qstr; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:all_res; 24, list:[]; 25, if_statement; 25, 26; 25, 29; 26, comparison_operator:is; 26, 27; 26, 28; 27, identifier:res; 28, None; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, augmented_assignment:+=; 31, 32; 31, 33; 32, identifier:all_res; 33, call; 33, 34; 33, 35; 34, identifier:list; 35, argument_list; 35, 36; 36, identifier:res; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:qstr; 40, string:"$.events.frames[(@.type is 'amount')]"; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:res; 44, call; 44, 45; 44, 50; 45, attribute; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:tree; 49, identifier:execute; 50, argument_list; 50, 51; 51, identifier:qstr; 52, if_statement; 52, 53; 52, 56; 53, comparison_operator:is; 53, 54; 53, 55; 54, identifier:res; 55, None; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, augmented_assignment:+=; 58, 59; 58, 60; 59, identifier:all_res; 60, call; 60, 61; 60, 62; 61, identifier:list; 62, argument_list; 62, 63; 63, identifier:res; 64, for_statement; 64, 65; 64, 66; 64, 67; 65, identifier:r; 66, identifier:all_res; 67, block; 67, 68; 67, 77; 67, 86; 67, 95; 67, 106; 67, 112; 67, 118; 67, 122; 67, 143; 67, 149; 67, 160; 67, 168; 67, 179; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:subtype; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:r; 74, identifier:get; 75, argument_list; 75, 76; 76, string:'subtype'; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:epistemics; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:_get_epistemics; 84, argument_list; 84, 85; 85, identifier:r; 86, if_statement; 86, 87; 86, 93; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:epistemics; 90, identifier:get; 91, argument_list; 91, 92; 92, string:'negated'; 93, block; 93, 94; 94, continue_statement; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 100; 97, pattern_list; 97, 98; 97, 99; 98, identifier:annotations; 99, identifier:context; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:_get_annot_context; 104, argument_list; 104, 105; 105, identifier:r; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:frame_id; 109, subscript; 109, 110; 109, 111; 110, identifier:r; 111, string:'frame_id'; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:args; 115, subscript; 115, 116; 115, 117; 116, identifier:r; 117, string:'arguments'; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:theme; 121, None; 122, for_statement; 122, 123; 122, 124; 122, 125; 123, identifier:a; 124, identifier:args; 125, block; 125, 126; 126, if_statement; 126, 127; 126, 135; 127, comparison_operator:==; 127, 128; 127, 134; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:_get_arg_type; 132, argument_list; 132, 133; 133, identifier:a; 134, string:'theme'; 135, block; 135, 136; 135, 142; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:theme; 139, subscript; 139, 140; 139, 141; 140, identifier:a; 141, string:'arg'; 142, break_statement; 143, if_statement; 143, 144; 143, 147; 144, comparison_operator:is; 144, 145; 144, 146; 145, identifier:theme; 146, None; 147, block; 147, 148; 148, continue_statement; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 154; 151, pattern_list; 151, 152; 151, 153; 152, identifier:theme_agent; 153, identifier:theme_coords; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:_get_agent_from_entity; 158, argument_list; 158, 159; 159, identifier:theme; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:qstr; 163, binary_operator:+; 163, 164; 163, 165; 164, string:"$.events.frames[(@.type is 'regulation') and "; 165, binary_operator:%; 165, 166; 165, 167; 166, string:"(@.arguments[0].arg is '%s')]"; 167, identifier:frame_id; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:reg_res; 171, call; 171, 172; 171, 177; 172, attribute; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:self; 175, identifier:tree; 176, identifier:execute; 177, argument_list; 177, 178; 178, identifier:qstr; 179, for_statement; 179, 180; 179, 181; 179, 182; 180, identifier:reg; 181, identifier:reg_res; 182, block; 182, 183; 182, 191; 182, 219; 182, 225; 182, 235; 182, 261; 182, 268; 182, 277; 182, 300; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 188; 185, pattern_list; 185, 186; 185, 187; 186, identifier:controller_agent; 187, identifier:controller_coords; 188, expression_list; 188, 189; 188, 190; 189, None; 190, None; 191, for_statement; 191, 192; 191, 193; 191, 196; 192, identifier:a; 193, subscript; 193, 194; 193, 195; 194, identifier:reg; 195, string:'arguments'; 196, block; 196, 197; 197, if_statement; 197, 198; 197, 206; 198, comparison_operator:==; 198, 199; 198, 205; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:self; 202, identifier:_get_arg_type; 203, argument_list; 203, 204; 204, identifier:a; 205, string:'controller'; 206, block; 206, 207; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 212; 208, 213; 209, pattern_list; 209, 210; 209, 211; 210, identifier:controller_agent; 211, identifier:controller_coords; 212, line_continuation:\; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:self; 216, identifier:_get_controller_agent; 217, argument_list; 217, 218; 218, identifier:a; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:sentence; 222, subscript; 222, 223; 222, 224; 223, identifier:reg; 224, string:'verbose-text'; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 232; 227, subscript; 227, 228; 227, 231; 228, subscript; 228, 229; 228, 230; 229, identifier:annotations; 230, string:'agents'; 231, string:'coords'; 232, list:[controller_coords,
theme_coords]; 232, 233; 232, 234; 233, identifier:controller_coords; 234, identifier:theme_coords; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:ev; 238, call; 238, 239; 238, 240; 239, identifier:Evidence; 240, argument_list; 240, 241; 240, 244; 240, 247; 240, 250; 240, 255; 240, 258; 241, keyword_argument; 241, 242; 241, 243; 242, identifier:source_api; 243, string:'reach'; 244, keyword_argument; 244, 245; 244, 246; 245, identifier:text; 246, identifier:sentence; 247, keyword_argument; 247, 248; 247, 249; 248, identifier:annotations; 249, identifier:annotations; 250, keyword_argument; 250, 251; 250, 252; 251, identifier:pmid; 252, attribute; 252, 253; 252, 254; 253, identifier:self; 254, identifier:citation; 255, keyword_argument; 255, 256; 255, 257; 256, identifier:context; 257, identifier:context; 258, keyword_argument; 258, 259; 258, 260; 259, identifier:epistemics; 260, identifier:epistemics; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:args; 264, list:[controller_agent, theme_agent, ev]; 264, 265; 264, 266; 264, 267; 265, identifier:controller_agent; 266, identifier:theme_agent; 267, identifier:ev; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:subtype; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:reg; 274, identifier:get; 275, argument_list; 275, 276; 276, string:'subtype'; 277, if_statement; 277, 278; 277, 281; 277, 290; 278, comparison_operator:==; 278, 279; 278, 280; 279, identifier:subtype; 280, string:'positive-regulation'; 281, block; 281, 282; 282, expression_statement; 282, 283; 283, assignment; 283, 284; 283, 285; 284, identifier:st; 285, call; 285, 286; 285, 287; 286, identifier:IncreaseAmount; 287, argument_list; 287, 288; 288, list_splat; 288, 289; 289, identifier:args; 290, else_clause; 290, 291; 291, block; 291, 292; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 295; 294, identifier:st; 295, call; 295, 296; 295, 297; 296, identifier:DecreaseAmount; 297, argument_list; 297, 298; 298, list_splat; 298, 299; 299, identifier:args; 300, expression_statement; 300, 301; 301, call; 301, 302; 301, 307; 302, attribute; 302, 303; 302, 306; 303, attribute; 303, 304; 303, 305; 304, identifier:self; 305, identifier:statements; 306, identifier:append; 307, argument_list; 307, 308; 308, identifier:st | def get_regulate_amounts(self):
qstr = "$.events.frames[(@.type is 'transcription')]"
res = self.tree.execute(qstr)
all_res = []
if res is not None:
all_res += list(res)
qstr = "$.events.frames[(@.type is 'amount')]"
res = self.tree.execute(qstr)
if res is not None:
all_res += list(res)
for r in all_res:
subtype = r.get('subtype')
epistemics = self._get_epistemics(r)
if epistemics.get('negated'):
continue
annotations, context = self._get_annot_context(r)
frame_id = r['frame_id']
args = r['arguments']
theme = None
for a in args:
if self._get_arg_type(a) == 'theme':
theme = a['arg']
break
if theme is None:
continue
theme_agent, theme_coords = self._get_agent_from_entity(theme)
qstr = "$.events.frames[(@.type is 'regulation') and " + \
"(@.arguments[0].arg is '%s')]" % frame_id
reg_res = self.tree.execute(qstr)
for reg in reg_res:
controller_agent, controller_coords = None, None
for a in reg['arguments']:
if self._get_arg_type(a) == 'controller':
controller_agent, controller_coords = \
self._get_controller_agent(a)
sentence = reg['verbose-text']
annotations['agents']['coords'] = [controller_coords,
theme_coords]
ev = Evidence(source_api='reach', text=sentence,
annotations=annotations, pmid=self.citation,
context=context, epistemics=epistemics)
args = [controller_agent, theme_agent, ev]
subtype = reg.get('subtype')
if subtype == 'positive-regulation':
st = IncreaseAmount(*args)
else:
st = DecreaseAmount(*args)
self.statements.append(st) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_get_entity_coordinates; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:entity_term; 6, block; 6, 7; 6, 16; 6, 23; 6, 29; 6, 40; 6, 47; 6, 61; 6, 70; 6, 77; 6, 86; 6, 93; 6, 102; 6, 111; 6, 122; 6, 131; 6, 140; 6, 151; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:sent_id; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:entity_term; 13, identifier:get; 14, argument_list; 14, 15; 15, string:'sentence'; 16, if_statement; 16, 17; 16, 20; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:sent_id; 19, None; 20, block; 20, 21; 21, return_statement; 21, 22; 22, None; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:qstr; 26, binary_operator:%; 26, 27; 26, 28; 27, string:"$.sentences.frames[(@.frame_id is \'%s')]"; 28, identifier:sent_id; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:res; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:tree; 37, identifier:execute; 38, argument_list; 38, 39; 39, identifier:qstr; 40, if_statement; 40, 41; 40, 44; 41, comparison_operator:is; 41, 42; 41, 43; 42, identifier:res; 43, None; 44, block; 44, 45; 45, return_statement; 45, 46; 46, None; 47, try_statement; 47, 48; 47, 56; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:sentence; 52, call; 52, 53; 52, 54; 53, identifier:next; 54, argument_list; 54, 55; 55, identifier:res; 56, except_clause; 56, 57; 56, 58; 57, identifier:StopIteration; 58, block; 58, 59; 59, return_statement; 59, 60; 60, None; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:sent_start; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:sentence; 67, identifier:get; 68, argument_list; 68, 69; 69, string:'start-pos'; 70, if_statement; 70, 71; 70, 74; 71, comparison_operator:is; 71, 72; 71, 73; 72, identifier:sent_start; 73, None; 74, block; 74, 75; 75, return_statement; 75, 76; 76, None; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:sent_start; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:sent_start; 83, identifier:get; 84, argument_list; 84, 85; 85, string:'offset'; 86, if_statement; 86, 87; 86, 90; 87, comparison_operator:is; 87, 88; 87, 89; 88, identifier:sent_start; 89, None; 90, block; 90, 91; 91, return_statement; 91, 92; 92, None; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:entity_start; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:entity_term; 99, identifier:get; 100, argument_list; 100, 101; 101, string:'start-pos'; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:entity_stop; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:entity_term; 108, identifier:get; 109, argument_list; 109, 110; 110, string:'end-pos'; 111, if_statement; 111, 112; 111, 119; 112, boolean_operator:or; 112, 113; 112, 116; 113, comparison_operator:is; 113, 114; 113, 115; 114, identifier:entity_start; 115, None; 116, comparison_operator:is; 116, 117; 116, 118; 117, identifier:entity_stop; 118, None; 119, block; 119, 120; 120, return_statement; 120, 121; 121, None; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:entity_start; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:entity_start; 128, identifier:get; 129, argument_list; 129, 130; 130, string:'offset'; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:entity_stop; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:entity_stop; 137, identifier:get; 138, argument_list; 138, 139; 139, string:'offset'; 140, if_statement; 140, 141; 140, 148; 141, boolean_operator:or; 141, 142; 141, 145; 142, comparison_operator:is; 142, 143; 142, 144; 143, identifier:entity_start; 144, None; 145, comparison_operator:is; 145, 146; 145, 147; 146, identifier:entity_stop; 147, None; 148, block; 148, 149; 149, return_statement; 149, 150; 150, None; 151, return_statement; 151, 152; 152, tuple; 152, 153; 152, 156; 153, binary_operator:-; 153, 154; 153, 155; 154, identifier:entity_start; 155, identifier:sent_start; 156, binary_operator:-; 156, 157; 156, 158; 157, identifier:entity_stop; 158, identifier:sent_start | def _get_entity_coordinates(self, entity_term):
sent_id = entity_term.get('sentence')
if sent_id is None:
return None
qstr = "$.sentences.frames[(@.frame_id is \'%s')]" % sent_id
res = self.tree.execute(qstr)
if res is None:
return None
try:
sentence = next(res)
except StopIteration:
return None
sent_start = sentence.get('start-pos')
if sent_start is None:
return None
sent_start = sent_start.get('offset')
if sent_start is None:
return None
entity_start = entity_term.get('start-pos')
entity_stop = entity_term.get('end-pos')
if entity_start is None or entity_stop is None:
return None
entity_start = entity_start.get('offset')
entity_stop = entity_stop.get('offset')
if entity_start is None or entity_stop is None:
return None
return (entity_start - sent_start, entity_stop - sent_start) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_evidence; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:relation; 6, block; 6, 7; 6, 16; 6, 20; 6, 24; 6, 211; 6, 226; 6, 249; 6, 253; 6, 262; 6, 271; 6, 280; 6, 295; 6, 312; 6, 333; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:provenance; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:relation; 13, identifier:get; 14, argument_list; 14, 15; 15, string:'provenance'; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:text; 19, None; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:context; 23, None; 24, if_statement; 24, 25; 24, 26; 25, identifier:provenance; 26, block; 26, 27; 26, 38; 26, 159; 26, 176; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:sentence_tag; 30, call; 30, 31; 30, 36; 31, attribute; 31, 32; 31, 35; 32, subscript; 32, 33; 32, 34; 33, identifier:provenance; 34, integer:0; 35, identifier:get; 36, argument_list; 36, 37; 37, string:'sentence'; 38, if_statement; 38, 39; 38, 44; 39, boolean_operator:and; 39, 40; 39, 41; 40, identifier:sentence_tag; 41, comparison_operator:in; 41, 42; 41, 43; 42, string:'@id'; 43, identifier:sentence_tag; 44, block; 44, 45; 44, 51; 44, 64; 44, 78; 44, 88; 44, 113; 44, 123; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:sentence_id; 48, subscript; 48, 49; 48, 50; 49, identifier:sentence_tag; 50, string:'@id'; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:sentence; 54, call; 54, 55; 54, 62; 55, attribute; 55, 56; 55, 61; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:doc; 60, identifier:sentences; 61, identifier:get; 62, argument_list; 62, 63; 63, identifier:sentence_id; 64, if_statement; 64, 65; 64, 68; 65, comparison_operator:is; 65, 66; 65, 67; 66, identifier:sentence; 67, None; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:text; 72, call; 72, 73; 72, 74; 73, identifier:_sanitize; 74, argument_list; 74, 75; 75, subscript; 75, 76; 75, 77; 76, identifier:sentence; 77, string:'text'; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:timexes; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:sentence; 84, identifier:get; 85, argument_list; 85, 86; 85, 87; 86, string:'timexes'; 87, list:[]; 88, if_statement; 88, 89; 88, 90; 89, identifier:timexes; 90, block; 90, 91; 90, 97; 90, 104; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:timex; 94, subscript; 94, 95; 94, 96; 95, identifier:timexes; 96, integer:0; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:tc; 100, call; 100, 101; 100, 102; 101, identifier:time_context_from_timex; 102, argument_list; 102, 103; 103, identifier:timex; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:context; 107, call; 107, 108; 107, 109; 108, identifier:WorldContext; 109, argument_list; 109, 110; 110, keyword_argument; 110, 111; 110, 112; 111, identifier:time; 112, identifier:tc; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:geolocs; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:sentence; 119, identifier:get; 120, argument_list; 120, 121; 120, 122; 121, string:'geolocs'; 122, list:[]; 123, if_statement; 123, 124; 123, 125; 124, identifier:geolocs; 125, block; 125, 126; 125, 132; 125, 139; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:geoloc; 129, subscript; 129, 130; 129, 131; 130, identifier:geolocs; 131, integer:0; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:rc; 135, call; 135, 136; 135, 137; 136, identifier:ref_context_from_geoloc; 137, argument_list; 137, 138; 138, identifier:geoloc; 139, if_statement; 139, 140; 139, 141; 139, 148; 140, identifier:context; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:context; 146, identifier:geo_location; 147, identifier:rc; 148, else_clause; 148, 149; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:context; 153, call; 153, 154; 153, 155; 154, identifier:WorldContext; 155, argument_list; 155, 156; 156, keyword_argument; 156, 157; 156, 158; 157, identifier:geo_location; 158, identifier:rc; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:doc_id; 162, call; 162, 163; 162, 174; 163, attribute; 163, 164; 163, 173; 164, call; 164, 165; 164, 170; 165, attribute; 165, 166; 165, 169; 166, subscript; 166, 167; 166, 168; 167, identifier:provenance; 168, integer:0; 169, identifier:get; 170, argument_list; 170, 171; 170, 172; 171, string:'document'; 172, dictionary; 173, identifier:get; 174, argument_list; 174, 175; 175, string:'@id'; 176, if_statement; 176, 177; 176, 178; 177, identifier:doc_id; 178, block; 178, 179; 178, 198; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:title; 182, call; 182, 183; 182, 196; 183, attribute; 183, 184; 183, 195; 184, call; 184, 185; 184, 192; 185, attribute; 185, 186; 185, 191; 186, attribute; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:self; 189, identifier:doc; 190, identifier:documents; 191, identifier:get; 192, argument_list; 192, 193; 192, 194; 193, identifier:doc_id; 194, dictionary; 195, identifier:get; 196, argument_list; 196, 197; 197, string:'title'; 198, if_statement; 198, 199; 198, 200; 199, identifier:title; 200, block; 200, 201; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 210; 203, subscript; 203, 204; 203, 209; 204, subscript; 204, 205; 204, 208; 205, subscript; 205, 206; 205, 207; 206, identifier:provenance; 207, integer:0; 208, string:'document'; 209, string:'title'; 210, identifier:title; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:annotations; 214, dictionary; 214, 215; 214, 223; 215, pair; 215, 216; 215, 217; 216, string:'found_by'; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:relation; 220, identifier:get; 221, argument_list; 221, 222; 222, string:'rule'; 223, pair; 223, 224; 223, 225; 224, string:'provenance'; 225, identifier:provenance; 226, if_statement; 226, 227; 226, 234; 227, comparison_operator:is; 227, 228; 227, 233; 228, attribute; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:self; 231, identifier:doc; 232, identifier:dct; 233, None; 234, block; 234, 235; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 240; 237, subscript; 237, 238; 237, 239; 238, identifier:annotations; 239, string:'document_creation_time'; 240, call; 240, 241; 240, 248; 241, attribute; 241, 242; 241, 247; 242, attribute; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:self; 245, identifier:doc; 246, identifier:dct; 247, identifier:to_json; 248, argument_list; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:epistemics; 252, dictionary; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:negations; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:self; 259, identifier:get_negation; 260, argument_list; 260, 261; 261, identifier:relation; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 265; 264, identifier:hedgings; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:self; 268, identifier:get_hedging; 269, argument_list; 269, 270; 270, identifier:relation; 271, if_statement; 271, 272; 271, 273; 272, identifier:hedgings; 273, block; 273, 274; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 279; 276, subscript; 276, 277; 276, 278; 277, identifier:epistemics; 278, string:'hedgings'; 279, identifier:hedgings; 280, if_statement; 280, 281; 280, 282; 281, identifier:negations; 282, block; 282, 283; 282, 289; 283, expression_statement; 283, 284; 284, assignment; 284, 285; 284, 288; 285, subscript; 285, 286; 285, 287; 286, identifier:epistemics; 287, string:'negated'; 288, True; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 294; 291, subscript; 291, 292; 291, 293; 292, identifier:annotations; 293, string:'negated_texts'; 294, identifier:negations; 295, if_statement; 295, 296; 295, 299; 296, comparison_operator:is; 296, 297; 296, 298; 297, identifier:text; 298, None; 299, block; 299, 300; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:text; 303, call; 303, 304; 303, 305; 304, identifier:_sanitize; 305, argument_list; 305, 306; 306, call; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:event; 309, identifier:get; 310, argument_list; 310, 311; 311, string:'text'; 312, expression_statement; 312, 313; 313, assignment; 313, 314; 313, 315; 314, identifier:ev; 315, call; 315, 316; 315, 317; 316, identifier:Evidence; 317, argument_list; 317, 318; 317, 321; 317, 324; 317, 327; 317, 330; 318, keyword_argument; 318, 319; 318, 320; 319, identifier:source_api; 320, string:'eidos'; 321, keyword_argument; 321, 322; 321, 323; 322, identifier:text; 323, identifier:text; 324, keyword_argument; 324, 325; 324, 326; 325, identifier:annotations; 326, identifier:annotations; 327, keyword_argument; 327, 328; 327, 329; 328, identifier:context; 329, identifier:context; 330, keyword_argument; 330, 331; 330, 332; 331, identifier:epistemics; 332, identifier:epistemics; 333, return_statement; 333, 334; 334, identifier:ev | def get_evidence(self, relation):
provenance = relation.get('provenance')
text = None
context = None
if provenance:
sentence_tag = provenance[0].get('sentence')
if sentence_tag and '@id' in sentence_tag:
sentence_id = sentence_tag['@id']
sentence = self.doc.sentences.get(sentence_id)
if sentence is not None:
text = _sanitize(sentence['text'])
timexes = sentence.get('timexes', [])
if timexes:
timex = timexes[0]
tc = time_context_from_timex(timex)
context = WorldContext(time=tc)
geolocs = sentence.get('geolocs', [])
if geolocs:
geoloc = geolocs[0]
rc = ref_context_from_geoloc(geoloc)
if context:
context.geo_location = rc
else:
context = WorldContext(geo_location=rc)
doc_id = provenance[0].get('document', {}).get('@id')
if doc_id:
title = self.doc.documents.get(doc_id, {}).get('title')
if title:
provenance[0]['document']['title'] = title
annotations = {'found_by': relation.get('rule'),
'provenance': provenance}
if self.doc.dct is not None:
annotations['document_creation_time'] = self.doc.dct.to_json()
epistemics = {}
negations = self.get_negation(relation)
hedgings = self.get_hedging(relation)
if hedgings:
epistemics['hedgings'] = hedgings
if negations:
epistemics['negated'] = True
annotations['negated_texts'] = negations
if text is None:
text = _sanitize(event.get('text'))
ev = Evidence(source_api='eidos', text=text, annotations=annotations,
context=context, epistemics=epistemics)
return ev |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_groundings; 3, parameters; 3, 4; 4, identifier:entity; 5, block; 5, 6; 5, 77; 5, 86; 5, 95; 5, 101; 5, 160; 6, function_definition; 6, 7; 6, 8; 6, 10; 7, function_name:get_grounding_entries; 8, parameters; 8, 9; 9, identifier:grounding; 10, block; 10, 11; 10, 17; 10, 21; 10, 31; 10, 75; 11, if_statement; 11, 12; 11, 14; 12, not_operator; 12, 13; 13, identifier:grounding; 14, block; 14, 15; 15, return_statement; 15, 16; 16, None; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:entries; 20, list:[]; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:values; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:grounding; 27, identifier:get; 28, argument_list; 28, 29; 28, 30; 29, string:'values'; 30, list:[]; 31, if_statement; 31, 32; 31, 33; 32, identifier:values; 33, block; 33, 34; 34, for_statement; 34, 35; 34, 36; 34, 37; 35, identifier:entry; 36, identifier:values; 37, block; 37, 38; 37, 47; 37, 56; 37, 66; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:ont_concept; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:entry; 44, identifier:get; 45, argument_list; 45, 46; 46, string:'ontologyConcept'; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:value; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:entry; 53, identifier:get; 54, argument_list; 54, 55; 55, string:'value'; 56, if_statement; 56, 57; 56, 64; 57, boolean_operator:or; 57, 58; 57, 61; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:ont_concept; 60, None; 61, comparison_operator:is; 61, 62; 61, 63; 62, identifier:value; 63, None; 64, block; 64, 65; 65, continue_statement; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:entries; 70, identifier:append; 71, argument_list; 71, 72; 72, tuple; 72, 73; 72, 74; 73, identifier:ont_concept; 74, identifier:value; 75, return_statement; 75, 76; 76, identifier:entries; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:db_refs; 80, dictionary; 80, 81; 81, pair; 81, 82; 81, 83; 82, string:'TEXT'; 83, subscript; 83, 84; 83, 85; 84, identifier:entity; 85, string:'text'; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:groundings; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:entity; 92, identifier:get; 93, argument_list; 93, 94; 94, string:'groundings'; 95, if_statement; 95, 96; 95, 98; 96, not_operator; 96, 97; 97, identifier:groundings; 98, block; 98, 99; 99, return_statement; 99, 100; 100, identifier:db_refs; 101, for_statement; 101, 102; 101, 103; 101, 104; 102, identifier:g; 103, identifier:groundings; 104, block; 104, 105; 104, 112; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:entries; 108, call; 108, 109; 108, 110; 109, identifier:get_grounding_entries; 110, argument_list; 110, 111; 111, identifier:g; 112, if_statement; 112, 113; 112, 114; 113, identifier:entries; 114, block; 114, 115; 114, 125; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:key; 118, call; 118, 119; 118, 124; 119, attribute; 119, 120; 119, 123; 120, subscript; 120, 121; 120, 122; 121, identifier:g; 122, string:'name'; 123, identifier:upper; 124, argument_list; 125, if_statement; 125, 126; 125, 129; 125, 152; 126, comparison_operator:==; 126, 127; 126, 128; 127, identifier:key; 128, string:'UN'; 129, block; 129, 130; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 135; 132, subscript; 132, 133; 132, 134; 133, identifier:db_refs; 134, identifier:key; 135, list_comprehension; 135, 136; 135, 149; 136, tuple; 136, 137; 136, 146; 137, call; 137, 138; 137, 143; 138, attribute; 138, 139; 138, 142; 139, subscript; 139, 140; 139, 141; 140, identifier:s; 141, integer:0; 142, identifier:replace; 143, argument_list; 143, 144; 143, 145; 144, string:' '; 145, string:'_'; 146, subscript; 146, 147; 146, 148; 147, identifier:s; 148, integer:1; 149, for_in_clause; 149, 150; 149, 151; 150, identifier:s; 151, identifier:entries; 152, else_clause; 152, 153; 153, block; 153, 154; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 159; 156, subscript; 156, 157; 156, 158; 157, identifier:db_refs; 158, identifier:key; 159, identifier:entries; 160, return_statement; 160, 161; 161, identifier:db_refs | def get_groundings(entity):
def get_grounding_entries(grounding):
if not grounding:
return None
entries = []
values = grounding.get('values', [])
if values:
for entry in values:
ont_concept = entry.get('ontologyConcept')
value = entry.get('value')
if ont_concept is None or value is None:
continue
entries.append((ont_concept, value))
return entries
db_refs = {'TEXT': entity['text']}
groundings = entity.get('groundings')
if not groundings:
return db_refs
for g in groundings:
entries = get_grounding_entries(g)
if entries:
key = g['name'].upper()
if key == 'UN':
db_refs[key] = [(s[0].replace(' ', '_'), s[1])
for s in entries]
else:
db_refs[key] = entries
return db_refs |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:make_model; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:grounding_ontology; 7, string:'UN'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:grounding_threshold; 10, None; 11, block; 11, 12; 11, 23; 11, 29; 11, 45; 11, 55; 11, 312; 12, if_statement; 12, 13; 12, 16; 13, comparison_operator:is; 13, 14; 13, 15; 14, identifier:grounding_threshold; 15, None; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:grounding_threshold; 22, identifier:grounding_threshold; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:grounding_ontology; 28, identifier:grounding_ontology; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:statements; 32, list_comprehension; 32, 33; 32, 34; 32, 39; 33, identifier:stmt; 34, for_in_clause; 34, 35; 34, 36; 35, identifier:stmt; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:statements; 39, if_clause; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:isinstance; 42, argument_list; 42, 43; 42, 44; 43, identifier:stmt; 44, identifier:Influence; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:CAG; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:nx; 53, identifier:MultiDiGraph; 54, argument_list; 55, for_statement; 55, 56; 55, 57; 55, 58; 56, identifier:s; 57, identifier:statements; 58, block; 58, 59; 58, 82; 58, 134; 58, 141; 58, 194; 58, 198; 58, 236; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:has_both_polarity; 62, parenthesized_expression; 62, 63; 63, boolean_operator:and; 63, 64; 63, 73; 64, comparison_operator:is; 64, 65; 64, 72; 65, subscript; 65, 66; 65, 71; 66, attribute; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:s; 69, identifier:subj; 70, identifier:delta; 71, string:'polarity'; 72, None; 73, comparison_operator:is; 73, 74; 73, 81; 74, subscript; 74, 75; 74, 80; 75, attribute; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:s; 78, identifier:obj; 79, identifier:delta; 80, string:'polarity'; 81, None; 82, for_statement; 82, 83; 82, 86; 82, 111; 83, pattern_list; 83, 84; 83, 85; 84, identifier:node; 85, identifier:delta; 86, call; 86, 87; 86, 88; 87, identifier:zip; 88, argument_list; 88, 89; 88, 100; 89, tuple; 89, 90; 89, 95; 90, attribute; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:s; 93, identifier:subj; 94, identifier:concept; 95, attribute; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:s; 98, identifier:obj; 99, identifier:concept; 100, tuple; 100, 101; 100, 106; 101, attribute; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:s; 104, identifier:subj; 105, identifier:delta; 106, attribute; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:s; 109, identifier:obj; 110, identifier:delta; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 119; 114, attribute; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:self; 117, identifier:CAG; 118, identifier:add_node; 119, argument_list; 119, 120; 119, 126; 119, 129; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:self; 123, identifier:_node_name; 124, argument_list; 124, 125; 125, identifier:node; 126, keyword_argument; 126, 127; 126, 128; 127, identifier:simulable; 128, identifier:has_both_polarity; 129, keyword_argument; 129, 130; 129, 131; 130, identifier:mods; 131, subscript; 131, 132; 131, 133; 132, identifier:delta; 133, string:'adjectives'; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:linestyle; 137, conditional_expression:if; 137, 138; 137, 139; 137, 140; 138, string:'solid'; 139, identifier:has_both_polarity; 140, string:'dotted'; 141, if_statement; 141, 142; 141, 143; 141, 184; 142, identifier:has_both_polarity; 143, block; 143, 144; 143, 163; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:same_polarity; 147, parenthesized_expression; 147, 148; 148, comparison_operator:==; 148, 149; 148, 156; 149, subscript; 149, 150; 149, 155; 150, attribute; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:s; 153, identifier:subj; 154, identifier:delta; 155, string:'polarity'; 156, subscript; 156, 157; 156, 162; 157, attribute; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:s; 160, identifier:obj; 161, identifier:delta; 162, string:'polarity'; 163, if_statement; 163, 164; 163, 165; 163, 174; 164, identifier:same_polarity; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 171; 168, pattern_list; 168, 169; 168, 170; 169, identifier:target_arrow_shape; 170, identifier:linecolor; 171, tuple; 171, 172; 171, 173; 172, string:'circle'; 173, string:'green'; 174, else_clause; 174, 175; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 181; 178, pattern_list; 178, 179; 178, 180; 179, identifier:target_arrow_shape; 180, identifier:linecolor; 181, tuple; 181, 182; 181, 183; 182, string:'tee'; 183, string:'maroon'; 184, else_clause; 184, 185; 185, block; 185, 186; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 191; 188, pattern_list; 188, 189; 188, 190; 189, identifier:target_arrow_shape; 190, identifier:linecolor; 191, tuple; 191, 192; 191, 193; 192, string:'triangle'; 193, string:'maroon'; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:provenance; 197, list:[]; 198, if_statement; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:s; 201, identifier:evidence; 202, block; 202, 203; 202, 219; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:provenance; 206, call; 206, 207; 206, 216; 207, attribute; 207, 208; 207, 215; 208, attribute; 208, 209; 208, 214; 209, subscript; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:s; 212, identifier:evidence; 213, integer:0; 214, identifier:annotations; 215, identifier:get; 216, argument_list; 216, 217; 216, 218; 217, string:'provenance'; 218, list:[]; 219, if_statement; 219, 220; 219, 221; 220, identifier:provenance; 221, block; 221, 222; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 229; 224, subscript; 224, 225; 224, 228; 225, subscript; 225, 226; 225, 227; 226, identifier:provenance; 227, integer:0; 228, string:'text'; 229, attribute; 229, 230; 229, 235; 230, subscript; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:s; 233, identifier:evidence; 234, integer:0; 235, identifier:text; 236, expression_statement; 236, 237; 237, call; 237, 238; 237, 243; 238, attribute; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:self; 241, identifier:CAG; 242, identifier:add_edge; 243, argument_list; 243, 244; 243, 254; 243, 264; 243, 273; 243, 282; 243, 291; 243, 300; 243, 303; 243, 306; 243, 309; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:self; 247, identifier:_node_name; 248, argument_list; 248, 249; 249, attribute; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:s; 252, identifier:subj; 253, identifier:concept; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:self; 257, identifier:_node_name; 258, argument_list; 258, 259; 259, attribute; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:s; 262, identifier:obj; 263, identifier:concept; 264, keyword_argument; 264, 265; 264, 266; 265, identifier:subj_polarity; 266, subscript; 266, 267; 266, 272; 267, attribute; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, identifier:s; 270, identifier:subj; 271, identifier:delta; 272, string:'polarity'; 273, keyword_argument; 273, 274; 273, 275; 274, identifier:subj_adjectives; 275, subscript; 275, 276; 275, 281; 276, attribute; 276, 277; 276, 280; 277, attribute; 277, 278; 277, 279; 278, identifier:s; 279, identifier:subj; 280, identifier:delta; 281, string:'adjectives'; 282, keyword_argument; 282, 283; 282, 284; 283, identifier:obj_polarity; 284, subscript; 284, 285; 284, 290; 285, attribute; 285, 286; 285, 289; 286, attribute; 286, 287; 286, 288; 287, identifier:s; 288, identifier:obj; 289, identifier:delta; 290, string:'polarity'; 291, keyword_argument; 291, 292; 291, 293; 292, identifier:obj_adjectives; 293, subscript; 293, 294; 293, 299; 294, attribute; 294, 295; 294, 298; 295, attribute; 295, 296; 295, 297; 296, identifier:s; 297, identifier:obj; 298, identifier:delta; 299, string:'adjectives'; 300, keyword_argument; 300, 301; 300, 302; 301, identifier:linestyle; 302, identifier:linestyle; 303, keyword_argument; 303, 304; 303, 305; 304, identifier:linecolor; 305, identifier:linecolor; 306, keyword_argument; 306, 307; 306, 308; 307, identifier:targetArrowShape; 308, identifier:target_arrow_shape; 309, keyword_argument; 309, 310; 309, 311; 310, identifier:provenance; 311, identifier:provenance; 312, return_statement; 312, 313; 313, attribute; 313, 314; 313, 315; 314, identifier:self; 315, identifier:CAG | def make_model(self, grounding_ontology='UN', grounding_threshold=None):
if grounding_threshold is not None:
self.grounding_threshold = grounding_threshold
self.grounding_ontology = grounding_ontology
statements = [stmt for stmt in self.statements if
isinstance(stmt, Influence)]
self.CAG = nx.MultiDiGraph()
for s in statements:
has_both_polarity = (s.subj.delta['polarity'] is not None and
s.obj.delta['polarity'] is not None)
for node, delta in zip((s.subj.concept, s.obj.concept),
(s.subj.delta, s.obj.delta)):
self.CAG.add_node(self._node_name(node),
simulable=has_both_polarity,
mods=delta['adjectives'])
linestyle = 'solid' if has_both_polarity else 'dotted'
if has_both_polarity:
same_polarity = (s.subj.delta['polarity'] ==
s.obj.delta['polarity'])
if same_polarity:
target_arrow_shape, linecolor = ('circle', 'green')
else:
target_arrow_shape, linecolor = ('tee', 'maroon')
else:
target_arrow_shape, linecolor = ('triangle', 'maroon')
provenance = []
if s.evidence:
provenance = s.evidence[0].annotations.get('provenance', [])
if provenance:
provenance[0]['text'] = s.evidence[0].text
self.CAG.add_edge(
self._node_name(s.subj.concept),
self._node_name(s.obj.concept),
subj_polarity=s.subj.delta['polarity'],
subj_adjectives=s.subj.delta['adjectives'],
obj_polarity=s.obj.delta['polarity'],
obj_adjectives=s.obj.delta['adjectives'],
linestyle=linestyle,
linecolor=linecolor,
targetArrowShape=target_arrow_shape,
provenance=provenance,
)
return self.CAG |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:process_directory_statements_sorted_by_pmid; 3, parameters; 3, 4; 4, identifier:directory_name; 5, block; 5, 6; 5, 13; 5, 23; 5, 46; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:s_dict; 9, call; 9, 10; 9, 11; 10, identifier:defaultdict; 11, argument_list; 11, 12; 12, identifier:list; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:mp; 16, call; 16, 17; 16, 18; 17, identifier:process_directory; 18, argument_list; 18, 19; 18, 20; 19, identifier:directory_name; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:lazy; 22, True; 23, for_statement; 23, 24; 23, 25; 23, 30; 24, identifier:statement; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:mp; 28, identifier:iter_statements; 29, argument_list; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 44; 33, attribute; 33, 34; 33, 43; 34, subscript; 34, 35; 34, 36; 35, identifier:s_dict; 36, attribute; 36, 37; 36, 42; 37, subscript; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:statement; 40, identifier:evidence; 41, integer:0; 42, identifier:pmid; 43, identifier:append; 44, argument_list; 44, 45; 45, identifier:statement; 46, return_statement; 46, 47; 47, identifier:s_dict | def process_directory_statements_sorted_by_pmid(directory_name):
s_dict = defaultdict(list)
mp = process_directory(directory_name, lazy=True)
for statement in mp.iter_statements():
s_dict[statement.evidence[0].pmid].append(statement)
return s_dict |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:process_file_sorted_by_pmid; 3, parameters; 3, 4; 4, identifier:file_name; 5, block; 5, 6; 5, 13; 5, 23; 5, 46; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:s_dict; 9, call; 9, 10; 9, 11; 10, identifier:defaultdict; 11, argument_list; 11, 12; 12, identifier:list; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:mp; 16, call; 16, 17; 16, 18; 17, identifier:process_file; 18, argument_list; 18, 19; 18, 20; 19, identifier:file_name; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:lazy; 22, True; 23, for_statement; 23, 24; 23, 25; 23, 30; 24, identifier:statement; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:mp; 28, identifier:iter_statements; 29, argument_list; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 44; 33, attribute; 33, 34; 33, 43; 34, subscript; 34, 35; 34, 36; 35, identifier:s_dict; 36, attribute; 36, 37; 36, 42; 37, subscript; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:statement; 40, identifier:evidence; 41, integer:0; 42, identifier:pmid; 43, identifier:append; 44, argument_list; 44, 45; 45, identifier:statement; 46, return_statement; 46, 47; 47, identifier:s_dict | def process_file_sorted_by_pmid(file_name):
s_dict = defaultdict(list)
mp = process_file(file_name, lazy=True)
for statement in mp.iter_statements():
s_dict[statement.evidence[0].pmid].append(statement)
return s_dict |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:extract_context; 3, parameters; 3, 4; 3, 5; 4, identifier:annotations; 5, identifier:annot_manager; 6, block; 6, 7; 6, 71; 6, 77; 6, 85; 6, 115; 6, 139; 6, 217; 6, 225; 7, function_definition; 7, 8; 7, 9; 7, 12; 8, function_name:get_annot; 9, parameters; 9, 10; 9, 11; 10, identifier:annotations; 11, identifier:key; 12, block; 12, 13; 12, 23; 12, 69; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:val; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:annotations; 19, identifier:pop; 20, argument_list; 20, 21; 20, 22; 21, identifier:key; 22, None; 23, if_statement; 23, 24; 23, 25; 24, identifier:val; 25, block; 25, 26; 25, 42; 25, 65; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:val_list; 29, list_comprehension; 29, 30; 29, 31; 29, 40; 30, identifier:v; 31, for_in_clause; 31, 32; 31, 35; 32, pattern_list; 32, 33; 32, 34; 33, identifier:v; 34, identifier:tf; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:val; 38, identifier:items; 39, argument_list; 40, if_clause; 40, 41; 41, identifier:tf; 42, if_statement; 42, 43; 42, 49; 42, 59; 43, comparison_operator:>; 43, 44; 43, 48; 44, call; 44, 45; 44, 46; 45, identifier:len; 46, argument_list; 46, 47; 47, identifier:val_list; 48, integer:1; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:logger; 54, identifier:warning; 55, argument_list; 55, 56; 56, binary_operator:%; 56, 57; 56, 58; 57, string:'More than one "%s" in annotations'; 58, identifier:key; 59, elif_clause; 59, 60; 59, 62; 60, not_operator; 60, 61; 61, identifier:val_list; 62, block; 62, 63; 63, return_statement; 63, 64; 64, None; 65, return_statement; 65, 66; 66, subscript; 66, 67; 66, 68; 67, identifier:val_list; 68, integer:0; 69, return_statement; 69, 70; 70, None; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:bc; 74, call; 74, 75; 74, 76; 75, identifier:BioContext; 76, argument_list; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:species; 80, call; 80, 81; 80, 82; 81, identifier:get_annot; 82, argument_list; 82, 83; 82, 84; 83, identifier:annotations; 84, string:'Species'; 85, if_statement; 85, 86; 85, 87; 86, identifier:species; 87, block; 87, 88; 87, 98; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:name; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:annot_manager; 94, identifier:get_mapping; 95, argument_list; 95, 96; 95, 97; 96, string:'Species'; 97, identifier:species; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:bc; 102, identifier:species; 103, call; 103, 104; 103, 105; 104, identifier:RefContext; 105, argument_list; 105, 106; 105, 109; 106, keyword_argument; 106, 107; 106, 108; 107, identifier:name; 108, identifier:name; 109, keyword_argument; 109, 110; 109, 111; 110, identifier:db_refs; 111, dictionary; 111, 112; 112, pair; 112, 113; 112, 114; 113, string:'TAXONOMY'; 114, identifier:species; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:mappings; 118, tuple; 118, 119; 118, 123; 118, 127; 118, 131; 118, 135; 119, tuple; 119, 120; 119, 121; 119, 122; 120, string:'CellLine'; 121, string:'cell_line'; 122, None; 123, tuple; 123, 124; 123, 125; 123, 126; 124, string:'Disease'; 125, string:'disease'; 126, None; 127, tuple; 127, 128; 127, 129; 127, 130; 128, string:'Anatomy'; 129, string:'organ'; 130, None; 131, tuple; 131, 132; 131, 133; 131, 134; 132, string:'Cell'; 133, string:'cell_type'; 134, None; 135, tuple; 135, 136; 135, 137; 135, 138; 136, string:'CellStructure'; 137, string:'location'; 138, string:'MESH'; 139, for_statement; 139, 140; 139, 144; 139, 145; 140, pattern_list; 140, 141; 140, 142; 140, 143; 141, identifier:bel_name; 142, identifier:indra_name; 143, identifier:ns; 144, identifier:mappings; 145, block; 145, 146; 145, 154; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:ann; 149, call; 149, 150; 149, 151; 150, identifier:get_annot; 151, argument_list; 151, 152; 151, 153; 152, identifier:annotations; 153, identifier:bel_name; 154, if_statement; 154, 155; 154, 156; 155, identifier:ann; 156, block; 156, 157; 156, 167; 156, 173; 156, 199; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:ref; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:annot_manager; 163, identifier:get_mapping; 164, argument_list; 164, 165; 164, 166; 165, identifier:bel_name; 166, identifier:ann; 167, if_statement; 167, 168; 167, 171; 168, comparison_operator:is; 168, 169; 168, 170; 169, identifier:ref; 170, None; 171, block; 171, 172; 172, continue_statement; 173, if_statement; 173, 174; 173, 176; 173, 189; 174, not_operator; 174, 175; 175, identifier:ns; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 182; 179, pattern_list; 179, 180; 179, 181; 180, identifier:db_ns; 181, identifier:db_id; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:ref; 185, identifier:split; 186, argument_list; 186, 187; 186, 188; 187, string:'_'; 188, integer:1; 189, else_clause; 189, 190; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 196; 193, pattern_list; 193, 194; 193, 195; 194, identifier:db_ns; 195, identifier:db_id; 196, expression_list; 196, 197; 196, 198; 197, identifier:ns; 198, identifier:ref; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 202; 201, identifier:setattr; 202, argument_list; 202, 203; 202, 204; 202, 205; 203, identifier:bc; 204, identifier:indra_name; 205, call; 205, 206; 205, 207; 206, identifier:RefContext; 207, argument_list; 207, 208; 207, 211; 208, keyword_argument; 208, 209; 208, 210; 209, identifier:name; 210, identifier:ann; 211, keyword_argument; 211, 212; 211, 213; 212, identifier:db_refs; 213, dictionary; 213, 214; 214, pair; 214, 215; 214, 216; 215, identifier:db_ns; 216, identifier:db_id; 217, if_statement; 217, 218; 217, 220; 218, not_operator; 218, 219; 219, identifier:bc; 220, block; 220, 221; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:bc; 224, None; 225, return_statement; 225, 226; 226, identifier:bc | def extract_context(annotations, annot_manager):
def get_annot(annotations, key):
val = annotations.pop(key, None)
if val:
val_list = [v for v, tf in val.items() if tf]
if len(val_list) > 1:
logger.warning('More than one "%s" in annotations' % key)
elif not val_list:
return None
return val_list[0]
return None
bc = BioContext()
species = get_annot(annotations, 'Species')
if species:
name = annot_manager.get_mapping('Species', species)
bc.species = RefContext(name=name, db_refs={'TAXONOMY': species})
mappings = (('CellLine', 'cell_line', None),
('Disease', 'disease', None),
('Anatomy', 'organ', None),
('Cell', 'cell_type', None),
('CellStructure', 'location', 'MESH'))
for bel_name, indra_name, ns in mappings:
ann = get_annot(annotations, bel_name)
if ann:
ref = annot_manager.get_mapping(bel_name, ann)
if ref is None:
continue
if not ns:
db_ns, db_id = ref.split('_', 1)
else:
db_ns, db_id = ns, ref
setattr(bc, indra_name,
RefContext(name=ann, db_refs={db_ns: db_id}))
if not bc:
bc = None
return bc |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_format_evidence_text; 3, parameters; 3, 4; 4, identifier:stmt; 5, block; 5, 6; 5, 80; 5, 84; 5, 308; 6, function_definition; 6, 7; 6, 8; 6, 10; 7, function_name:get_role; 8, parameters; 8, 9; 9, identifier:ag_ix; 10, block; 10, 11; 11, if_statement; 11, 12; 11, 44; 11, 47; 12, boolean_operator:or; 12, 13; 12, 38; 12, 39; 13, boolean_operator:or; 13, 14; 13, 33; 14, boolean_operator:or; 14, 15; 14, 27; 14, 28; 15, boolean_operator:or; 15, 16; 15, 21; 15, 22; 16, call; 16, 17; 16, 18; 17, identifier:isinstance; 18, argument_list; 18, 19; 18, 20; 19, identifier:stmt; 20, identifier:Complex; 21, line_continuation:\; 22, call; 22, 23; 22, 24; 23, identifier:isinstance; 24, argument_list; 24, 25; 24, 26; 25, identifier:stmt; 26, identifier:SelfModification; 27, line_continuation:\; 28, call; 28, 29; 28, 30; 29, identifier:isinstance; 30, argument_list; 30, 31; 30, 32; 31, identifier:stmt; 32, identifier:ActiveForm; 33, call; 33, 34; 33, 35; 34, identifier:isinstance; 35, argument_list; 35, 36; 35, 37; 36, identifier:stmt; 37, identifier:Conversion; 38, line_continuation:\; 39, call; 39, 40; 39, 41; 40, identifier:isinstance; 41, argument_list; 41, 42; 41, 43; 42, identifier:stmt; 43, identifier:Translocation; 44, block; 44, 45; 45, return_statement; 45, 46; 46, string:'other'; 47, else_clause; 47, 48; 48, block; 48, 49; 48, 73; 49, assert_statement; 49, 50; 49, 60; 50, comparison_operator:==; 50, 51; 50, 59; 51, call; 51, 52; 51, 53; 52, identifier:len; 53, argument_list; 53, 54; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:stmt; 57, identifier:agent_list; 58, argument_list; 59, integer:2; 60, tuple; 60, 61; 60, 69; 61, call; 61, 62; 61, 63; 62, identifier:len; 63, argument_list; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:stmt; 67, identifier:agent_list; 68, argument_list; 69, call; 69, 70; 69, 71; 70, identifier:type; 71, argument_list; 71, 72; 72, identifier:stmt; 73, return_statement; 73, 74; 74, conditional_expression:if; 74, 75; 74, 76; 74, 79; 75, string:'subject'; 76, comparison_operator:==; 76, 77; 76, 78; 77, identifier:ag_ix; 78, integer:0; 79, string:'object'; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:ev_list; 83, list:[]; 84, for_statement; 84, 85; 84, 88; 84, 94; 85, pattern_list; 85, 86; 85, 87; 86, identifier:ix; 87, identifier:ev; 88, call; 88, 89; 88, 90; 89, identifier:enumerate; 90, argument_list; 90, 91; 91, attribute; 91, 92; 91, 93; 92, identifier:stmt; 93, identifier:evidence; 94, block; 94, 95; 94, 137; 94, 280; 95, if_statement; 95, 96; 95, 114; 95, 129; 96, boolean_operator:and; 96, 97; 96, 108; 96, 109; 97, boolean_operator:and; 97, 98; 97, 103; 98, comparison_operator:==; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:ev; 101, identifier:source_api; 102, string:'biopax'; 103, comparison_operator:in; 103, 104; 103, 105; 104, string:'source_sub_id'; 105, attribute; 105, 106; 105, 107; 106, identifier:ev; 107, identifier:annotations; 108, line_continuation:\; 109, subscript; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:ev; 112, identifier:annotations; 113, string:'source_sub_id'; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:source_api; 118, binary_operator:%; 118, 119; 118, 120; 119, string:'%s:%s'; 120, tuple; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:ev; 123, identifier:source_api; 124, subscript; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:ev; 127, identifier:annotations; 128, string:'source_sub_id'; 129, else_clause; 129, 130; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:source_api; 134, attribute; 134, 135; 134, 136; 135, identifier:ev; 136, identifier:source_api; 137, if_statement; 137, 138; 137, 143; 137, 148; 138, comparison_operator:is; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:ev; 141, identifier:text; 142, None; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:format_text; 147, None; 148, else_clause; 148, 149; 149, block; 149, 150; 149, 154; 149, 270; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:indices; 153, list:[]; 154, for_statement; 154, 155; 154, 158; 154, 166; 155, pattern_list; 155, 156; 155, 157; 156, identifier:ix; 157, identifier:ag; 158, call; 158, 159; 158, 160; 159, identifier:enumerate; 160, argument_list; 160, 161; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:stmt; 164, identifier:agent_list; 165, argument_list; 166, block; 166, 167; 166, 173; 166, 208; 166, 214; 166, 221; 166, 227; 166, 231; 167, if_statement; 167, 168; 167, 171; 168, comparison_operator:is; 168, 169; 168, 170; 169, identifier:ag; 170, None; 171, block; 171, 172; 172, continue_statement; 173, try_statement; 173, 174; 173, 194; 174, block; 174, 175; 174, 187; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:ag_text; 178, subscript; 178, 179; 178, 186; 179, subscript; 179, 180; 179, 185; 180, subscript; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:ev; 183, identifier:annotations; 184, string:'agents'; 185, string:'raw_text'; 186, identifier:ix; 187, if_statement; 187, 188; 187, 191; 188, comparison_operator:is; 188, 189; 188, 190; 189, identifier:ag_text; 190, None; 191, block; 191, 192; 192, raise_statement; 192, 193; 193, identifier:KeyError; 194, except_clause; 194, 195; 194, 196; 195, identifier:KeyError; 196, block; 196, 197; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 200; 199, identifier:ag_text; 200, call; 200, 201; 200, 206; 201, attribute; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:ag; 204, identifier:db_refs; 205, identifier:get; 206, argument_list; 206, 207; 207, string:'TEXT'; 208, if_statement; 208, 209; 208, 212; 209, comparison_operator:is; 209, 210; 209, 211; 210, identifier:ag_text; 211, None; 212, block; 212, 213; 213, continue_statement; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:role; 217, call; 217, 218; 217, 219; 218, identifier:get_role; 219, argument_list; 219, 220; 220, identifier:ix; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:tag_start; 224, binary_operator:%; 224, 225; 224, 226; 225, string:'<span class="badge badge-%s">'; 226, identifier:role; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:tag_close; 230, string:'</span>'; 231, expression_statement; 231, 232; 232, augmented_assignment:+=; 232, 233; 232, 234; 233, identifier:indices; 234, list_comprehension; 234, 235; 234, 254; 235, tuple; 235, 236; 235, 241; 235, 251; 235, 252; 235, 253; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:m; 239, identifier:start; 240, argument_list; 241, binary_operator:+; 241, 242; 241, 247; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:m; 245, identifier:start; 246, argument_list; 247, call; 247, 248; 247, 249; 248, identifier:len; 249, argument_list; 249, 250; 250, identifier:ag_text; 251, identifier:ag_text; 252, identifier:tag_start; 253, identifier:tag_close; 254, for_in_clause; 254, 255; 254, 256; 255, identifier:m; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:re; 259, identifier:finditer; 260, argument_list; 260, 261; 260, 267; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:re; 264, identifier:escape; 265, argument_list; 265, 266; 266, identifier:ag_text; 267, attribute; 267, 268; 267, 269; 268, identifier:ev; 269, identifier:text; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 273; 272, identifier:format_text; 273, call; 273, 274; 273, 275; 274, identifier:tag_text; 275, argument_list; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:ev; 278, identifier:text; 279, identifier:indices; 280, expression_statement; 280, 281; 281, call; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:ev_list; 284, identifier:append; 285, argument_list; 285, 286; 286, dictionary; 286, 287; 286, 290; 286, 295; 286, 300; 286, 303; 287, pair; 287, 288; 287, 289; 288, string:'source_api'; 289, identifier:source_api; 290, pair; 290, 291; 290, 292; 291, string:'pmid'; 292, attribute; 292, 293; 292, 294; 293, identifier:ev; 294, identifier:pmid; 295, pair; 295, 296; 295, 297; 296, string:'text_refs'; 297, attribute; 297, 298; 297, 299; 298, identifier:ev; 299, identifier:text_refs; 300, pair; 300, 301; 300, 302; 301, string:'text'; 302, identifier:format_text; 303, pair; 303, 304; 303, 305; 304, string:'source_hash'; 305, attribute; 305, 306; 305, 307; 306, identifier:ev; 307, identifier:source_hash; 308, return_statement; 308, 309; 309, identifier:ev_list | def _format_evidence_text(stmt):
def get_role(ag_ix):
if isinstance(stmt, Complex) or \
isinstance(stmt, SelfModification) or \
isinstance(stmt, ActiveForm) or isinstance(stmt, Conversion) or\
isinstance(stmt, Translocation):
return 'other'
else:
assert len(stmt.agent_list()) == 2, (len(stmt.agent_list()),
type(stmt))
return 'subject' if ag_ix == 0 else 'object'
ev_list = []
for ix, ev in enumerate(stmt.evidence):
if ev.source_api == 'biopax' and \
'source_sub_id' in ev.annotations and \
ev.annotations['source_sub_id']:
source_api = '%s:%s' % (ev.source_api,
ev.annotations['source_sub_id'])
else:
source_api = ev.source_api
if ev.text is None:
format_text = None
else:
indices = []
for ix, ag in enumerate(stmt.agent_list()):
if ag is None:
continue
try:
ag_text = ev.annotations['agents']['raw_text'][ix]
if ag_text is None:
raise KeyError
except KeyError:
ag_text = ag.db_refs.get('TEXT')
if ag_text is None:
continue
role = get_role(ix)
tag_start = '<span class="badge badge-%s">' % role
tag_close = '</span>'
indices += [(m.start(), m.start() + len(ag_text),
ag_text, tag_start, tag_close)
for m in re.finditer(re.escape(ag_text),
ev.text)]
format_text = tag_text(ev.text, indices)
ev_list.append({'source_api': source_api,
'pmid': ev.pmid,
'text_refs': ev.text_refs,
'text': format_text,
'source_hash': ev.source_hash })
return ev_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:get_full_text; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:paper_id; 5, identifier:idtype; 6, default_parameter; 6, 7; 6, 8; 7, identifier:preferred_content_type; 8, string:'text/xml'; 9, block; 9, 10; 9, 26; 9, 34; 9, 43; 9, 52; 9, 61; 9, 80; 9, 91; 9, 215; 10, if_statement; 10, 11; 10, 18; 11, comparison_operator:not; 11, 12; 11, 13; 11, 14; 12, identifier:preferred_content_type; 13, line_continuation:\; 14, tuple; 14, 15; 14, 16; 14, 17; 15, string:'text/xml'; 16, string:'text/plain'; 17, string:'application/pdf'; 18, block; 18, 19; 19, raise_statement; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:ValueError; 22, argument_list; 22, 23; 23, concatenated_string; 23, 24; 23, 25; 24, string:"preferred_content_type must be one of 'text/xml', "; 25, string:"'text/plain', or 'application/pdf'."; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:ids; 29, call; 29, 30; 29, 31; 30, identifier:id_lookup; 31, argument_list; 31, 32; 31, 33; 32, identifier:paper_id; 33, identifier:idtype; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:pmcid; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:ids; 40, identifier:get; 41, argument_list; 41, 42; 42, string:'pmcid'; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:pmid; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:ids; 49, identifier:get; 50, argument_list; 50, 51; 51, string:'pmid'; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:doi; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:ids; 58, identifier:get; 59, argument_list; 59, 60; 60, string:'doi'; 61, if_statement; 61, 62; 61, 63; 62, identifier:pmcid; 63, block; 63, 64; 63, 73; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:nxml; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:pmc_client; 70, identifier:get_xml; 71, argument_list; 71, 72; 72, identifier:pmcid; 73, if_statement; 73, 74; 73, 75; 74, identifier:nxml; 75, block; 75, 76; 76, return_statement; 76, 77; 77, expression_list; 77, 78; 77, 79; 78, identifier:nxml; 79, string:'pmc_oa_xml'; 80, if_statement; 80, 81; 80, 86; 81, boolean_operator:and; 81, 82; 81, 84; 82, not_operator; 82, 83; 83, identifier:doi; 84, not_operator; 84, 85; 85, identifier:pmid; 86, block; 86, 87; 87, return_statement; 87, 88; 88, tuple; 88, 89; 88, 90; 89, None; 90, None; 91, if_statement; 91, 92; 91, 93; 91, 189; 92, identifier:doi; 93, block; 93, 94; 93, 103; 93, 156; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:publisher; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:crossref_client; 100, identifier:get_publisher; 101, argument_list; 101, 102; 102, identifier:doi; 103, if_statement; 103, 104; 103, 107; 104, comparison_operator:==; 104, 105; 104, 106; 105, identifier:publisher; 106, string:'Elsevier BV'; 107, block; 107, 108; 107, 117; 107, 147; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:logger; 112, identifier:info; 113, argument_list; 113, 114; 114, binary_operator:%; 114, 115; 114, 116; 115, string:'Elsevier: %s'; 116, identifier:pmid; 117, try_statement; 117, 118; 117, 128; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:article_xml; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:elsevier_client; 125, identifier:download_article; 126, argument_list; 126, 127; 127, identifier:doi; 128, except_clause; 128, 129; 128, 133; 129, as_pattern; 129, 130; 129, 131; 130, identifier:Exception; 131, as_pattern_target; 131, 132; 132, identifier:e; 133, block; 133, 134; 133, 143; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:logger; 138, identifier:error; 139, argument_list; 139, 140; 140, binary_operator:%; 140, 141; 140, 142; 141, string:"Error downloading Elsevier article: %s"; 142, identifier:e; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:article_xml; 146, None; 147, if_statement; 147, 148; 147, 151; 148, comparison_operator:is; 148, 149; 148, 150; 149, identifier:article_xml; 150, None; 151, block; 151, 152; 152, return_statement; 152, 153; 153, tuple; 153, 154; 153, 155; 154, identifier:article_xml; 155, string:'elsevier_xml'; 156, if_statement; 156, 157; 156, 158; 156, 183; 157, identifier:pmid; 158, block; 158, 159; 158, 168; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:abstract; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:pubmed_client; 165, identifier:get_abstract; 166, argument_list; 166, 167; 167, identifier:pmid; 168, if_statement; 168, 169; 168, 172; 168, 177; 169, comparison_operator:is; 169, 170; 169, 171; 170, identifier:abstract; 171, None; 172, block; 172, 173; 173, return_statement; 173, 174; 174, tuple; 174, 175; 174, 176; 175, None; 176, None; 177, else_clause; 177, 178; 178, block; 178, 179; 179, return_statement; 179, 180; 180, expression_list; 180, 181; 180, 182; 181, identifier:abstract; 182, string:'abstract'; 183, else_clause; 183, 184; 184, block; 184, 185; 185, return_statement; 185, 186; 186, tuple; 186, 187; 186, 188; 187, None; 188, None; 189, else_clause; 189, 190; 190, block; 190, 191; 190, 200; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:abstract; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:pubmed_client; 197, identifier:get_abstract; 198, argument_list; 198, 199; 199, identifier:pmid; 200, if_statement; 200, 201; 200, 204; 200, 209; 201, comparison_operator:is; 201, 202; 201, 203; 202, identifier:abstract; 203, None; 204, block; 204, 205; 205, return_statement; 205, 206; 206, tuple; 206, 207; 206, 208; 207, None; 208, None; 209, else_clause; 209, 210; 210, block; 210, 211; 211, return_statement; 211, 212; 212, expression_list; 212, 213; 212, 214; 213, identifier:abstract; 214, string:'abstract'; 215, assert_statement; 215, 216; 216, False | def get_full_text(paper_id, idtype, preferred_content_type='text/xml'):
if preferred_content_type not in \
('text/xml', 'text/plain', 'application/pdf'):
raise ValueError("preferred_content_type must be one of 'text/xml', "
"'text/plain', or 'application/pdf'.")
ids = id_lookup(paper_id, idtype)
pmcid = ids.get('pmcid')
pmid = ids.get('pmid')
doi = ids.get('doi')
if pmcid:
nxml = pmc_client.get_xml(pmcid)
if nxml:
return nxml, 'pmc_oa_xml'
if not doi and not pmid:
return (None, None)
if doi:
publisher = crossref_client.get_publisher(doi)
if publisher == 'Elsevier BV':
logger.info('Elsevier: %s' % pmid)
try:
article_xml = elsevier_client.download_article(doi)
except Exception as e:
logger.error("Error downloading Elsevier article: %s" % e)
article_xml = None
if article_xml is not None:
return (article_xml, 'elsevier_xml')
if pmid:
abstract = pubmed_client.get_abstract(pmid)
if abstract is None:
return (None, None)
else:
return abstract, 'abstract'
else:
return (None, None)
else:
abstract = pubmed_client.get_abstract(pmid)
if abstract is None:
return (None, None)
else:
return abstract, 'abstract'
assert False |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:process_text; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:text; 5, default_parameter; 5, 6; 5, 7; 6, identifier:pmid; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:python2_path; 10, None; 11, block; 11, 12; 11, 65; 11, 79; 11, 90; 11, 100; 12, if_statement; 12, 13; 12, 16; 13, comparison_operator:is; 13, 14; 13, 15; 14, identifier:python2_path; 15, None; 16, block; 16, 17; 17, for_statement; 17, 18; 17, 19; 17, 31; 18, identifier:path; 19, call; 19, 20; 19, 27; 20, attribute; 20, 21; 20, 26; 21, subscript; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:os; 24, identifier:environ; 25, string:"PATH"; 26, identifier:split; 27, argument_list; 27, 28; 28, attribute; 28, 29; 28, 30; 29, identifier:os; 30, identifier:pathsep; 31, block; 31, 32; 31, 44; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:proposed_python2_path; 35, call; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:os; 39, identifier:path; 40, identifier:join; 41, argument_list; 41, 42; 41, 43; 42, identifier:path; 43, string:'python2.7'; 44, if_statement; 44, 45; 44, 53; 45, call; 45, 46; 45, 51; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:os; 49, identifier:path; 50, identifier:isfile; 51, argument_list; 51, 52; 52, identifier:proposed_python2_path; 53, block; 53, 54; 53, 58; 53, 64; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:python2_path; 57, identifier:proposed_python2_path; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:print; 61, argument_list; 61, 62; 61, 63; 62, string:'Found python 2 interpreter at'; 63, identifier:python2_path; 64, break_statement; 65, if_statement; 65, 66; 65, 69; 66, comparison_operator:is; 66, 67; 66, 68; 67, identifier:python2_path; 68, None; 69, block; 69, 70; 70, raise_statement; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:Exception; 73, argument_list; 73, 74; 74, binary_operator:+; 74, 75; 74, 78; 75, binary_operator:+; 75, 76; 75, 77; 76, string:'Could not find python2 in the directories '; 77, string:'listed in the PATH environment variable. '; 78, string:'Need python2 to run TEES.'; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 85; 81, pattern_list; 81, 82; 81, 83; 81, 84; 82, identifier:a1_text; 83, identifier:a2_text; 84, identifier:sentence_segmentations; 85, call; 85, 86; 85, 87; 86, identifier:run_on_text; 87, argument_list; 87, 88; 87, 89; 88, identifier:text; 89, identifier:python2_path; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:tp; 93, call; 93, 94; 93, 95; 94, identifier:TEESProcessor; 95, argument_list; 95, 96; 95, 97; 95, 98; 95, 99; 96, identifier:a1_text; 97, identifier:a2_text; 98, identifier:sentence_segmentations; 99, identifier:pmid; 100, return_statement; 100, 101; 101, identifier:tp | def process_text(text, pmid=None, python2_path=None):
if python2_path is None:
for path in os.environ["PATH"].split(os.pathsep):
proposed_python2_path = os.path.join(path, 'python2.7')
if os.path.isfile(proposed_python2_path):
python2_path = proposed_python2_path
print('Found python 2 interpreter at', python2_path)
break
if python2_path is None:
raise Exception('Could not find python2 in the directories ' +
'listed in the PATH environment variable. ' +
'Need python2 to run TEES.')
a1_text, a2_text, sentence_segmentations = run_on_text(text,
python2_path)
tp = TEESProcessor(a1_text, a2_text, sentence_segmentations, pmid)
return tp |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:run_on_text; 3, parameters; 3, 4; 3, 5; 4, identifier:text; 5, identifier:python2_path; 6, block; 6, 7; 6, 14; 6, 135; 6, 151; 6, 155; 6, 166; 6, 181; 6, 368; 6, 375; 6, 382; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:tees_path; 10, call; 10, 11; 10, 12; 11, identifier:get_config; 12, argument_list; 12, 13; 13, string:'TEES_PATH'; 14, if_statement; 14, 15; 14, 18; 15, comparison_operator:is; 15, 16; 15, 17; 16, identifier:tees_path; 17, None; 18, block; 18, 19; 19, for_statement; 19, 20; 19, 21; 19, 22; 20, identifier:cpath; 21, identifier:tees_candidate_paths; 22, block; 22, 23; 22, 34; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:cpath; 26, call; 26, 27; 26, 32; 27, attribute; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:os; 30, identifier:path; 31, identifier:expanduser; 32, argument_list; 32, 33; 33, identifier:cpath; 34, if_statement; 34, 35; 34, 43; 35, call; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:os; 39, identifier:path; 40, identifier:isdir; 41, argument_list; 41, 42; 42, identifier:cpath; 43, block; 43, 44; 43, 48; 43, 81; 43, 85; 43, 118; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:has_expected_files; 47, True; 48, for_statement; 48, 49; 48, 50; 48, 51; 49, identifier:f; 50, identifier:tees_installation_files; 51, block; 51, 52; 51, 64; 51, 75; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:fpath; 55, call; 55, 56; 55, 61; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:os; 59, identifier:path; 60, identifier:join; 61, argument_list; 61, 62; 61, 63; 62, identifier:cpath; 63, identifier:f; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:present; 67, call; 67, 68; 67, 73; 68, attribute; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:os; 71, identifier:path; 72, identifier:isfile; 73, argument_list; 73, 74; 74, identifier:fpath; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:has_expected_files; 78, boolean_operator:and; 78, 79; 78, 80; 79, identifier:has_expected_files; 80, identifier:present; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:has_expected_dirs; 84, True; 85, for_statement; 85, 86; 85, 87; 85, 88; 86, identifier:d; 87, identifier:tees_installation_dirs; 88, block; 88, 89; 88, 101; 88, 112; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:dpath; 92, call; 92, 93; 92, 98; 93, attribute; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:os; 96, identifier:path; 97, identifier:join; 98, argument_list; 98, 99; 98, 100; 99, identifier:cpath; 100, identifier:d; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:present; 104, call; 104, 105; 104, 110; 105, attribute; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:os; 108, identifier:path; 109, identifier:isdir; 110, argument_list; 110, 111; 111, identifier:dpath; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:has_expected_dirs; 115, boolean_operator:and; 115, 116; 115, 117; 116, identifier:has_expected_dirs; 117, identifier:present; 118, if_statement; 118, 119; 118, 122; 119, boolean_operator:and; 119, 120; 119, 121; 120, identifier:has_expected_files; 121, identifier:has_expected_dirs; 122, block; 122, 123; 122, 127; 122, 134; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:tees_path; 126, identifier:cpath; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 130; 129, identifier:print; 130, argument_list; 130, 131; 131, binary_operator:+; 131, 132; 131, 133; 132, string:'Found TEES installation at '; 133, identifier:cpath; 134, break_statement; 135, if_statement; 135, 136; 135, 145; 136, not_operator; 136, 137; 137, call; 137, 138; 137, 143; 138, attribute; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:os; 141, identifier:path; 142, identifier:isdir; 143, argument_list; 143, 144; 144, identifier:tees_path; 145, block; 145, 146; 146, raise_statement; 146, 147; 147, call; 147, 148; 147, 149; 148, identifier:Exception; 149, argument_list; 149, 150; 150, string:'Provided TEES directory does not exist.'; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:classify_path; 154, string:'classify.py'; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:tmp_dir; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:tempfile; 161, identifier:mkdtemp; 162, argument_list; 162, 163; 163, keyword_argument; 163, 164; 163, 165; 164, identifier:suffix; 165, string:'indra_tees_processor'; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:pwd; 169, call; 169, 170; 169, 175; 170, attribute; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:os; 173, identifier:path; 174, identifier:abspath; 175, argument_list; 175, 176; 176, call; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:os; 179, identifier:getcwd; 180, argument_list; 181, try_statement; 181, 182; 181, 353; 182, block; 182, 183; 182, 195; 182, 223; 182, 235; 182, 247; 182, 259; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:text_path; 186, call; 186, 187; 186, 192; 187, attribute; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:os; 190, identifier:path; 191, identifier:join; 192, argument_list; 192, 193; 192, 194; 193, identifier:tmp_dir; 194, string:'text.txt'; 195, with_statement; 195, 196; 195, 215; 196, with_clause; 196, 197; 197, with_item; 197, 198; 198, as_pattern; 198, 199; 198, 212; 198, 213; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:codecs; 202, identifier:open; 203, argument_list; 203, 204; 203, 205; 203, 206; 203, 209; 204, identifier:text_path; 205, string:'w'; 206, keyword_argument; 206, 207; 206, 208; 207, identifier:encoding; 208, string:'latin-1'; 209, keyword_argument; 209, 210; 209, 211; 210, identifier:errors; 211, string:'ignore'; 212, line_continuation:\; 213, as_pattern_target; 213, 214; 214, identifier:f; 215, block; 215, 216; 216, expression_statement; 216, 217; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:f; 220, identifier:write; 221, argument_list; 221, 222; 222, identifier:text; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:output_path; 226, call; 226, 227; 226, 232; 227, attribute; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:os; 230, identifier:path; 231, identifier:join; 232, argument_list; 232, 233; 232, 234; 233, identifier:tmp_dir; 234, string:'output'; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:model_path; 238, call; 238, 239; 238, 244; 239, attribute; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:os; 242, identifier:path; 243, identifier:join; 244, argument_list; 244, 245; 244, 246; 245, identifier:tees_path; 246, string:'tees_data/models/GE11-test/'; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:command; 250, list:[python2_path, classify_path, '-m', model_path,
'-i', text_path,
'-o', output_path]; 250, 251; 250, 252; 250, 253; 250, 254; 250, 255; 250, 256; 250, 257; 250, 258; 251, identifier:python2_path; 252, identifier:classify_path; 253, string:'-m'; 254, identifier:model_path; 255, string:'-i'; 256, identifier:text_path; 257, string:'-o'; 258, identifier:output_path; 259, try_statement; 259, 260; 259, 338; 260, block; 260, 261; 260, 276; 260, 283; 260, 305; 260, 311; 260, 321; 260, 326; 260, 331; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:pwd; 264, call; 264, 265; 264, 270; 265, attribute; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:os; 268, identifier:path; 269, identifier:abspath; 270, argument_list; 270, 271; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:os; 274, identifier:getcwd; 275, argument_list; 276, expression_statement; 276, 277; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:os; 280, identifier:chdir; 281, argument_list; 281, 282; 282, identifier:tees_path; 283, expression_statement; 283, 284; 284, assignment; 284, 285; 284, 286; 285, identifier:p; 286, call; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:subprocess; 289, identifier:Popen; 290, argument_list; 290, 291; 290, 292; 290, 297; 290, 302; 291, identifier:command; 292, keyword_argument; 292, 293; 292, 294; 293, identifier:stdout; 294, attribute; 294, 295; 294, 296; 295, identifier:subprocess; 296, identifier:PIPE; 297, keyword_argument; 297, 298; 297, 299; 298, identifier:stderr; 299, attribute; 299, 300; 299, 301; 300, identifier:subprocess; 301, identifier:PIPE; 302, keyword_argument; 302, 303; 302, 304; 303, identifier:cwd; 304, identifier:tees_path; 305, expression_statement; 305, 306; 306, call; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:p; 309, identifier:wait; 310, argument_list; 311, expression_statement; 311, 312; 312, assignment; 312, 313; 312, 316; 313, tuple_pattern; 313, 314; 313, 315; 314, identifier:so; 315, identifier:se; 316, call; 316, 317; 316, 320; 317, attribute; 317, 318; 317, 319; 318, identifier:p; 319, identifier:communicate; 320, argument_list; 321, expression_statement; 321, 322; 322, call; 322, 323; 322, 324; 323, identifier:print; 324, argument_list; 324, 325; 325, identifier:so; 326, expression_statement; 326, 327; 327, call; 327, 328; 327, 329; 328, identifier:print; 329, argument_list; 329, 330; 330, identifier:se; 331, expression_statement; 331, 332; 332, call; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:os; 335, identifier:chdir; 336, argument_list; 336, 337; 337, identifier:pwd; 338, except_clause; 338, 339; 338, 343; 339, as_pattern; 339, 340; 339, 341; 340, identifier:BaseException; 341, as_pattern_target; 341, 342; 342, identifier:e; 343, block; 343, 344; 343, 351; 344, expression_statement; 344, 345; 345, call; 345, 346; 345, 349; 346, attribute; 346, 347; 346, 348; 347, identifier:os; 348, identifier:chdir; 349, argument_list; 349, 350; 350, identifier:pwd; 351, raise_statement; 351, 352; 352, identifier:e; 353, except_clause; 353, 354; 353, 358; 354, as_pattern; 354, 355; 354, 356; 355, identifier:BaseException; 356, as_pattern_target; 356, 357; 357, identifier:e; 358, block; 358, 359; 358, 366; 359, expression_statement; 359, 360; 360, call; 360, 361; 360, 364; 361, attribute; 361, 362; 361, 363; 362, identifier:shutil; 363, identifier:rmtree; 364, argument_list; 364, 365; 365, identifier:tmp_dir; 366, raise_statement; 366, 367; 367, identifier:e; 368, expression_statement; 368, 369; 369, assignment; 369, 370; 369, 371; 370, identifier:output_tuple; 371, call; 371, 372; 371, 373; 372, identifier:extract_output; 373, argument_list; 373, 374; 374, identifier:tmp_dir; 375, expression_statement; 375, 376; 376, call; 376, 377; 376, 380; 377, attribute; 377, 378; 377, 379; 378, identifier:shutil; 379, identifier:rmtree; 380, argument_list; 380, 381; 381, identifier:tmp_dir; 382, return_statement; 382, 383; 383, identifier:output_tuple | def run_on_text(text, python2_path):
tees_path = get_config('TEES_PATH')
if tees_path is None:
for cpath in tees_candidate_paths:
cpath = os.path.expanduser(cpath)
if os.path.isdir(cpath):
has_expected_files = True
for f in tees_installation_files:
fpath = os.path.join(cpath, f)
present = os.path.isfile(fpath)
has_expected_files = has_expected_files and present
has_expected_dirs = True
for d in tees_installation_dirs:
dpath = os.path.join(cpath, d)
present = os.path.isdir(dpath)
has_expected_dirs = has_expected_dirs and present
if has_expected_files and has_expected_dirs:
tees_path = cpath
print('Found TEES installation at ' + cpath)
break
if not os.path.isdir(tees_path):
raise Exception('Provided TEES directory does not exist.')
classify_path = 'classify.py'
tmp_dir = tempfile.mkdtemp(suffix='indra_tees_processor')
pwd = os.path.abspath(os.getcwd())
try:
text_path = os.path.join(tmp_dir, 'text.txt')
with codecs.open(text_path, 'w', encoding='latin-1', errors='ignore') \
as f:
f.write(text)
output_path = os.path.join(tmp_dir, 'output')
model_path = os.path.join(tees_path, 'tees_data/models/GE11-test/')
command = [python2_path, classify_path, '-m', model_path,
'-i', text_path,
'-o', output_path]
try:
pwd = os.path.abspath(os.getcwd())
os.chdir(tees_path)
p = subprocess.Popen(command, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, cwd=tees_path)
p.wait()
(so, se) = p.communicate()
print(so)
print(se)
os.chdir(pwd)
except BaseException as e:
os.chdir(pwd)
raise e
except BaseException as e:
shutil.rmtree(tmp_dir)
raise e
output_tuple = extract_output(tmp_dir)
shutil.rmtree(tmp_dir)
return output_tuple |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:extract_output; 3, parameters; 3, 4; 4, identifier:output_dir; 5, block; 5, 6; 5, 18; 5, 27; 5, 56; 5, 62; 5, 91; 5, 102; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:sentences_glob; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:os; 13, identifier:path; 14, identifier:join; 15, argument_list; 15, 16; 15, 17; 16, identifier:output_dir; 17, string:'*-preprocessed.xml.gz'; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:sentences_filename_candidates; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:glob; 24, identifier:glob; 25, argument_list; 25, 26; 26, identifier:sentences_glob; 27, if_statement; 27, 28; 27, 34; 28, comparison_operator:!=; 28, 29; 28, 33; 29, call; 29, 30; 29, 31; 30, identifier:len; 31, argument_list; 31, 32; 32, identifier:sentences_filename_candidates; 33, integer:1; 34, block; 34, 35; 34, 39; 34, 51; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:m; 38, string:'Looking for exactly one file matching %s but found %d matches'; 39, raise_statement; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:Exception; 42, argument_list; 42, 43; 43, binary_operator:%; 43, 44; 43, 45; 44, identifier:m; 45, tuple; 45, 46; 45, 47; 46, identifier:sentences_glob; 47, call; 47, 48; 47, 49; 48, identifier:len; 49, argument_list; 49, 50; 50, identifier:sentences_filename_candidates; 51, return_statement; 51, 52; 52, expression_list; 52, 53; 52, 54; 52, 55; 53, None; 54, None; 55, None; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:sentence_segmentation_filename; 59, subscript; 59, 60; 59, 61; 60, identifier:sentences_filename_candidates; 61, integer:0; 62, with_statement; 62, 63; 62, 77; 63, with_clause; 63, 64; 64, with_item; 64, 65; 65, as_pattern; 65, 66; 65, 75; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:gzip; 69, identifier:GzipFile; 70, argument_list; 70, 71; 70, 74; 71, subscript; 71, 72; 71, 73; 72, identifier:sentences_filename_candidates; 73, integer:0; 74, string:'r'; 75, as_pattern_target; 75, 76; 76, identifier:f; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:sentence_segmentations; 81, call; 81, 82; 81, 89; 82, attribute; 82, 83; 82, 88; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:f; 86, identifier:read; 87, argument_list; 88, identifier:decode; 89, argument_list; 89, 90; 90, string:'utf-8'; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:tmp_dir; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:tempfile; 97, identifier:mkdtemp; 98, argument_list; 98, 99; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:suffix; 101, string:'indra_tees_processor'; 102, try_statement; 102, 103; 102, 354; 103, block; 103, 104; 103, 116; 103, 125; 103, 145; 103, 156; 103, 160; 103, 164; 103, 168; 103, 231; 103, 264; 103, 276; 103, 309; 103, 342; 103, 349; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:tarfile_glob; 107, call; 107, 108; 107, 113; 108, attribute; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:os; 111, identifier:path; 112, identifier:join; 113, argument_list; 113, 114; 113, 115; 114, identifier:output_dir; 115, string:'*-events.tar.gz'; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:candidate_tarfiles; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:glob; 122, identifier:glob; 123, argument_list; 123, 124; 124, identifier:tarfile_glob; 125, if_statement; 125, 126; 125, 132; 126, comparison_operator:!=; 126, 127; 126, 131; 127, call; 127, 128; 127, 129; 128, identifier:len; 129, argument_list; 129, 130; 130, identifier:candidate_tarfiles; 131, integer:1; 132, block; 132, 133; 132, 140; 133, raise_statement; 133, 134; 134, call; 134, 135; 134, 136; 135, identifier:Exception; 136, argument_list; 136, 137; 137, binary_operator:%; 137, 138; 137, 139; 138, string:'Expected exactly one match for glob %s'; 139, identifier:tarfile_glob; 140, return_statement; 140, 141; 141, expression_list; 141, 142; 141, 143; 141, 144; 142, None; 143, None; 144, None; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:tar_file; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:tarfile; 151, identifier:open; 152, argument_list; 152, 153; 153, subscript; 153, 154; 153, 155; 154, identifier:candidate_tarfiles; 155, integer:0; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:a1_file; 159, None; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:a2_file; 163, None; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:extract_these; 167, list:[]; 168, for_statement; 168, 169; 168, 170; 168, 175; 169, identifier:m; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:tar_file; 173, identifier:getmembers; 174, argument_list; 175, block; 175, 176; 176, if_statement; 176, 177; 176, 186; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:re; 180, identifier:match; 181, argument_list; 181, 182; 181, 183; 182, string:'[a-zA-Z0-9].*.a[12]'; 183, attribute; 183, 184; 183, 185; 184, identifier:m; 185, identifier:name; 186, block; 186, 187; 186, 194; 187, expression_statement; 187, 188; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:extract_these; 191, identifier:append; 192, argument_list; 192, 193; 193, identifier:m; 194, if_statement; 194, 195; 194, 203; 194, 210; 194, 226; 195, call; 195, 196; 195, 201; 196, attribute; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:m; 199, identifier:name; 200, identifier:endswith; 201, argument_list; 201, 202; 202, string:'.a1'; 203, block; 203, 204; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:a1_file; 207, attribute; 207, 208; 207, 209; 208, identifier:m; 209, identifier:name; 210, elif_clause; 210, 211; 210, 219; 211, call; 211, 212; 211, 217; 212, attribute; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:m; 215, identifier:name; 216, identifier:endswith; 217, argument_list; 217, 218; 218, string:'.a2'; 219, block; 219, 220; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:a2_file; 223, attribute; 223, 224; 223, 225; 224, identifier:m; 225, identifier:name; 226, else_clause; 226, 227; 227, block; 227, 228; 228, assert_statement; 228, 229; 229, parenthesized_expression; 229, 230; 230, False; 231, if_statement; 231, 232; 231, 246; 232, boolean_operator:or; 232, 233; 232, 243; 233, boolean_operator:or; 233, 234; 233, 240; 234, comparison_operator:!=; 234, 235; 234, 239; 235, call; 235, 236; 235, 237; 236, identifier:len; 237, argument_list; 237, 238; 238, identifier:extract_these; 239, integer:2; 240, comparison_operator:is; 240, 241; 240, 242; 241, identifier:a1_file; 242, None; 243, comparison_operator:is; 243, 244; 243, 245; 244, identifier:a2_file; 245, None; 246, block; 246, 247; 246, 259; 247, raise_statement; 247, 248; 248, call; 248, 249; 248, 250; 249, identifier:Exception; 250, argument_list; 250, 251; 251, binary_operator:+; 251, 252; 251, 253; 252, string:'We thought there would be one .a1 and one .a2'; 253, binary_operator:%; 253, 254; 253, 255; 254, string:' file in the tarball, but we got %d files total'; 255, call; 255, 256; 255, 257; 256, identifier:len; 257, argument_list; 257, 258; 258, identifier:extract_these; 259, return_statement; 259, 260; 260, expression_list; 260, 261; 260, 262; 260, 263; 261, None; 262, None; 263, None; 264, expression_statement; 264, 265; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:tar_file; 268, identifier:extractall; 269, argument_list; 269, 270; 269, 273; 270, keyword_argument; 270, 271; 270, 272; 271, identifier:path; 272, identifier:tmp_dir; 273, keyword_argument; 273, 274; 273, 275; 274, identifier:members; 275, identifier:extract_these; 276, with_statement; 276, 277; 276, 300; 277, with_clause; 277, 278; 278, with_item; 278, 279; 279, as_pattern; 279, 280; 279, 298; 280, call; 280, 281; 280, 284; 281, attribute; 281, 282; 281, 283; 282, identifier:codecs; 283, identifier:open; 284, argument_list; 284, 285; 284, 294; 284, 295; 285, call; 285, 286; 285, 291; 286, attribute; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:os; 289, identifier:path; 290, identifier:join; 291, argument_list; 291, 292; 291, 293; 292, identifier:tmp_dir; 293, identifier:a1_file; 294, string:'r'; 295, keyword_argument; 295, 296; 295, 297; 296, identifier:encoding; 297, string:'utf-8'; 298, as_pattern_target; 298, 299; 299, identifier:f; 300, block; 300, 301; 301, expression_statement; 301, 302; 302, assignment; 302, 303; 302, 304; 303, identifier:a1_text; 304, call; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:f; 307, identifier:read; 308, argument_list; 309, with_statement; 309, 310; 309, 333; 310, with_clause; 310, 311; 311, with_item; 311, 312; 312, as_pattern; 312, 313; 312, 331; 313, call; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:codecs; 316, identifier:open; 317, argument_list; 317, 318; 317, 327; 317, 328; 318, call; 318, 319; 318, 324; 319, attribute; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:os; 322, identifier:path; 323, identifier:join; 324, argument_list; 324, 325; 324, 326; 325, identifier:tmp_dir; 326, identifier:a2_file; 327, string:'r'; 328, keyword_argument; 328, 329; 328, 330; 329, identifier:encoding; 330, string:'utf-8'; 331, as_pattern_target; 331, 332; 332, identifier:f; 333, block; 333, 334; 334, expression_statement; 334, 335; 335, assignment; 335, 336; 335, 337; 336, identifier:a2_text; 337, call; 337, 338; 337, 341; 338, attribute; 338, 339; 338, 340; 339, identifier:f; 340, identifier:read; 341, argument_list; 342, expression_statement; 342, 343; 343, call; 343, 344; 343, 347; 344, attribute; 344, 345; 344, 346; 345, identifier:shutil; 346, identifier:rmtree; 347, argument_list; 347, 348; 348, identifier:tmp_dir; 349, return_statement; 349, 350; 350, expression_list; 350, 351; 350, 352; 350, 353; 351, identifier:a1_text; 352, identifier:a2_text; 353, identifier:sentence_segmentations; 354, except_clause; 354, 355; 354, 359; 355, as_pattern; 355, 356; 355, 357; 356, identifier:BaseException; 357, as_pattern_target; 357, 358; 358, identifier:e; 359, block; 359, 360; 359, 367; 359, 374; 359, 376; 360, expression_statement; 360, 361; 361, call; 361, 362; 361, 363; 362, identifier:print; 363, argument_list; 363, 364; 364, binary_operator:+; 364, 365; 364, 366; 365, string:'Not removing temporary directory: '; 366, identifier:tmp_dir; 367, expression_statement; 367, 368; 368, call; 368, 369; 368, 372; 369, attribute; 369, 370; 369, 371; 370, identifier:shutil; 371, identifier:rmtree; 372, argument_list; 372, 373; 373, identifier:tmp_dir; 374, raise_statement; 374, 375; 375, identifier:e; 376, return_statement; 376, 377; 377, expression_list; 377, 378; 377, 379; 377, 380; 378, None; 379, None; 380, None | def extract_output(output_dir):
sentences_glob = os.path.join(output_dir, '*-preprocessed.xml.gz')
sentences_filename_candidates = glob.glob(sentences_glob)
if len(sentences_filename_candidates) != 1:
m = 'Looking for exactly one file matching %s but found %d matches'
raise Exception(m % (
sentences_glob, len(sentences_filename_candidates)))
return None, None, None
sentence_segmentation_filename = sentences_filename_candidates[0]
with gzip.GzipFile(sentences_filename_candidates[0], 'r') as f:
sentence_segmentations = f.read().decode('utf-8')
tmp_dir = tempfile.mkdtemp(suffix='indra_tees_processor')
try:
tarfile_glob = os.path.join(output_dir, '*-events.tar.gz')
candidate_tarfiles = glob.glob(tarfile_glob)
if len(candidate_tarfiles) != 1:
raise Exception('Expected exactly one match for glob %s' %
tarfile_glob)
return None, None, None
tar_file = tarfile.open(candidate_tarfiles[0])
a1_file = None
a2_file = None
extract_these = []
for m in tar_file.getmembers():
if re.match('[a-zA-Z0-9].*.a[12]', m.name):
extract_these.append(m)
if m.name.endswith('.a1'):
a1_file = m.name
elif m.name.endswith('.a2'):
a2_file = m.name
else:
assert(False)
if len(extract_these) != 2 or a1_file is None or a2_file is None:
raise Exception('We thought there would be one .a1 and one .a2' +
' file in the tarball, but we got %d files total' %
len(extract_these))
return None, None, None
tar_file.extractall(path=tmp_dir, members=extract_these)
with codecs.open(os.path.join(tmp_dir, a1_file), 'r',
encoding='utf-8') as f:
a1_text = f.read()
with codecs.open(os.path.join(tmp_dir, a2_file), 'r',
encoding='utf-8') as f:
a2_text = f.read()
shutil.rmtree(tmp_dir)
return a1_text, a2_text, sentence_segmentations
except BaseException as e:
print('Not removing temporary directory: ' + tmp_dir)
shutil.rmtree(tmp_dir)
raise e
return None, None, None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_drug_inhibition_stmts; 3, parameters; 3, 4; 4, identifier:drug; 5, block; 5, 6; 5, 17; 5, 28; 5, 61; 5, 71; 5, 87; 5, 94; 5, 100; 5, 107; 5, 115; 5, 122; 5, 138; 5, 142; 5, 270; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:chebi_id; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:drug; 13, identifier:db_refs; 14, identifier:get; 15, argument_list; 15, 16; 16, string:'CHEBI'; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:mesh_id; 20, call; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:drug; 24, identifier:db_refs; 25, identifier:get; 26, argument_list; 26, 27; 27, string:'MESH'; 28, if_statement; 28, 29; 28, 30; 28, 40; 28, 50; 29, identifier:chebi_id; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:drug_chembl_id; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:chebi_client; 37, identifier:get_chembl_id; 38, argument_list; 38, 39; 39, identifier:chebi_id; 40, elif_clause; 40, 41; 40, 42; 41, identifier:mesh_id; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:drug_chembl_id; 46, call; 46, 47; 46, 48; 47, identifier:get_chembl_id; 48, argument_list; 48, 49; 49, identifier:mesh_id; 50, else_clause; 50, 51; 51, block; 51, 52; 51, 59; 52, expression_statement; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:logger; 56, identifier:error; 57, argument_list; 57, 58; 58, string:'Drug missing ChEBI or MESH grounding.'; 59, return_statement; 59, 60; 60, None; 61, expression_statement; 61, 62; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:logger; 65, identifier:info; 66, argument_list; 66, 67; 67, binary_operator:%; 67, 68; 67, 69; 68, string:'Drug: %s'; 69, parenthesized_expression; 69, 70; 70, identifier:drug_chembl_id; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:query_dict; 74, dictionary; 74, 75; 74, 78; 75, pair; 75, 76; 75, 77; 76, string:'query'; 77, string:'activity'; 78, pair; 78, 79; 78, 80; 79, string:'params'; 80, dictionary; 80, 81; 80, 84; 81, pair; 81, 82; 81, 83; 82, string:'molecule_chembl_id'; 83, identifier:drug_chembl_id; 84, pair; 84, 85; 84, 86; 85, string:'limit'; 86, integer:10000; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:res; 90, call; 90, 91; 90, 92; 91, identifier:send_query; 92, argument_list; 92, 93; 93, identifier:query_dict; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:activities; 97, subscript; 97, 98; 97, 99; 98, identifier:res; 99, string:'activities'; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:targ_act_dict; 103, call; 103, 104; 103, 105; 104, identifier:activities_by_target; 105, argument_list; 105, 106; 106, identifier:activities; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:target_chembl_ids; 110, list_comprehension; 110, 111; 110, 112; 111, identifier:x; 112, for_in_clause; 112, 113; 112, 114; 113, identifier:x; 114, identifier:targ_act_dict; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:protein_targets; 118, call; 118, 119; 118, 120; 119, identifier:get_protein_targets_only; 120, argument_list; 120, 121; 121, identifier:target_chembl_ids; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:filtered_targ_act_dict; 125, dictionary_comprehension; 125, 126; 125, 131; 126, pair; 126, 127; 126, 128; 127, identifier:t; 128, subscript; 128, 129; 128, 130; 129, identifier:targ_act_dict; 130, identifier:t; 131, for_in_clause; 131, 132; 131, 133; 132, identifier:t; 133, list_comprehension; 133, 134; 133, 135; 134, identifier:x; 135, for_in_clause; 135, 136; 135, 137; 136, identifier:x; 137, identifier:protein_targets; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:stmts; 141, list:[]; 142, for_statement; 142, 143; 142, 144; 142, 145; 143, identifier:target_chembl_id; 144, identifier:filtered_targ_act_dict; 145, block; 145, 146; 145, 152; 145, 166; 145, 170; 145, 178; 145, 191; 145, 195; 145, 218; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:target_activity_ids; 149, subscript; 149, 150; 149, 151; 150, identifier:filtered_targ_act_dict; 151, identifier:target_chembl_id; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:target_activites; 155, list_comprehension; 155, 156; 155, 157; 155, 160; 156, identifier:x; 157, for_in_clause; 157, 158; 157, 159; 158, identifier:x; 159, identifier:activities; 160, if_clause; 160, 161; 161, comparison_operator:in; 161, 162; 161, 165; 162, subscript; 162, 163; 162, 164; 163, identifier:x; 164, string:'activity_id'; 165, identifier:target_activity_ids; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:target_upids; 169, list:[]; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:targ_comp; 173, subscript; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:protein_targets; 176, identifier:target_chembl_id; 177, string:'target_components'; 178, for_statement; 178, 179; 178, 180; 178, 181; 179, identifier:t_c; 180, identifier:targ_comp; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:target_upids; 186, identifier:append; 187, argument_list; 187, 188; 188, subscript; 188, 189; 188, 190; 189, identifier:t_c; 190, string:'accession'; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:evidence; 194, list:[]; 195, for_statement; 195, 196; 195, 197; 195, 198; 196, identifier:assay; 197, identifier:target_activites; 198, block; 198, 199; 198, 206; 198, 211; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:ev; 202, call; 202, 203; 202, 204; 203, identifier:get_evidence; 204, argument_list; 204, 205; 205, identifier:assay; 206, if_statement; 206, 207; 206, 209; 207, not_operator; 207, 208; 208, identifier:ev; 209, block; 209, 210; 210, continue_statement; 211, expression_statement; 211, 212; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:evidence; 215, identifier:append; 216, argument_list; 216, 217; 217, identifier:ev; 218, if_statement; 218, 219; 218, 225; 219, comparison_operator:>; 219, 220; 219, 224; 220, call; 220, 221; 220, 222; 221, identifier:len; 222, argument_list; 222, 223; 223, identifier:evidence; 224, integer:0; 225, block; 225, 226; 226, for_statement; 226, 227; 226, 228; 226, 229; 227, identifier:target_upid; 228, identifier:target_upids; 229, block; 229, 230; 229, 239; 229, 252; 229, 263; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:agent_name; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:uniprot_client; 236, identifier:get_gene_name; 237, argument_list; 237, 238; 238, identifier:target_upid; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 242; 241, identifier:target_agent; 242, call; 242, 243; 242, 244; 243, identifier:Agent; 244, argument_list; 244, 245; 244, 246; 245, identifier:agent_name; 246, keyword_argument; 246, 247; 246, 248; 247, identifier:db_refs; 248, dictionary; 248, 249; 249, pair; 249, 250; 249, 251; 250, string:'UP'; 251, identifier:target_upid; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 255; 254, identifier:st; 255, call; 255, 256; 255, 257; 256, identifier:Inhibition; 257, argument_list; 257, 258; 257, 259; 257, 260; 258, identifier:drug; 259, identifier:target_agent; 260, keyword_argument; 260, 261; 260, 262; 261, identifier:evidence; 262, identifier:evidence; 263, expression_statement; 263, 264; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:stmts; 267, identifier:append; 268, argument_list; 268, 269; 269, identifier:st; 270, return_statement; 270, 271; 271, identifier:stmts | def get_drug_inhibition_stmts(drug):
chebi_id = drug.db_refs.get('CHEBI')
mesh_id = drug.db_refs.get('MESH')
if chebi_id:
drug_chembl_id = chebi_client.get_chembl_id(chebi_id)
elif mesh_id:
drug_chembl_id = get_chembl_id(mesh_id)
else:
logger.error('Drug missing ChEBI or MESH grounding.')
return None
logger.info('Drug: %s' % (drug_chembl_id))
query_dict = {'query': 'activity',
'params': {'molecule_chembl_id': drug_chembl_id,
'limit': 10000}
}
res = send_query(query_dict)
activities = res['activities']
targ_act_dict = activities_by_target(activities)
target_chembl_ids = [x for x in targ_act_dict]
protein_targets = get_protein_targets_only(target_chembl_ids)
filtered_targ_act_dict = {t: targ_act_dict[t]
for t in [x for x in protein_targets]}
stmts = []
for target_chembl_id in filtered_targ_act_dict:
target_activity_ids = filtered_targ_act_dict[target_chembl_id]
target_activites = [x for x in activities
if x['activity_id'] in target_activity_ids]
target_upids = []
targ_comp = protein_targets[target_chembl_id]['target_components']
for t_c in targ_comp:
target_upids.append(t_c['accession'])
evidence = []
for assay in target_activites:
ev = get_evidence(assay)
if not ev:
continue
evidence.append(ev)
if len(evidence) > 0:
for target_upid in target_upids:
agent_name = uniprot_client.get_gene_name(target_upid)
target_agent = Agent(agent_name, db_refs={'UP': target_upid})
st = Inhibition(drug, target_agent, evidence=evidence)
stmts.append(st)
return stmts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:merge_groundings; 3, parameters; 3, 4; 4, identifier:stmts_in; 5, block; 5, 6; 5, 117; 5, 293; 5, 297; 5, 323; 6, function_definition; 6, 7; 6, 8; 6, 10; 7, function_name:surface_grounding; 8, parameters; 8, 9; 9, identifier:stmt; 10, block; 10, 11; 11, for_statement; 11, 12; 11, 15; 11, 23; 12, pattern_list; 12, 13; 12, 14; 13, identifier:idx; 14, identifier:concept; 15, call; 15, 16; 15, 17; 16, identifier:enumerate; 17, argument_list; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:stmt; 21, identifier:agent_list; 22, argument_list; 23, block; 23, 24; 23, 30; 23, 34; 23, 104; 23, 111; 24, if_statement; 24, 25; 24, 28; 25, comparison_operator:is; 25, 26; 25, 27; 26, identifier:concept; 27, None; 28, block; 28, 29; 29, continue_statement; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:aggregate_groundings; 33, dictionary; 34, for_statement; 34, 35; 34, 36; 34, 39; 35, identifier:ev; 36, attribute; 36, 37; 36, 38; 37, identifier:stmt; 38, identifier:evidence; 39, block; 39, 40; 40, if_statement; 40, 41; 40, 46; 41, comparison_operator:in; 41, 42; 41, 43; 42, string:'agents'; 43, attribute; 43, 44; 43, 45; 44, identifier:ev; 45, identifier:annotations; 46, block; 46, 47; 46, 59; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:groundings; 50, subscript; 50, 51; 50, 58; 51, subscript; 51, 52; 51, 57; 52, subscript; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:ev; 55, identifier:annotations; 56, string:'agents'; 57, string:'raw_grounding'; 58, identifier:idx; 59, for_statement; 59, 60; 59, 63; 59, 68; 60, pattern_list; 60, 61; 60, 62; 61, identifier:ns; 62, identifier:value; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:groundings; 66, identifier:items; 67, argument_list; 68, block; 68, 69; 68, 80; 69, if_statement; 69, 70; 69, 73; 70, comparison_operator:not; 70, 71; 70, 72; 71, identifier:ns; 72, identifier:aggregate_groundings; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 79; 76, subscript; 76, 77; 76, 78; 77, identifier:aggregate_groundings; 78, identifier:ns; 79, list:[]; 80, if_statement; 80, 81; 80, 86; 80, 93; 81, call; 81, 82; 81, 83; 82, identifier:isinstance; 83, argument_list; 83, 84; 83, 85; 84, identifier:value; 85, identifier:list; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, augmented_assignment:+=; 88, 89; 88, 92; 89, subscript; 89, 90; 89, 91; 90, identifier:aggregate_groundings; 91, identifier:ns; 92, identifier:value; 93, else_clause; 93, 94; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 102; 97, attribute; 97, 98; 97, 101; 98, subscript; 98, 99; 98, 100; 99, identifier:aggregate_groundings; 100, identifier:ns; 101, identifier:append; 102, argument_list; 102, 103; 103, identifier:value; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:best_groundings; 107, call; 107, 108; 107, 109; 108, identifier:get_best_groundings; 109, argument_list; 109, 110; 110, identifier:aggregate_groundings; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:concept; 115, identifier:db_refs; 116, identifier:best_groundings; 117, function_definition; 117, 118; 117, 119; 117, 121; 118, function_name:get_best_groundings; 119, parameters; 119, 120; 120, identifier:aggregate_groundings; 121, block; 121, 122; 121, 126; 121, 291; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:best_groundings; 125, dictionary; 126, for_statement; 126, 127; 126, 130; 126, 135; 127, pattern_list; 127, 128; 127, 129; 128, identifier:ns; 129, identifier:values; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:aggregate_groundings; 133, identifier:items; 134, argument_list; 135, block; 135, 136; 136, if_statement; 136, 137; 136, 151; 136, 221; 136, 255; 137, call; 137, 138; 137, 139; 138, identifier:all; 139, argument_list; 139, 140; 140, list_comprehension; 140, 141; 140, 148; 141, call; 141, 142; 141, 143; 142, identifier:isinstance; 143, argument_list; 143, 144; 143, 145; 144, identifier:v; 145, tuple; 145, 146; 145, 147; 146, identifier:tuple; 147, identifier:list; 148, for_in_clause; 148, 149; 148, 150; 149, identifier:v; 150, identifier:values; 151, block; 151, 152; 151, 158; 151, 198; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 157; 154, subscript; 154, 155; 154, 156; 155, identifier:best_groundings; 156, identifier:ns; 157, list:[]; 158, for_statement; 158, 159; 158, 160; 158, 167; 159, identifier:unique_value; 160, set_comprehension; 160, 161; 160, 164; 161, subscript; 161, 162; 161, 163; 162, identifier:v; 163, integer:0; 164, for_in_clause; 164, 165; 164, 166; 165, identifier:v; 166, identifier:values; 167, block; 167, 168; 167, 184; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:scores; 171, list_comprehension; 171, 172; 171, 175; 171, 178; 172, subscript; 172, 173; 172, 174; 173, identifier:v; 174, integer:1; 175, for_in_clause; 175, 176; 175, 177; 176, identifier:v; 177, identifier:values; 178, if_clause; 178, 179; 179, comparison_operator:==; 179, 180; 179, 183; 180, subscript; 180, 181; 180, 182; 181, identifier:v; 182, integer:0; 183, identifier:unique_value; 184, expression_statement; 184, 185; 185, call; 185, 186; 185, 191; 186, attribute; 186, 187; 186, 190; 187, subscript; 187, 188; 187, 189; 188, identifier:best_groundings; 189, identifier:ns; 190, identifier:append; 191, argument_list; 191, 192; 192, tuple; 192, 193; 192, 194; 193, identifier:unique_value; 194, call; 194, 195; 194, 196; 195, identifier:max; 196, argument_list; 196, 197; 197, identifier:scores; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 203; 199, 204; 200, subscript; 200, 201; 200, 202; 201, identifier:best_groundings; 202, identifier:ns; 203, line_continuation:\; 204, call; 204, 205; 204, 206; 205, identifier:sorted; 206, argument_list; 206, 207; 206, 210; 206, 218; 207, subscript; 207, 208; 207, 209; 208, identifier:best_groundings; 209, identifier:ns; 210, keyword_argument; 210, 211; 210, 212; 211, identifier:key; 212, lambda; 212, 213; 212, 215; 213, lambda_parameters; 213, 214; 214, identifier:x; 215, subscript; 215, 216; 215, 217; 216, identifier:x; 217, integer:1; 218, keyword_argument; 218, 219; 218, 220; 219, identifier:reverse; 220, True; 221, elif_clause; 221, 222; 221, 237; 222, call; 222, 223; 222, 224; 223, identifier:all; 224, argument_list; 224, 225; 225, list_comprehension; 225, 226; 225, 234; 226, not_operator; 226, 227; 227, call; 227, 228; 227, 229; 228, identifier:isinstance; 229, argument_list; 229, 230; 229, 231; 230, identifier:v; 231, tuple; 231, 232; 231, 233; 232, identifier:tuple; 233, identifier:list; 234, for_in_clause; 234, 235; 234, 236; 235, identifier:v; 236, identifier:values; 237, block; 237, 238; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 243; 240, subscript; 240, 241; 240, 242; 241, identifier:best_groundings; 242, identifier:ns; 243, call; 243, 244; 243, 245; 244, identifier:max; 245, argument_list; 245, 246; 245, 250; 246, call; 246, 247; 246, 248; 247, identifier:set; 248, argument_list; 248, 249; 249, identifier:values; 250, keyword_argument; 250, 251; 250, 252; 251, identifier:key; 252, attribute; 252, 253; 252, 254; 253, identifier:values; 254, identifier:count; 255, else_clause; 255, 256; 256, block; 256, 257; 256, 274; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 260; 259, identifier:unscored_vals; 260, list_comprehension; 260, 261; 260, 262; 260, 265; 261, identifier:v; 262, for_in_clause; 262, 263; 262, 264; 263, identifier:v; 264, identifier:values; 265, if_clause; 265, 266; 266, not_operator; 266, 267; 267, call; 267, 268; 267, 269; 268, identifier:isinstance; 269, argument_list; 269, 270; 269, 271; 270, identifier:v; 271, tuple; 271, 272; 271, 273; 272, identifier:tuple; 273, identifier:list; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 279; 276, subscript; 276, 277; 276, 278; 277, identifier:best_groundings; 278, identifier:ns; 279, call; 279, 280; 279, 281; 280, identifier:max; 281, argument_list; 281, 282; 281, 286; 282, call; 282, 283; 282, 284; 283, identifier:set; 284, argument_list; 284, 285; 285, identifier:unscored_vals; 286, keyword_argument; 286, 287; 286, 288; 287, identifier:key; 288, attribute; 288, 289; 288, 290; 289, identifier:unscored_vals; 290, identifier:count; 291, return_statement; 291, 292; 292, identifier:best_groundings; 293, expression_statement; 293, 294; 294, assignment; 294, 295; 294, 296; 295, identifier:stmts_out; 296, list:[]; 297, for_statement; 297, 298; 297, 299; 297, 300; 298, identifier:stmt; 299, identifier:stmts_in; 300, block; 300, 301; 300, 316; 301, if_statement; 301, 302; 301, 310; 302, not_operator; 302, 303; 303, call; 303, 304; 303, 305; 304, identifier:isinstance; 305, argument_list; 305, 306; 305, 307; 306, identifier:stmt; 307, tuple; 307, 308; 307, 309; 308, identifier:Complex; 309, identifier:Conversion; 310, block; 310, 311; 311, expression_statement; 311, 312; 312, call; 312, 313; 312, 314; 313, identifier:surface_grounding; 314, argument_list; 314, 315; 315, identifier:stmt; 316, expression_statement; 316, 317; 317, call; 317, 318; 317, 321; 318, attribute; 318, 319; 318, 320; 319, identifier:stmts_out; 320, identifier:append; 321, argument_list; 321, 322; 322, identifier:stmt; 323, return_statement; 323, 324; 324, identifier:stmts_out | def merge_groundings(stmts_in):
def surface_grounding(stmt):
for idx, concept in enumerate(stmt.agent_list()):
if concept is None:
continue
aggregate_groundings = {}
for ev in stmt.evidence:
if 'agents' in ev.annotations:
groundings = ev.annotations['agents']['raw_grounding'][idx]
for ns, value in groundings.items():
if ns not in aggregate_groundings:
aggregate_groundings[ns] = []
if isinstance(value, list):
aggregate_groundings[ns] += value
else:
aggregate_groundings[ns].append(value)
best_groundings = get_best_groundings(aggregate_groundings)
concept.db_refs = best_groundings
def get_best_groundings(aggregate_groundings):
best_groundings = {}
for ns, values in aggregate_groundings.items():
if all([isinstance(v, (tuple, list)) for v in values]):
best_groundings[ns] = []
for unique_value in {v[0] for v in values}:
scores = [v[1] for v in values if v[0] == unique_value]
best_groundings[ns].append((unique_value, max(scores)))
best_groundings[ns] = \
sorted(best_groundings[ns], key=lambda x: x[1],
reverse=True)
elif all([not isinstance(v, (tuple, list)) for v in values]):
best_groundings[ns] = max(set(values), key=values.count)
else:
unscored_vals = [v for v in values
if not isinstance(v, (tuple, list))]
best_groundings[ns] = max(set(unscored_vals),
key=unscored_vals.count)
return best_groundings
stmts_out = []
for stmt in stmts_in:
if not isinstance(stmt, (Complex, Conversion)):
surface_grounding(stmt)
stmts_out.append(stmt)
return stmts_out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:merge_deltas; 3, parameters; 3, 4; 4, identifier:stmts_in; 5, block; 5, 6; 5, 10; 5, 298; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:stmts_out; 9, list:[]; 10, for_statement; 10, 11; 10, 12; 10, 13; 11, identifier:stmt; 12, identifier:stmts_in; 13, block; 13, 14; 13, 30; 13, 34; 13, 89; 13, 108; 13, 128; 13, 230; 13, 291; 14, if_statement; 14, 15; 14, 21; 15, not_operator; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:isinstance; 18, argument_list; 18, 19; 18, 20; 19, identifier:stmt; 20, identifier:Influence; 21, block; 21, 22; 21, 29; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:stmts_out; 26, identifier:append; 27, argument_list; 27, 28; 28, identifier:stmt; 29, continue_statement; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:deltas; 33, dictionary; 34, for_statement; 34, 35; 34, 36; 34, 39; 35, identifier:role; 36, tuple; 36, 37; 36, 38; 37, string:'subj'; 38, string:'obj'; 39, block; 39, 40; 40, for_statement; 40, 41; 40, 42; 40, 45; 41, identifier:info; 42, tuple; 42, 43; 42, 44; 43, string:'polarity'; 44, string:'adjectives'; 45, block; 45, 46; 45, 52; 45, 58; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:key; 49, tuple; 49, 50; 49, 51; 50, identifier:role; 51, identifier:info; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 57; 54, subscript; 54, 55; 54, 56; 55, identifier:deltas; 56, identifier:key; 57, list:[]; 58, for_statement; 58, 59; 58, 60; 58, 63; 59, identifier:ev; 60, attribute; 60, 61; 60, 62; 61, identifier:stmt; 62, identifier:evidence; 63, block; 63, 64; 63, 77; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:entry; 67, call; 67, 68; 67, 73; 68, attribute; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:ev; 71, identifier:annotations; 72, identifier:get; 73, argument_list; 73, 74; 74, binary_operator:%; 74, 75; 74, 76; 75, string:'%s_%s'; 76, identifier:key; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 84; 79, attribute; 79, 80; 79, 83; 80, subscript; 80, 81; 80, 82; 81, identifier:deltas; 82, identifier:key; 83, identifier:append; 84, argument_list; 84, 85; 85, conditional_expression:if; 85, 86; 85, 87; 85, 88; 86, identifier:entry; 87, identifier:entry; 88, None; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:polarity_pairs; 92, call; 92, 93; 92, 94; 93, identifier:list; 94, argument_list; 94, 95; 95, call; 95, 96; 95, 97; 96, identifier:zip; 97, argument_list; 97, 98; 97, 103; 98, subscript; 98, 99; 98, 100; 99, identifier:deltas; 100, tuple; 100, 101; 100, 102; 101, string:'subj'; 102, string:'polarity'; 103, subscript; 103, 104; 103, 105; 104, identifier:deltas; 105, tuple; 105, 106; 105, 107; 106, string:'obj'; 107, string:'polarity'; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:both_pols; 111, list_comprehension; 111, 112; 111, 113; 111, 116; 112, identifier:pair; 113, for_in_clause; 113, 114; 113, 115; 114, identifier:pair; 115, identifier:polarity_pairs; 116, if_clause; 116, 117; 117, boolean_operator:and; 117, 118; 117, 123; 118, comparison_operator:is; 118, 119; 118, 122; 119, subscript; 119, 120; 119, 121; 120, identifier:pair; 121, integer:0; 122, None; 123, comparison_operator:is; 123, 124; 123, 127; 124, subscript; 124, 125; 124, 126; 125, identifier:pair; 126, integer:1; 127, None; 128, if_statement; 128, 129; 128, 130; 128, 168; 129, identifier:both_pols; 130, block; 130, 131; 130, 148; 130, 158; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 136; 133, pattern_list; 133, 134; 133, 135; 134, identifier:subj_pol; 135, identifier:obj_pol; 136, call; 136, 137; 136, 138; 137, identifier:max; 138, argument_list; 138, 139; 138, 143; 139, call; 139, 140; 139, 141; 140, identifier:set; 141, argument_list; 141, 142; 142, identifier:both_pols; 143, keyword_argument; 143, 144; 143, 145; 144, identifier:key; 145, attribute; 145, 146; 145, 147; 146, identifier:both_pols; 147, identifier:count; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 157; 150, subscript; 150, 151; 150, 156; 151, attribute; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:stmt; 154, identifier:subj; 155, identifier:delta; 156, string:'polarity'; 157, identifier:subj_pol; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 167; 160, subscript; 160, 161; 160, 166; 161, attribute; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:stmt; 164, identifier:obj; 165, identifier:delta; 166, string:'polarity'; 167, identifier:obj_pol; 168, else_clause; 168, 169; 169, block; 169, 170; 169, 190; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:one_pol; 173, list_comprehension; 173, 174; 173, 175; 173, 178; 174, identifier:pair; 175, for_in_clause; 175, 176; 175, 177; 176, identifier:pair; 177, identifier:polarity_pairs; 178, if_clause; 178, 179; 179, boolean_operator:or; 179, 180; 179, 185; 180, comparison_operator:is; 180, 181; 180, 184; 181, subscript; 181, 182; 181, 183; 182, identifier:pair; 183, integer:0; 184, None; 185, comparison_operator:is; 185, 186; 185, 189; 186, subscript; 186, 187; 186, 188; 187, identifier:pair; 188, integer:1; 189, None; 190, if_statement; 190, 191; 190, 192; 191, identifier:one_pol; 192, block; 192, 193; 192, 210; 192, 220; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 198; 195, pattern_list; 195, 196; 195, 197; 196, identifier:subj_pol; 197, identifier:obj_pol; 198, call; 198, 199; 198, 200; 199, identifier:max; 200, argument_list; 200, 201; 200, 205; 201, call; 201, 202; 201, 203; 202, identifier:set; 203, argument_list; 203, 204; 204, identifier:one_pol; 205, keyword_argument; 205, 206; 205, 207; 206, identifier:key; 207, attribute; 207, 208; 207, 209; 208, identifier:one_pol; 209, identifier:count; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 219; 212, subscript; 212, 213; 212, 218; 213, attribute; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:stmt; 216, identifier:subj; 217, identifier:delta; 218, string:'polarity'; 219, identifier:subj_pol; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 229; 222, subscript; 222, 223; 222, 228; 223, attribute; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:stmt; 226, identifier:obj; 227, identifier:delta; 228, string:'polarity'; 229, identifier:obj_pol; 230, for_statement; 230, 231; 230, 234; 230, 249; 231, pattern_list; 231, 232; 231, 233; 232, identifier:attr; 233, identifier:role; 234, tuple; 234, 235; 234, 242; 235, tuple; 235, 236; 235, 241; 236, attribute; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:stmt; 239, identifier:subj; 240, identifier:delta; 241, string:'subj'; 242, tuple; 242, 243; 242, 248; 243, attribute; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:stmt; 246, identifier:obj; 247, identifier:delta; 248, string:'obj'; 249, block; 249, 250; 249, 254; 249, 285; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:all_adjectives; 253, list:[]; 254, for_statement; 254, 255; 254, 256; 254, 261; 255, identifier:adj; 256, subscript; 256, 257; 256, 258; 257, identifier:deltas; 258, tuple; 258, 259; 258, 260; 259, identifier:role; 260, string:'adjectives'; 261, block; 261, 262; 262, if_statement; 262, 263; 262, 268; 262, 273; 263, call; 263, 264; 263, 265; 264, identifier:isinstance; 265, argument_list; 265, 266; 265, 267; 266, identifier:adj; 267, identifier:list; 268, block; 268, 269; 269, expression_statement; 269, 270; 270, augmented_assignment:+=; 270, 271; 270, 272; 271, identifier:all_adjectives; 272, identifier:adj; 273, elif_clause; 273, 274; 273, 277; 274, comparison_operator:is; 274, 275; 274, 276; 275, identifier:adj; 276, None; 277, block; 277, 278; 278, expression_statement; 278, 279; 279, call; 279, 280; 279, 283; 280, attribute; 280, 281; 280, 282; 281, identifier:all_adjectives; 282, identifier:append; 283, argument_list; 283, 284; 284, identifier:adj; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 290; 287, subscript; 287, 288; 287, 289; 288, identifier:attr; 289, string:'adjectives'; 290, identifier:all_adjectives; 291, expression_statement; 291, 292; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:stmts_out; 295, identifier:append; 296, argument_list; 296, 297; 297, identifier:stmt; 298, return_statement; 298, 299; 299, identifier:stmts_out | def merge_deltas(stmts_in):
stmts_out = []
for stmt in stmts_in:
if not isinstance(stmt, Influence):
stmts_out.append(stmt)
continue
deltas = {}
for role in ('subj', 'obj'):
for info in ('polarity', 'adjectives'):
key = (role, info)
deltas[key] = []
for ev in stmt.evidence:
entry = ev.annotations.get('%s_%s' % key)
deltas[key].append(entry if entry else None)
polarity_pairs = list(zip(deltas[('subj', 'polarity')],
deltas[('obj', 'polarity')]))
both_pols = [pair for pair in polarity_pairs if pair[0] is not None and
pair[1] is not None]
if both_pols:
subj_pol, obj_pol = max(set(both_pols), key=both_pols.count)
stmt.subj.delta['polarity'] = subj_pol
stmt.obj.delta['polarity'] = obj_pol
else:
one_pol = [pair for pair in polarity_pairs if pair[0] is not None or
pair[1] is not None]
if one_pol:
subj_pol, obj_pol = max(set(one_pol), key=one_pol.count)
stmt.subj.delta['polarity'] = subj_pol
stmt.obj.delta['polarity'] = obj_pol
for attr, role in ((stmt.subj.delta, 'subj'), (stmt.obj.delta, 'obj')):
all_adjectives = []
for adj in deltas[(role, 'adjectives')]:
if isinstance(adj, list):
all_adjectives += adj
elif adj is not None:
all_adjectives.append(adj)
attr['adjectives'] = all_adjectives
stmts_out.append(stmt)
return stmts_out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:map_sequence; 3, parameters; 3, 4; 3, 5; 4, identifier:stmts_in; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 17; 7, 29; 7, 36; 7, 58; 7, 69; 7, 73; 7, 106; 7, 112; 7, 124; 7, 133; 7, 142; 7, 144; 8, import_from_statement; 8, 9; 8, 13; 8, 15; 9, dotted_name; 9, 10; 9, 11; 9, 12; 10, identifier:indra; 11, identifier:preassembler; 12, identifier:sitemapper; 13, dotted_name; 13, 14; 14, identifier:SiteMapper; 15, dotted_name; 15, 16; 16, identifier:default_site_map; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:logger; 21, identifier:info; 22, argument_list; 22, 23; 23, binary_operator:%; 23, 24; 23, 25; 24, string:'Mapping sites on %d statements...'; 25, call; 25, 26; 25, 27; 26, identifier:len; 27, argument_list; 27, 28; 28, identifier:stmts_in; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:kwarg_list; 32, list:['do_methionine_offset', 'do_orthology_mapping',
'do_isoform_mapping']; 32, 33; 32, 34; 32, 35; 33, string:'do_methionine_offset'; 34, string:'do_orthology_mapping'; 35, string:'do_isoform_mapping'; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:sm; 39, call; 39, 40; 39, 41; 40, identifier:SiteMapper; 41, argument_list; 41, 42; 41, 43; 41, 52; 42, identifier:default_site_map; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:use_cache; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:kwargs; 48, identifier:pop; 49, argument_list; 49, 50; 49, 51; 50, string:'use_cache'; 51, False; 52, dictionary_splat; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:_filter; 55, argument_list; 55, 56; 55, 57; 56, identifier:kwargs; 57, identifier:kwarg_list; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 63; 60, pattern_list; 60, 61; 60, 62; 61, identifier:valid; 62, identifier:mapped; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:sm; 66, identifier:map_sites; 67, argument_list; 67, 68; 68, identifier:stmts_in; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:correctly_mapped_stmts; 72, list:[]; 73, for_statement; 73, 74; 73, 75; 73, 76; 74, identifier:ms; 75, identifier:mapped; 76, block; 76, 77; 76, 94; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:correctly_mapped; 80, call; 80, 81; 80, 82; 81, identifier:all; 82, argument_list; 82, 83; 83, list_comprehension; 83, 84; 83, 89; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:mm; 87, identifier:has_mapping; 88, argument_list; 89, for_in_clause; 89, 90; 89, 91; 90, identifier:mm; 91, attribute; 91, 92; 91, 93; 92, identifier:ms; 93, identifier:mapped_mods; 94, if_statement; 94, 95; 94, 96; 95, identifier:correctly_mapped; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:correctly_mapped_stmts; 101, identifier:append; 102, argument_list; 102, 103; 103, attribute; 103, 104; 103, 105; 104, identifier:ms; 105, identifier:mapped_stmt; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:stmts_out; 109, binary_operator:+; 109, 110; 109, 111; 110, identifier:valid; 111, identifier:correctly_mapped_stmts; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:logger; 116, identifier:info; 117, argument_list; 117, 118; 118, binary_operator:%; 118, 119; 118, 120; 119, string:'%d statements with valid sites'; 120, call; 120, 121; 120, 122; 121, identifier:len; 122, argument_list; 122, 123; 123, identifier:stmts_out; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:dump_pkl; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:kwargs; 130, identifier:get; 131, argument_list; 131, 132; 132, string:'save'; 133, if_statement; 133, 134; 133, 135; 134, identifier:dump_pkl; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 139; 138, identifier:dump_statements; 139, argument_list; 139, 140; 139, 141; 140, identifier:stmts_out; 141, identifier:dump_pkl; 142, delete_statement; 142, 143; 143, identifier:sm; 144, return_statement; 144, 145; 145, identifier:stmts_out | def map_sequence(stmts_in, **kwargs):
from indra.preassembler.sitemapper import SiteMapper, default_site_map
logger.info('Mapping sites on %d statements...' % len(stmts_in))
kwarg_list = ['do_methionine_offset', 'do_orthology_mapping',
'do_isoform_mapping']
sm = SiteMapper(default_site_map,
use_cache=kwargs.pop('use_cache', False),
**_filter(kwargs, kwarg_list))
valid, mapped = sm.map_sites(stmts_in)
correctly_mapped_stmts = []
for ms in mapped:
correctly_mapped = all([mm.has_mapping() for mm in ms.mapped_mods])
if correctly_mapped:
correctly_mapped_stmts.append(ms.mapped_stmt)
stmts_out = valid + correctly_mapped_stmts
logger.info('%d statements with valid sites' % len(stmts_out))
dump_pkl = kwargs.get('save')
if dump_pkl:
dump_statements(stmts_out, dump_pkl)
del sm
return stmts_out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:filter_by_type; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:stmts_in; 5, identifier:stmt_type; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 19; 8, 39; 8, 74; 8, 86; 8, 95; 8, 104; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:invert; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:kwargs; 15, identifier:get; 16, argument_list; 16, 17; 16, 18; 17, string:'invert'; 18, False; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:logger; 23, identifier:info; 24, argument_list; 24, 25; 25, binary_operator:%; 25, 26; 25, 27; 26, string:'Filtering %d statements for type %s%s...'; 27, tuple; 27, 28; 27, 32; 27, 36; 28, call; 28, 29; 28, 30; 29, identifier:len; 30, argument_list; 30, 31; 31, identifier:stmts_in; 32, conditional_expression:if; 32, 33; 32, 34; 32, 35; 33, string:'not '; 34, identifier:invert; 35, string:''; 36, attribute; 36, 37; 36, 38; 37, identifier:stmt_type; 38, identifier:__name__; 39, if_statement; 39, 40; 39, 42; 39, 57; 40, not_operator; 40, 41; 41, identifier:invert; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:stmts_out; 46, list_comprehension; 46, 47; 46, 48; 46, 51; 47, identifier:st; 48, for_in_clause; 48, 49; 48, 50; 49, identifier:st; 50, identifier:stmts_in; 51, if_clause; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:isinstance; 54, argument_list; 54, 55; 54, 56; 55, identifier:st; 56, identifier:stmt_type; 57, else_clause; 57, 58; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:stmts_out; 62, list_comprehension; 62, 63; 62, 64; 62, 67; 63, identifier:st; 64, for_in_clause; 64, 65; 64, 66; 65, identifier:st; 66, identifier:stmts_in; 67, if_clause; 67, 68; 68, not_operator; 68, 69; 69, call; 69, 70; 69, 71; 70, identifier:isinstance; 71, argument_list; 71, 72; 71, 73; 72, identifier:st; 73, identifier:stmt_type; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:logger; 78, identifier:info; 79, argument_list; 79, 80; 80, binary_operator:%; 80, 81; 80, 82; 81, string:'%d statements after filter...'; 82, call; 82, 83; 82, 84; 83, identifier:len; 84, argument_list; 84, 85; 85, identifier:stmts_out; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:dump_pkl; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:kwargs; 92, identifier:get; 93, argument_list; 93, 94; 94, string:'save'; 95, if_statement; 95, 96; 95, 97; 96, identifier:dump_pkl; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:dump_statements; 101, argument_list; 101, 102; 101, 103; 102, identifier:stmts_out; 103, identifier:dump_pkl; 104, return_statement; 104, 105; 105, identifier:stmts_out | def filter_by_type(stmts_in, stmt_type, **kwargs):
invert = kwargs.get('invert', False)
logger.info('Filtering %d statements for type %s%s...' %
(len(stmts_in), 'not ' if invert else '',
stmt_type.__name__))
if not invert:
stmts_out = [st for st in stmts_in if isinstance(st, stmt_type)]
else:
stmts_out = [st for st in stmts_in if not isinstance(st, stmt_type)]
logger.info('%d statements after filter...' % len(stmts_out))
dump_pkl = kwargs.get('save')
if dump_pkl:
dump_statements(stmts_out, dump_pkl)
return stmts_out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:filter_grounded_only; 3, parameters; 3, 4; 3, 5; 4, identifier:stmts_in; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 18; 7, 30; 7, 34; 7, 43; 7, 127; 7, 139; 7, 148; 7, 157; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:remove_bound; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:kwargs; 14, identifier:get; 15, argument_list; 15, 16; 15, 17; 16, string:'remove_bound'; 17, False; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:logger; 22, identifier:info; 23, argument_list; 23, 24; 24, binary_operator:%; 24, 25; 24, 26; 25, string:'Filtering %d statements for grounded agents...'; 26, call; 26, 27; 26, 28; 27, identifier:len; 28, argument_list; 28, 29; 29, identifier:stmts_in; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:stmts_out; 33, list:[]; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:score_threshold; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:kwargs; 40, identifier:get; 41, argument_list; 41, 42; 42, string:'score_threshold'; 43, for_statement; 43, 44; 43, 45; 43, 46; 44, identifier:st; 45, identifier:stmts_in; 46, block; 46, 47; 46, 51; 46, 117; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:grounded; 50, True; 51, for_statement; 51, 52; 51, 53; 51, 58; 52, identifier:agent; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:st; 56, identifier:agent_list; 57, argument_list; 58, block; 58, 59; 59, if_statement; 59, 60; 59, 63; 60, comparison_operator:is; 60, 61; 60, 62; 61, identifier:agent; 62, None; 63, block; 63, 64; 63, 75; 63, 87; 63, 96; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:criterion; 67, lambda; 67, 68; 67, 70; 68, lambda_parameters; 68, 69; 69, identifier:x; 70, call; 70, 71; 70, 72; 71, identifier:_agent_is_grounded; 72, argument_list; 72, 73; 72, 74; 73, identifier:x; 74, identifier:score_threshold; 75, if_statement; 75, 76; 75, 81; 76, not_operator; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:criterion; 79, argument_list; 79, 80; 80, identifier:agent; 81, block; 81, 82; 81, 86; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:grounded; 85, False; 86, break_statement; 87, if_statement; 87, 88; 87, 94; 88, not_operator; 88, 89; 89, call; 89, 90; 89, 91; 90, identifier:isinstance; 91, argument_list; 91, 92; 91, 93; 92, identifier:agent; 93, identifier:Agent; 94, block; 94, 95; 95, continue_statement; 96, if_statement; 96, 97; 96, 98; 96, 105; 97, identifier:remove_bound; 98, block; 98, 99; 99, expression_statement; 99, 100; 100, call; 100, 101; 100, 102; 101, identifier:_remove_bound_conditions; 102, argument_list; 102, 103; 102, 104; 103, identifier:agent; 104, identifier:criterion; 105, elif_clause; 105, 106; 105, 111; 106, call; 106, 107; 106, 108; 107, identifier:_any_bound_condition_fails_criterion; 108, argument_list; 108, 109; 108, 110; 109, identifier:agent; 110, identifier:criterion; 111, block; 111, 112; 111, 116; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:grounded; 115, False; 116, break_statement; 117, if_statement; 117, 118; 117, 119; 118, identifier:grounded; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:stmts_out; 124, identifier:append; 125, argument_list; 125, 126; 126, identifier:st; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:logger; 131, identifier:info; 132, argument_list; 132, 133; 133, binary_operator:%; 133, 134; 133, 135; 134, string:'%d statements after filter...'; 135, call; 135, 136; 135, 137; 136, identifier:len; 137, argument_list; 137, 138; 138, identifier:stmts_out; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:dump_pkl; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:kwargs; 145, identifier:get; 146, argument_list; 146, 147; 147, string:'save'; 148, if_statement; 148, 149; 148, 150; 149, identifier:dump_pkl; 150, block; 150, 151; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 154; 153, identifier:dump_statements; 154, argument_list; 154, 155; 154, 156; 155, identifier:stmts_out; 156, identifier:dump_pkl; 157, return_statement; 157, 158; 158, identifier:stmts_out | def filter_grounded_only(stmts_in, **kwargs):
remove_bound = kwargs.get('remove_bound', False)
logger.info('Filtering %d statements for grounded agents...' %
len(stmts_in))
stmts_out = []
score_threshold = kwargs.get('score_threshold')
for st in stmts_in:
grounded = True
for agent in st.agent_list():
if agent is not None:
criterion = lambda x: _agent_is_grounded(x, score_threshold)
if not criterion(agent):
grounded = False
break
if not isinstance(agent, Agent):
continue
if remove_bound:
_remove_bound_conditions(agent, criterion)
elif _any_bound_condition_fails_criterion(agent, criterion):
grounded = False
break
if grounded:
stmts_out.append(st)
logger.info('%d statements after filter...' % len(stmts_out))
dump_pkl = kwargs.get('save')
if dump_pkl:
dump_statements(stmts_out, dump_pkl)
return stmts_out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:filter_genes_only; 3, parameters; 3, 4; 3, 5; 4, identifier:stmts_in; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 18; 7, 27; 7, 39; 7, 43; 7, 120; 7, 132; 7, 141; 7, 150; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:remove_bound; 11, boolean_operator:and; 11, 12; 11, 15; 12, comparison_operator:in; 12, 13; 12, 14; 13, string:'remove_bound'; 14, identifier:kwargs; 15, subscript; 15, 16; 15, 17; 16, identifier:kwargs; 17, string:'remove_bound'; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:specific_only; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:kwargs; 24, identifier:get; 25, argument_list; 25, 26; 26, string:'specific_only'; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:logger; 31, identifier:info; 32, argument_list; 32, 33; 33, binary_operator:%; 33, 34; 33, 35; 34, string:'Filtering %d statements for ones containing genes only...'; 35, call; 35, 36; 35, 37; 36, identifier:len; 37, argument_list; 37, 38; 38, identifier:stmts_in; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:stmts_out; 42, list:[]; 43, for_statement; 43, 44; 43, 45; 43, 46; 44, identifier:st; 45, identifier:stmts_in; 46, block; 46, 47; 46, 51; 46, 110; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:genes_only; 50, True; 51, for_statement; 51, 52; 51, 53; 51, 58; 52, identifier:agent; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:st; 56, identifier:agent_list; 57, argument_list; 58, block; 58, 59; 59, if_statement; 59, 60; 59, 63; 60, comparison_operator:is; 60, 61; 60, 62; 61, identifier:agent; 62, None; 63, block; 63, 64; 63, 75; 63, 87; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:criterion; 67, lambda; 67, 68; 67, 70; 68, lambda_parameters; 68, 69; 69, identifier:a; 70, call; 70, 71; 70, 72; 71, identifier:_agent_is_gene; 72, argument_list; 72, 73; 72, 74; 73, identifier:a; 74, identifier:specific_only; 75, if_statement; 75, 76; 75, 81; 76, not_operator; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:criterion; 79, argument_list; 79, 80; 80, identifier:agent; 81, block; 81, 82; 81, 86; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:genes_only; 85, False; 86, break_statement; 87, if_statement; 87, 88; 87, 89; 87, 96; 88, identifier:remove_bound; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:_remove_bound_conditions; 93, argument_list; 93, 94; 93, 95; 94, identifier:agent; 95, identifier:criterion; 96, else_clause; 96, 97; 97, block; 97, 98; 98, if_statement; 98, 99; 98, 104; 99, call; 99, 100; 99, 101; 100, identifier:_any_bound_condition_fails_criterion; 101, argument_list; 101, 102; 101, 103; 102, identifier:agent; 103, identifier:criterion; 104, block; 104, 105; 104, 109; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:genes_only; 108, False; 109, break_statement; 110, if_statement; 110, 111; 110, 112; 111, identifier:genes_only; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:stmts_out; 117, identifier:append; 118, argument_list; 118, 119; 119, identifier:st; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:logger; 124, identifier:info; 125, argument_list; 125, 126; 126, binary_operator:%; 126, 127; 126, 128; 127, string:'%d statements after filter...'; 128, call; 128, 129; 128, 130; 129, identifier:len; 130, argument_list; 130, 131; 131, identifier:stmts_out; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:dump_pkl; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:kwargs; 138, identifier:get; 139, argument_list; 139, 140; 140, string:'save'; 141, if_statement; 141, 142; 141, 143; 142, identifier:dump_pkl; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 147; 146, identifier:dump_statements; 147, argument_list; 147, 148; 147, 149; 148, identifier:stmts_out; 149, identifier:dump_pkl; 150, return_statement; 150, 151; 151, identifier:stmts_out | def filter_genes_only(stmts_in, **kwargs):
remove_bound = 'remove_bound' in kwargs and kwargs['remove_bound']
specific_only = kwargs.get('specific_only')
logger.info('Filtering %d statements for ones containing genes only...' %
len(stmts_in))
stmts_out = []
for st in stmts_in:
genes_only = True
for agent in st.agent_list():
if agent is not None:
criterion = lambda a: _agent_is_gene(a, specific_only)
if not criterion(agent):
genes_only = False
break
if remove_bound:
_remove_bound_conditions(agent, criterion)
else:
if _any_bound_condition_fails_criterion(agent, criterion):
genes_only = False
break
if genes_only:
stmts_out.append(st)
logger.info('%d statements after filter...' % len(stmts_out))
dump_pkl = kwargs.get('save')
if dump_pkl:
dump_statements(stmts_out, dump_pkl)
return stmts_out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:filter_gene_list; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 4, identifier:stmts_in; 5, identifier:gene_list; 6, identifier:policy; 7, default_parameter; 7, 8; 7, 9; 8, identifier:allow_families; 9, False; 10, dictionary_splat_pattern; 10, 11; 11, identifier:kwargs; 12, block; 12, 13; 12, 23; 12, 33; 12, 86; 12, 93; 12, 147; 12, 151; 12, 200; 12, 358; 12, 370; 12, 379; 12, 388; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:invert; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:kwargs; 19, identifier:get; 20, argument_list; 20, 21; 20, 22; 21, string:'invert'; 22, False; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:remove_bound; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:kwargs; 29, identifier:get; 30, argument_list; 30, 31; 30, 32; 31, string:'remove_bound'; 32, False; 33, if_statement; 33, 34; 33, 39; 33, 49; 34, comparison_operator:not; 34, 35; 34, 36; 35, identifier:policy; 36, tuple; 36, 37; 36, 38; 37, string:'one'; 38, string:'all'; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:logger; 44, identifier:error; 45, argument_list; 45, 46; 46, binary_operator:%; 46, 47; 46, 48; 47, string:'Policy %s is invalid, not applying filter.'; 48, identifier:policy; 49, else_clause; 49, 50; 50, block; 50, 51; 50, 60; 50, 67; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:genes_str; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, string:', '; 57, identifier:join; 58, argument_list; 58, 59; 59, identifier:gene_list; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:inv_str; 63, conditional_expression:if; 63, 64; 63, 65; 63, 66; 64, string:'not '; 65, identifier:invert; 66, string:''; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:logger; 71, identifier:info; 72, argument_list; 72, 73; 73, binary_operator:%; 73, 74; 73, 78; 74, parenthesized_expression; 74, 75; 75, concatenated_string; 75, 76; 75, 77; 76, string:'Filtering %d statements for ones %scontaining "%s" of: '; 77, string:'%s...'; 78, tuple; 78, 79; 78, 83; 78, 84; 78, 85; 79, call; 79, 80; 79, 81; 80, identifier:len; 81, argument_list; 81, 82; 82, identifier:stmts_in; 83, identifier:inv_str; 84, identifier:policy; 85, identifier:genes_str; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:filter_list; 89, call; 89, 90; 89, 91; 90, identifier:copy; 91, argument_list; 91, 92; 92, identifier:gene_list; 93, if_statement; 93, 94; 93, 95; 94, identifier:allow_families; 95, block; 95, 96; 96, for_statement; 96, 97; 96, 98; 96, 99; 97, identifier:hgnc_name; 98, identifier:gene_list; 99, block; 99, 100; 99, 112; 99, 123; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:gene_uri; 103, call; 103, 104; 103, 109; 104, attribute; 104, 105; 104, 108; 105, subscript; 105, 106; 105, 107; 106, identifier:hierarchies; 107, string:'entity'; 108, identifier:get_uri; 109, argument_list; 109, 110; 109, 111; 110, string:'HGNC'; 111, identifier:hgnc_name; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:parents; 115, call; 115, 116; 115, 121; 116, attribute; 116, 117; 116, 120; 117, subscript; 117, 118; 117, 119; 118, identifier:hierarchies; 119, string:'entity'; 120, identifier:get_parents; 121, argument_list; 121, 122; 122, identifier:gene_uri; 123, for_statement; 123, 124; 123, 125; 123, 126; 124, identifier:par_uri; 125, identifier:parents; 126, block; 126, 127; 126, 140; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 132; 129, pattern_list; 129, 130; 129, 131; 130, identifier:ns; 131, identifier:id; 132, call; 132, 133; 132, 138; 133, attribute; 133, 134; 133, 137; 134, subscript; 134, 135; 134, 136; 135, identifier:hierarchies; 136, string:'entity'; 137, identifier:ns_id_from_uri; 138, argument_list; 138, 139; 139, identifier:par_uri; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:filter_list; 144, identifier:append; 145, argument_list; 145, 146; 146, identifier:id; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:stmts_out; 150, list:[]; 151, if_statement; 151, 152; 151, 153; 152, identifier:remove_bound; 153, block; 153, 154; 153, 182; 154, if_statement; 154, 155; 154, 157; 154, 169; 155, not_operator; 155, 156; 156, identifier:invert; 157, block; 157, 158; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:keep_criterion; 161, lambda; 161, 162; 161, 164; 162, lambda_parameters; 162, 163; 163, identifier:a; 164, comparison_operator:in; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:a; 167, identifier:name; 168, identifier:filter_list; 169, else_clause; 169, 170; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:keep_criterion; 174, lambda; 174, 175; 174, 177; 175, lambda_parameters; 175, 176; 176, identifier:a; 177, comparison_operator:not; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:a; 180, identifier:name; 181, identifier:filter_list; 182, for_statement; 182, 183; 182, 184; 182, 185; 183, identifier:st; 184, identifier:stmts_in; 185, block; 185, 186; 186, for_statement; 186, 187; 186, 188; 186, 193; 187, identifier:agent; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:st; 191, identifier:agent_list; 192, argument_list; 193, block; 193, 194; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 197; 196, identifier:_remove_bound_conditions; 197, argument_list; 197, 198; 197, 199; 198, identifier:agent; 199, identifier:keep_criterion; 200, if_statement; 200, 201; 200, 204; 200, 276; 200, 352; 201, comparison_operator:==; 201, 202; 201, 203; 202, identifier:policy; 203, string:'one'; 204, block; 204, 205; 205, for_statement; 205, 206; 205, 207; 205, 208; 206, identifier:st; 207, identifier:stmts_in; 208, block; 208, 209; 208, 213; 208, 235; 208, 256; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:found_gene; 212, False; 213, if_statement; 213, 214; 213, 216; 213, 225; 214, not_operator; 214, 215; 215, identifier:remove_bound; 216, block; 216, 217; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:agent_list; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:st; 223, identifier:agent_list_with_bound_condition_agents; 224, argument_list; 225, else_clause; 225, 226; 226, block; 226, 227; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:agent_list; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:st; 233, identifier:agent_list; 234, argument_list; 235, for_statement; 235, 236; 235, 237; 235, 238; 236, identifier:agent; 237, identifier:agent_list; 238, block; 238, 239; 239, if_statement; 239, 240; 239, 243; 240, comparison_operator:is; 240, 241; 240, 242; 241, identifier:agent; 242, None; 243, block; 243, 244; 244, if_statement; 244, 245; 244, 250; 245, comparison_operator:in; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:agent; 248, identifier:name; 249, identifier:filter_list; 250, block; 250, 251; 250, 255; 251, expression_statement; 251, 252; 252, assignment; 252, 253; 252, 254; 253, identifier:found_gene; 254, True; 255, break_statement; 256, if_statement; 256, 257; 256, 268; 257, boolean_operator:or; 257, 258; 257, 263; 258, parenthesized_expression; 258, 259; 259, boolean_operator:and; 259, 260; 259, 261; 260, identifier:found_gene; 261, not_operator; 261, 262; 262, identifier:invert; 263, parenthesized_expression; 263, 264; 264, boolean_operator:and; 264, 265; 264, 267; 265, not_operator; 265, 266; 266, identifier:found_gene; 267, identifier:invert; 268, block; 268, 269; 269, expression_statement; 269, 270; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:stmts_out; 273, identifier:append; 274, argument_list; 274, 275; 275, identifier:st; 276, elif_clause; 276, 277; 276, 280; 277, comparison_operator:==; 277, 278; 277, 279; 278, identifier:policy; 279, string:'all'; 280, block; 280, 281; 281, for_statement; 281, 282; 281, 283; 281, 284; 282, identifier:st; 283, identifier:stmts_in; 284, block; 284, 285; 284, 289; 284, 311; 284, 332; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:found_genes; 288, True; 289, if_statement; 289, 290; 289, 292; 289, 301; 290, not_operator; 290, 291; 291, identifier:remove_bound; 292, block; 292, 293; 293, expression_statement; 293, 294; 294, assignment; 294, 295; 294, 296; 295, identifier:agent_list; 296, call; 296, 297; 296, 300; 297, attribute; 297, 298; 297, 299; 298, identifier:st; 299, identifier:agent_list_with_bound_condition_agents; 300, argument_list; 301, else_clause; 301, 302; 302, block; 302, 303; 303, expression_statement; 303, 304; 304, assignment; 304, 305; 304, 306; 305, identifier:agent_list; 306, call; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:st; 309, identifier:agent_list; 310, argument_list; 311, for_statement; 311, 312; 311, 313; 311, 314; 312, identifier:agent; 313, identifier:agent_list; 314, block; 314, 315; 315, if_statement; 315, 316; 315, 319; 316, comparison_operator:is; 316, 317; 316, 318; 317, identifier:agent; 318, None; 319, block; 319, 320; 320, if_statement; 320, 321; 320, 326; 321, comparison_operator:not; 321, 322; 321, 325; 322, attribute; 322, 323; 322, 324; 323, identifier:agent; 324, identifier:name; 325, identifier:filter_list; 326, block; 326, 327; 326, 331; 327, expression_statement; 327, 328; 328, assignment; 328, 329; 328, 330; 329, identifier:found_genes; 330, False; 331, break_statement; 332, if_statement; 332, 333; 332, 344; 333, boolean_operator:or; 333, 334; 333, 339; 334, parenthesized_expression; 334, 335; 335, boolean_operator:and; 335, 336; 335, 337; 336, identifier:found_genes; 337, not_operator; 337, 338; 338, identifier:invert; 339, parenthesized_expression; 339, 340; 340, boolean_operator:and; 340, 341; 340, 343; 341, not_operator; 341, 342; 342, identifier:found_genes; 343, identifier:invert; 344, block; 344, 345; 345, expression_statement; 345, 346; 346, call; 346, 347; 346, 350; 347, attribute; 347, 348; 347, 349; 348, identifier:stmts_out; 349, identifier:append; 350, argument_list; 350, 351; 351, identifier:st; 352, else_clause; 352, 353; 353, block; 353, 354; 354, expression_statement; 354, 355; 355, assignment; 355, 356; 355, 357; 356, identifier:stmts_out; 357, identifier:stmts_in; 358, expression_statement; 358, 359; 359, call; 359, 360; 359, 363; 360, attribute; 360, 361; 360, 362; 361, identifier:logger; 362, identifier:info; 363, argument_list; 363, 364; 364, binary_operator:%; 364, 365; 364, 366; 365, string:'%d statements after filter...'; 366, call; 366, 367; 366, 368; 367, identifier:len; 368, argument_list; 368, 369; 369, identifier:stmts_out; 370, expression_statement; 370, 371; 371, assignment; 371, 372; 371, 373; 372, identifier:dump_pkl; 373, call; 373, 374; 373, 377; 374, attribute; 374, 375; 374, 376; 375, identifier:kwargs; 376, identifier:get; 377, argument_list; 377, 378; 378, string:'save'; 379, if_statement; 379, 380; 379, 381; 380, identifier:dump_pkl; 381, block; 381, 382; 382, expression_statement; 382, 383; 383, call; 383, 384; 383, 385; 384, identifier:dump_statements; 385, argument_list; 385, 386; 385, 387; 386, identifier:stmts_out; 387, identifier:dump_pkl; 388, return_statement; 388, 389; 389, identifier:stmts_out | def filter_gene_list(stmts_in, gene_list, policy, allow_families=False,
**kwargs):
invert = kwargs.get('invert', False)
remove_bound = kwargs.get('remove_bound', False)
if policy not in ('one', 'all'):
logger.error('Policy %s is invalid, not applying filter.' % policy)
else:
genes_str = ', '.join(gene_list)
inv_str = 'not ' if invert else ''
logger.info(('Filtering %d statements for ones %scontaining "%s" of: '
'%s...') % (len(stmts_in), inv_str, policy, genes_str))
filter_list = copy(gene_list)
if allow_families:
for hgnc_name in gene_list:
gene_uri = hierarchies['entity'].get_uri('HGNC', hgnc_name)
parents = hierarchies['entity'].get_parents(gene_uri)
for par_uri in parents:
ns, id = hierarchies['entity'].ns_id_from_uri(par_uri)
filter_list.append(id)
stmts_out = []
if remove_bound:
if not invert:
keep_criterion = lambda a: a.name in filter_list
else:
keep_criterion = lambda a: a.name not in filter_list
for st in stmts_in:
for agent in st.agent_list():
_remove_bound_conditions(agent, keep_criterion)
if policy == 'one':
for st in stmts_in:
found_gene = False
if not remove_bound:
agent_list = st.agent_list_with_bound_condition_agents()
else:
agent_list = st.agent_list()
for agent in agent_list:
if agent is not None:
if agent.name in filter_list:
found_gene = True
break
if (found_gene and not invert) or (not found_gene and invert):
stmts_out.append(st)
elif policy == 'all':
for st in stmts_in:
found_genes = True
if not remove_bound:
agent_list = st.agent_list_with_bound_condition_agents()
else:
agent_list = st.agent_list()
for agent in agent_list:
if agent is not None:
if agent.name not in filter_list:
found_genes = False
break
if (found_genes and not invert) or (not found_genes and invert):
stmts_out.append(st)
else:
stmts_out = stmts_in
logger.info('%d statements after filter...' % len(stmts_out))
dump_pkl = kwargs.get('save')
if dump_pkl:
dump_statements(stmts_out, dump_pkl)
return stmts_out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:filter_by_db_refs; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:stmts_in; 5, identifier:namespace; 6, identifier:values; 7, identifier:policy; 8, dictionary_splat_pattern; 8, 9; 9, identifier:kwargs; 10, block; 10, 11; 10, 21; 10, 31; 10, 86; 10, 170; 10, 179; 10, 207; 10, 219; 10, 228; 10, 237; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:invert; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:kwargs; 17, identifier:get; 18, argument_list; 18, 19; 18, 20; 19, string:'invert'; 20, False; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:match_suffix; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:kwargs; 27, identifier:get; 28, argument_list; 28, 29; 28, 30; 29, string:'match_suffix'; 30, False; 31, if_statement; 31, 32; 31, 37; 31, 48; 32, comparison_operator:not; 32, 33; 32, 34; 33, identifier:policy; 34, tuple; 34, 35; 34, 36; 35, string:'one'; 36, string:'all'; 37, block; 37, 38; 37, 47; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:logger; 42, identifier:error; 43, argument_list; 43, 44; 44, binary_operator:%; 44, 45; 44, 46; 45, string:'Policy %s is invalid, not applying filter.'; 46, identifier:policy; 47, return_statement; 48, else_clause; 48, 49; 49, block; 49, 50; 49, 59; 49, 66; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:name_str; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, string:', '; 56, identifier:join; 57, argument_list; 57, 58; 58, identifier:values; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:rev_mod; 62, conditional_expression:if; 62, 63; 62, 64; 62, 65; 63, string:'not '; 64, identifier:invert; 65, string:''; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:logger; 70, identifier:info; 71, argument_list; 71, 72; 72, binary_operator:%; 72, 73; 72, 77; 73, parenthesized_expression; 73, 74; 74, concatenated_string; 74, 75; 74, 76; 75, string:'Filtering %d statements for those with %s agents %s'; 76, string:'grounded to: %s in the %s namespace...'; 77, tuple; 77, 78; 77, 82; 77, 83; 77, 84; 77, 85; 78, call; 78, 79; 78, 80; 79, identifier:len; 80, argument_list; 80, 81; 81, identifier:stmts_in; 82, identifier:policy; 83, identifier:rev_mod; 84, identifier:name_str; 85, identifier:namespace; 86, function_definition; 86, 87; 86, 88; 86, 90; 87, function_name:meets_criterion; 88, parameters; 88, 89; 89, identifier:agent; 90, block; 90, 91; 90, 100; 90, 108; 90, 123; 90, 127; 90, 160; 91, if_statement; 91, 92; 91, 97; 92, comparison_operator:not; 92, 93; 92, 94; 93, identifier:namespace; 94, attribute; 94, 95; 94, 96; 95, identifier:agent; 96, identifier:db_refs; 97, block; 97, 98; 98, return_statement; 98, 99; 99, False; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:entry; 103, subscript; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:agent; 106, identifier:db_refs; 107, identifier:namespace; 108, if_statement; 108, 109; 108, 114; 109, call; 109, 110; 109, 111; 110, identifier:isinstance; 111, argument_list; 111, 112; 111, 113; 112, identifier:entry; 113, identifier:list; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:entry; 118, subscript; 118, 119; 118, 122; 119, subscript; 119, 120; 119, 121; 120, identifier:entry; 121, integer:0; 122, integer:0; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:ret; 126, False; 127, if_statement; 127, 128; 127, 129; 127, 149; 128, identifier:match_suffix; 129, block; 129, 130; 130, if_statement; 130, 131; 130, 144; 131, call; 131, 132; 131, 133; 132, identifier:any; 133, argument_list; 133, 134; 134, list_comprehension; 134, 135; 134, 141; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:entry; 138, identifier:endswith; 139, argument_list; 139, 140; 140, identifier:e; 141, for_in_clause; 141, 142; 141, 143; 142, identifier:e; 143, identifier:values; 144, block; 144, 145; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:ret; 148, True; 149, else_clause; 149, 150; 150, block; 150, 151; 151, if_statement; 151, 152; 151, 155; 152, comparison_operator:in; 152, 153; 152, 154; 153, identifier:entry; 154, identifier:values; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:ret; 159, True; 160, if_statement; 160, 161; 160, 162; 160, 166; 161, identifier:invert; 162, block; 162, 163; 163, return_statement; 163, 164; 164, not_operator; 164, 165; 165, identifier:ret; 166, else_clause; 166, 167; 167, block; 167, 168; 168, return_statement; 168, 169; 169, identifier:ret; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:enough; 173, conditional_expression:if; 173, 174; 173, 175; 173, 178; 174, identifier:all; 175, comparison_operator:==; 175, 176; 175, 177; 176, identifier:policy; 177, string:'all'; 178, identifier:any; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:stmts_out; 182, list_comprehension; 182, 183; 182, 184; 182, 187; 183, identifier:s; 184, for_in_clause; 184, 185; 184, 186; 185, identifier:s; 186, identifier:stmts_in; 187, if_clause; 187, 188; 188, call; 188, 189; 188, 190; 189, identifier:enough; 190, argument_list; 190, 191; 191, list_comprehension; 191, 192; 191, 196; 191, 203; 192, call; 192, 193; 192, 194; 193, identifier:meets_criterion; 194, argument_list; 194, 195; 195, identifier:ag; 196, for_in_clause; 196, 197; 196, 198; 197, identifier:ag; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:s; 201, identifier:agent_list; 202, argument_list; 203, if_clause; 203, 204; 204, comparison_operator:is; 204, 205; 204, 206; 205, identifier:ag; 206, None; 207, expression_statement; 207, 208; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:logger; 211, identifier:info; 212, argument_list; 212, 213; 213, binary_operator:%; 213, 214; 213, 215; 214, string:'%d Statements after filter...'; 215, call; 215, 216; 215, 217; 216, identifier:len; 217, argument_list; 217, 218; 218, identifier:stmts_out; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:dump_pkl; 222, call; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:kwargs; 225, identifier:get; 226, argument_list; 226, 227; 227, string:'save'; 228, if_statement; 228, 229; 228, 230; 229, identifier:dump_pkl; 230, block; 230, 231; 231, expression_statement; 231, 232; 232, call; 232, 233; 232, 234; 233, identifier:dump_statements; 234, argument_list; 234, 235; 234, 236; 235, identifier:stmts_out; 236, identifier:dump_pkl; 237, return_statement; 237, 238; 238, identifier:stmts_out | def filter_by_db_refs(stmts_in, namespace, values, policy, **kwargs):
invert = kwargs.get('invert', False)
match_suffix = kwargs.get('match_suffix', False)
if policy not in ('one', 'all'):
logger.error('Policy %s is invalid, not applying filter.' % policy)
return
else:
name_str = ', '.join(values)
rev_mod = 'not ' if invert else ''
logger.info(('Filtering %d statements for those with %s agents %s'
'grounded to: %s in the %s namespace...') %
(len(stmts_in), policy, rev_mod, name_str, namespace))
def meets_criterion(agent):
if namespace not in agent.db_refs:
return False
entry = agent.db_refs[namespace]
if isinstance(entry, list):
entry = entry[0][0]
ret = False
if match_suffix:
if any([entry.endswith(e) for e in values]):
ret = True
else:
if entry in values:
ret = True
if invert:
return not ret
else:
return ret
enough = all if policy == 'all' else any
stmts_out = [s for s in stmts_in
if enough([meets_criterion(ag) for ag in s.agent_list()
if ag is not None])]
logger.info('%d Statements after filter...' % len(stmts_out))
dump_pkl = kwargs.get('save')
if dump_pkl:
dump_statements(stmts_out, dump_pkl)
return stmts_out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:filter_human_only; 3, parameters; 3, 4; 3, 5; 4, identifier:stmts_in; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 14; 7, 33; 7, 42; 7, 54; 7, 58; 7, 91; 7, 155; 7, 167; 7, 176; 8, import_from_statement; 8, 9; 8, 12; 9, dotted_name; 9, 10; 9, 11; 10, identifier:indra; 11, identifier:databases; 12, dotted_name; 12, 13; 13, identifier:uniprot_client; 14, if_statement; 14, 15; 14, 22; 14, 27; 15, boolean_operator:and; 15, 16; 15, 19; 16, comparison_operator:in; 16, 17; 16, 18; 17, string:'remove_bound'; 18, identifier:kwargs; 19, subscript; 19, 20; 19, 21; 20, identifier:kwargs; 21, string:'remove_bound'; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:remove_bound; 26, True; 27, else_clause; 27, 28; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:remove_bound; 32, False; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:dump_pkl; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:kwargs; 39, identifier:get; 40, argument_list; 40, 41; 41, string:'save'; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:logger; 46, identifier:info; 47, argument_list; 47, 48; 48, binary_operator:%; 48, 49; 48, 50; 49, string:'Filtering %d statements for human genes only...'; 50, call; 50, 51; 50, 52; 51, identifier:len; 52, argument_list; 52, 53; 53, identifier:stmts_in; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:stmts_out; 57, list:[]; 58, function_definition; 58, 59; 58, 60; 58, 62; 59, function_name:criterion; 60, parameters; 60, 61; 61, identifier:agent; 62, block; 62, 63; 62, 74; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:upid; 66, call; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:agent; 70, identifier:db_refs; 71, identifier:get; 72, argument_list; 72, 73; 73, string:'UP'; 74, if_statement; 74, 75; 74, 84; 74, 87; 75, boolean_operator:and; 75, 76; 75, 77; 76, identifier:upid; 77, not_operator; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:uniprot_client; 81, identifier:is_human; 82, argument_list; 82, 83; 83, identifier:upid; 84, block; 84, 85; 85, return_statement; 85, 86; 86, False; 87, else_clause; 87, 88; 88, block; 88, 89; 89, return_statement; 89, 90; 90, True; 91, for_statement; 91, 92; 91, 93; 91, 94; 92, identifier:st; 93, identifier:stmts_in; 94, block; 94, 95; 94, 99; 94, 145; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:human_genes; 98, True; 99, for_statement; 99, 100; 99, 101; 99, 106; 100, identifier:agent; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:st; 104, identifier:agent_list; 105, argument_list; 106, block; 106, 107; 107, if_statement; 107, 108; 107, 111; 108, comparison_operator:is; 108, 109; 108, 110; 109, identifier:agent; 110, None; 111, block; 111, 112; 111, 124; 112, if_statement; 112, 113; 112, 118; 113, not_operator; 113, 114; 114, call; 114, 115; 114, 116; 115, identifier:criterion; 116, argument_list; 116, 117; 117, identifier:agent; 118, block; 118, 119; 118, 123; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:human_genes; 122, False; 123, break_statement; 124, if_statement; 124, 125; 124, 126; 124, 133; 125, identifier:remove_bound; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 130; 129, identifier:_remove_bound_conditions; 130, argument_list; 130, 131; 130, 132; 131, identifier:agent; 132, identifier:criterion; 133, elif_clause; 133, 134; 133, 139; 134, call; 134, 135; 134, 136; 135, identifier:_any_bound_condition_fails_criterion; 136, argument_list; 136, 137; 136, 138; 137, identifier:agent; 138, identifier:criterion; 139, block; 139, 140; 139, 144; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:human_genes; 143, False; 144, break_statement; 145, if_statement; 145, 146; 145, 147; 146, identifier:human_genes; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:stmts_out; 152, identifier:append; 153, argument_list; 153, 154; 154, identifier:st; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:logger; 159, identifier:info; 160, argument_list; 160, 161; 161, binary_operator:%; 161, 162; 161, 163; 162, string:'%d statements after filter...'; 163, call; 163, 164; 163, 165; 164, identifier:len; 165, argument_list; 165, 166; 166, identifier:stmts_out; 167, if_statement; 167, 168; 167, 169; 168, identifier:dump_pkl; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 173; 172, identifier:dump_statements; 173, argument_list; 173, 174; 173, 175; 174, identifier:stmts_out; 175, identifier:dump_pkl; 176, return_statement; 176, 177; 177, identifier:stmts_out | def filter_human_only(stmts_in, **kwargs):
from indra.databases import uniprot_client
if 'remove_bound' in kwargs and kwargs['remove_bound']:
remove_bound = True
else:
remove_bound = False
dump_pkl = kwargs.get('save')
logger.info('Filtering %d statements for human genes only...' %
len(stmts_in))
stmts_out = []
def criterion(agent):
upid = agent.db_refs.get('UP')
if upid and not uniprot_client.is_human(upid):
return False
else:
return True
for st in stmts_in:
human_genes = True
for agent in st.agent_list():
if agent is not None:
if not criterion(agent):
human_genes = False
break
if remove_bound:
_remove_bound_conditions(agent, criterion)
elif _any_bound_condition_fails_criterion(agent, criterion):
human_genes = False
break
if human_genes:
stmts_out.append(st)
logger.info('%d statements after filter...' % len(stmts_out))
if dump_pkl:
dump_statements(stmts_out, dump_pkl)
return stmts_out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:filter_direct; 3, parameters; 3, 4; 3, 5; 4, identifier:stmts_in; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 60; 7, 72; 7, 76; 7, 93; 7, 105; 7, 114; 7, 123; 8, function_definition; 8, 9; 8, 10; 8, 12; 9, function_name:get_is_direct; 10, parameters; 10, 11; 11, identifier:stmt; 12, block; 12, 13; 12, 17; 12, 53; 12, 58; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:any_indirect; 16, False; 17, for_statement; 17, 18; 17, 19; 17, 22; 18, identifier:ev; 19, attribute; 19, 20; 19, 21; 20, identifier:stmt; 21, identifier:evidence; 22, block; 22, 23; 23, if_statement; 23, 24; 23, 34; 23, 37; 24, comparison_operator:is; 24, 25; 24, 33; 25, call; 25, 26; 25, 31; 26, attribute; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:ev; 29, identifier:epistemics; 30, identifier:get; 31, argument_list; 31, 32; 32, string:'direct'; 33, True; 34, block; 34, 35; 35, return_statement; 35, 36; 36, True; 37, elif_clause; 37, 38; 37, 48; 38, comparison_operator:is; 38, 39; 38, 47; 39, call; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:ev; 43, identifier:epistemics; 44, identifier:get; 45, argument_list; 45, 46; 46, string:'direct'; 47, False; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:any_indirect; 52, True; 53, if_statement; 53, 54; 53, 55; 54, identifier:any_indirect; 55, block; 55, 56; 56, return_statement; 56, 57; 57, False; 58, return_statement; 58, 59; 59, True; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:logger; 64, identifier:info; 65, argument_list; 65, 66; 66, binary_operator:%; 66, 67; 66, 68; 67, string:'Filtering %d statements to direct ones...'; 68, call; 68, 69; 68, 70; 69, identifier:len; 70, argument_list; 70, 71; 71, identifier:stmts_in; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:stmts_out; 75, list:[]; 76, for_statement; 76, 77; 76, 78; 76, 79; 77, identifier:st; 78, identifier:stmts_in; 79, block; 79, 80; 80, if_statement; 80, 81; 80, 85; 81, call; 81, 82; 81, 83; 82, identifier:get_is_direct; 83, argument_list; 83, 84; 84, identifier:st; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:stmts_out; 90, identifier:append; 91, argument_list; 91, 92; 92, identifier:st; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:logger; 97, identifier:info; 98, argument_list; 98, 99; 99, binary_operator:%; 99, 100; 99, 101; 100, string:'%d statements after filter...'; 101, call; 101, 102; 101, 103; 102, identifier:len; 103, argument_list; 103, 104; 104, identifier:stmts_out; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:dump_pkl; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:kwargs; 111, identifier:get; 112, argument_list; 112, 113; 113, string:'save'; 114, if_statement; 114, 115; 114, 116; 115, identifier:dump_pkl; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, call; 118, 119; 118, 120; 119, identifier:dump_statements; 120, argument_list; 120, 121; 120, 122; 121, identifier:stmts_out; 122, identifier:dump_pkl; 123, return_statement; 123, 124; 124, identifier:stmts_out | def filter_direct(stmts_in, **kwargs):
def get_is_direct(stmt):
any_indirect = False
for ev in stmt.evidence:
if ev.epistemics.get('direct') is True:
return True
elif ev.epistemics.get('direct') is False:
any_indirect = True
if any_indirect:
return False
return True
logger.info('Filtering %d statements to direct ones...' % len(stmts_in))
stmts_out = []
for st in stmts_in:
if get_is_direct(st):
stmts_out.append(st)
logger.info('%d statements after filter...' % len(stmts_out))
dump_pkl = kwargs.get('save')
if dump_pkl:
dump_statements(stmts_out, dump_pkl)
return stmts_out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:filter_evidence_source; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:stmts_in; 5, identifier:source_apis; 6, default_parameter; 6, 7; 6, 8; 7, identifier:policy; 8, string:'one'; 9, dictionary_splat_pattern; 9, 10; 10, identifier:kwargs; 11, block; 11, 12; 11, 32; 11, 36; 11, 121; 11, 133; 11, 142; 11, 151; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:logger; 16, identifier:info; 17, argument_list; 17, 18; 18, binary_operator:%; 18, 19; 18, 20; 19, string:'Filtering %d statements to evidence source "%s" of: %s...'; 20, tuple; 20, 21; 20, 25; 20, 26; 21, call; 21, 22; 21, 23; 22, identifier:len; 23, argument_list; 23, 24; 24, identifier:stmts_in; 25, identifier:policy; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, string:', '; 29, identifier:join; 30, argument_list; 30, 31; 31, identifier:source_apis; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:stmts_out; 35, list:[]; 36, for_statement; 36, 37; 36, 38; 36, 39; 37, identifier:st; 38, identifier:stmts_in; 39, block; 39, 40; 39, 55; 39, 75; 39, 100; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:sources; 43, call; 43, 44; 43, 45; 44, identifier:set; 45, argument_list; 45, 46; 46, list_comprehension; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:ev; 49, identifier:source_api; 50, for_in_clause; 50, 51; 50, 52; 51, identifier:ev; 52, attribute; 52, 53; 52, 54; 53, identifier:st; 54, identifier:evidence; 55, if_statement; 55, 56; 55, 59; 56, comparison_operator:==; 56, 57; 56, 58; 57, identifier:policy; 58, string:'one'; 59, block; 59, 60; 60, if_statement; 60, 61; 60, 67; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:sources; 64, identifier:intersection; 65, argument_list; 65, 66; 66, identifier:source_apis; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:stmts_out; 72, identifier:append; 73, argument_list; 73, 74; 74, identifier:st; 75, if_statement; 75, 76; 75, 79; 76, comparison_operator:==; 76, 77; 76, 78; 77, identifier:policy; 78, string:'all'; 79, block; 79, 80; 80, if_statement; 80, 81; 80, 92; 81, comparison_operator:==; 81, 82; 81, 88; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:sources; 85, identifier:intersection; 86, argument_list; 86, 87; 87, identifier:source_apis; 88, call; 88, 89; 88, 90; 89, identifier:set; 90, argument_list; 90, 91; 91, identifier:source_apis; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:stmts_out; 97, identifier:append; 98, argument_list; 98, 99; 99, identifier:st; 100, if_statement; 100, 101; 100, 104; 101, comparison_operator:==; 101, 102; 101, 103; 102, identifier:policy; 103, string:'none'; 104, block; 104, 105; 105, if_statement; 105, 106; 105, 113; 106, not_operator; 106, 107; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:sources; 110, identifier:intersection; 111, argument_list; 111, 112; 112, identifier:source_apis; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:stmts_out; 118, identifier:append; 119, argument_list; 119, 120; 120, identifier:st; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:logger; 125, identifier:info; 126, argument_list; 126, 127; 127, binary_operator:%; 127, 128; 127, 129; 128, string:'%d statements after filter...'; 129, call; 129, 130; 129, 131; 130, identifier:len; 131, argument_list; 131, 132; 132, identifier:stmts_out; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:dump_pkl; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:kwargs; 139, identifier:get; 140, argument_list; 140, 141; 141, string:'save'; 142, if_statement; 142, 143; 142, 144; 143, identifier:dump_pkl; 144, block; 144, 145; 145, expression_statement; 145, 146; 146, call; 146, 147; 146, 148; 147, identifier:dump_statements; 148, argument_list; 148, 149; 148, 150; 149, identifier:stmts_out; 150, identifier:dump_pkl; 151, return_statement; 151, 152; 152, identifier:stmts_out | def filter_evidence_source(stmts_in, source_apis, policy='one', **kwargs):
logger.info('Filtering %d statements to evidence source "%s" of: %s...' %
(len(stmts_in), policy, ', '.join(source_apis)))
stmts_out = []
for st in stmts_in:
sources = set([ev.source_api for ev in st.evidence])
if policy == 'one':
if sources.intersection(source_apis):
stmts_out.append(st)
if policy == 'all':
if sources.intersection(source_apis) == set(source_apis):
stmts_out.append(st)
if policy == 'none':
if not sources.intersection(source_apis):
stmts_out.append(st)
logger.info('%d statements after filter...' % len(stmts_out))
dump_pkl = kwargs.get('save')
if dump_pkl:
dump_statements(stmts_out, dump_pkl)
return stmts_out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:filter_inconsequential_mods; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:stmts_in; 5, default_parameter; 5, 6; 5, 7; 6, identifier:whitelist; 7, None; 8, dictionary_splat_pattern; 8, 9; 9, identifier:kwargs; 10, block; 10, 11; 10, 20; 10, 34; 10, 38; 10, 104; 10, 126; 10, 130; 10, 211; 10, 223; 10, 232; 10, 241; 11, if_statement; 11, 12; 11, 15; 12, comparison_operator:is; 12, 13; 12, 14; 13, identifier:whitelist; 14, None; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:whitelist; 19, dictionary; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:logger; 24, identifier:info; 25, argument_list; 25, 26; 26, binary_operator:+; 26, 27; 26, 33; 27, binary_operator:%; 27, 28; 27, 29; 28, string:'Filtering %d statements to remove'; 29, call; 29, 30; 29, 31; 30, identifier:len; 31, argument_list; 31, 32; 32, identifier:stmts_in; 33, string:' inconsequential modifications...'; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:states_used; 37, identifier:whitelist; 38, for_statement; 38, 39; 38, 40; 38, 41; 39, identifier:stmt; 40, identifier:stmts_in; 41, block; 41, 42; 42, for_statement; 42, 43; 42, 44; 42, 49; 43, identifier:agent; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:stmt; 47, identifier:agent_list; 48, argument_list; 49, block; 49, 50; 50, if_statement; 50, 51; 50, 54; 51, comparison_operator:is; 51, 52; 51, 53; 52, identifier:agent; 53, None; 54, block; 54, 55; 55, if_statement; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:agent; 58, identifier:mods; 59, block; 59, 60; 60, for_statement; 60, 61; 60, 62; 60, 65; 61, identifier:mc; 62, attribute; 62, 63; 62, 64; 63, identifier:agent; 64, identifier:mods; 65, block; 65, 66; 65, 79; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:mod; 69, tuple; 69, 70; 69, 73; 69, 76; 70, attribute; 70, 71; 70, 72; 71, identifier:mc; 72, identifier:mod_type; 73, attribute; 73, 74; 73, 75; 74, identifier:mc; 75, identifier:residue; 76, attribute; 76, 77; 76, 78; 77, identifier:mc; 78, identifier:position; 79, try_statement; 79, 80; 79, 92; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, call; 82, 83; 82, 90; 83, attribute; 83, 84; 83, 89; 84, subscript; 84, 85; 84, 86; 85, identifier:states_used; 86, attribute; 86, 87; 86, 88; 87, identifier:agent; 88, identifier:name; 89, identifier:append; 90, argument_list; 90, 91; 91, identifier:mod; 92, except_clause; 92, 93; 92, 94; 93, identifier:KeyError; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 102; 97, subscript; 97, 98; 97, 99; 98, identifier:states_used; 99, attribute; 99, 100; 99, 101; 100, identifier:agent; 101, identifier:name; 102, list:[mod]; 102, 103; 103, identifier:mod; 104, for_statement; 104, 105; 104, 108; 104, 113; 105, pattern_list; 105, 106; 105, 107; 106, identifier:k; 107, identifier:v; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:states_used; 111, identifier:items; 112, argument_list; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 119; 116, subscript; 116, 117; 116, 118; 117, identifier:states_used; 118, identifier:k; 119, call; 119, 120; 119, 121; 120, identifier:list; 121, argument_list; 121, 122; 122, call; 122, 123; 122, 124; 123, identifier:set; 124, argument_list; 124, 125; 125, identifier:v; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:stmts_out; 129, list:[]; 130, for_statement; 130, 131; 130, 132; 130, 133; 131, identifier:stmt; 132, identifier:stmts_in; 133, block; 133, 134; 133, 138; 133, 200; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:skip; 137, False; 138, if_statement; 138, 139; 138, 144; 139, call; 139, 140; 139, 141; 140, identifier:isinstance; 141, argument_list; 141, 142; 141, 143; 142, identifier:stmt; 143, identifier:Modification; 144, block; 144, 145; 144, 153; 144, 166; 144, 177; 144, 191; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:mod_type; 148, subscript; 148, 149; 148, 150; 149, identifier:modclass_to_modtype; 150, attribute; 150, 151; 150, 152; 151, identifier:stmt; 152, identifier:__class__; 153, if_statement; 153, 154; 153, 159; 154, call; 154, 155; 154, 156; 155, identifier:isinstance; 156, argument_list; 156, 157; 156, 158; 157, identifier:stmt; 158, identifier:RemoveModification; 159, block; 159, 160; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:mod_type; 163, subscript; 163, 164; 163, 165; 164, identifier:modtype_to_inverse; 165, identifier:mod_type; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:mod; 169, tuple; 169, 170; 169, 171; 169, 174; 170, identifier:mod_type; 171, attribute; 171, 172; 171, 173; 172, identifier:stmt; 173, identifier:residue; 174, attribute; 174, 175; 174, 176; 175, identifier:stmt; 176, identifier:position; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:used; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:states_used; 183, identifier:get; 184, argument_list; 184, 185; 184, 190; 185, attribute; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:stmt; 188, identifier:sub; 189, identifier:name; 190, list:[]; 191, if_statement; 191, 192; 191, 195; 192, comparison_operator:not; 192, 193; 192, 194; 193, identifier:mod; 194, identifier:used; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:skip; 199, True; 200, if_statement; 200, 201; 200, 203; 201, not_operator; 201, 202; 202, identifier:skip; 203, block; 203, 204; 204, expression_statement; 204, 205; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:stmts_out; 208, identifier:append; 209, argument_list; 209, 210; 210, identifier:stmt; 211, expression_statement; 211, 212; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:logger; 215, identifier:info; 216, argument_list; 216, 217; 217, binary_operator:%; 217, 218; 217, 219; 218, string:'%d statements after filter...'; 219, call; 219, 220; 219, 221; 220, identifier:len; 221, argument_list; 221, 222; 222, identifier:stmts_out; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:dump_pkl; 226, call; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:kwargs; 229, identifier:get; 230, argument_list; 230, 231; 231, string:'save'; 232, if_statement; 232, 233; 232, 234; 233, identifier:dump_pkl; 234, block; 234, 235; 235, expression_statement; 235, 236; 236, call; 236, 237; 236, 238; 237, identifier:dump_statements; 238, argument_list; 238, 239; 238, 240; 239, identifier:stmts_out; 240, identifier:dump_pkl; 241, return_statement; 241, 242; 242, identifier:stmts_out | def filter_inconsequential_mods(stmts_in, whitelist=None, **kwargs):
if whitelist is None:
whitelist = {}
logger.info('Filtering %d statements to remove' % len(stmts_in) +
' inconsequential modifications...')
states_used = whitelist
for stmt in stmts_in:
for agent in stmt.agent_list():
if agent is not None:
if agent.mods:
for mc in agent.mods:
mod = (mc.mod_type, mc.residue, mc.position)
try:
states_used[agent.name].append(mod)
except KeyError:
states_used[agent.name] = [mod]
for k, v in states_used.items():
states_used[k] = list(set(v))
stmts_out = []
for stmt in stmts_in:
skip = False
if isinstance(stmt, Modification):
mod_type = modclass_to_modtype[stmt.__class__]
if isinstance(stmt, RemoveModification):
mod_type = modtype_to_inverse[mod_type]
mod = (mod_type, stmt.residue, stmt.position)
used = states_used.get(stmt.sub.name, [])
if mod not in used:
skip = True
if not skip:
stmts_out.append(stmt)
logger.info('%d statements after filter...' % len(stmts_out))
dump_pkl = kwargs.get('save')
if dump_pkl:
dump_statements(stmts_out, dump_pkl)
return stmts_out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:filter_inconsequential_acts; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:stmts_in; 5, default_parameter; 5, 6; 5, 7; 6, identifier:whitelist; 7, None; 8, dictionary_splat_pattern; 8, 9; 9, identifier:kwargs; 10, block; 10, 11; 10, 20; 10, 34; 10, 38; 10, 93; 10, 115; 10, 119; 10, 170; 10, 182; 10, 191; 10, 200; 11, if_statement; 11, 12; 11, 15; 12, comparison_operator:is; 12, 13; 12, 14; 13, identifier:whitelist; 14, None; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:whitelist; 19, dictionary; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:logger; 24, identifier:info; 25, argument_list; 25, 26; 26, binary_operator:+; 26, 27; 26, 33; 27, binary_operator:%; 27, 28; 27, 29; 28, string:'Filtering %d statements to remove'; 29, call; 29, 30; 29, 31; 30, identifier:len; 31, argument_list; 31, 32; 32, identifier:stmts_in; 33, string:' inconsequential activations...'; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:states_used; 37, identifier:whitelist; 38, for_statement; 38, 39; 38, 40; 38, 41; 39, identifier:stmt; 40, identifier:stmts_in; 41, block; 41, 42; 42, for_statement; 42, 43; 42, 44; 42, 49; 43, identifier:agent; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:stmt; 47, identifier:agent_list; 48, argument_list; 49, block; 49, 50; 50, if_statement; 50, 51; 50, 54; 51, comparison_operator:is; 51, 52; 51, 53; 52, identifier:agent; 53, None; 54, block; 54, 55; 55, if_statement; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:agent; 58, identifier:activity; 59, block; 59, 60; 59, 68; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:act; 63, attribute; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:agent; 66, identifier:activity; 67, identifier:activity_type; 68, try_statement; 68, 69; 68, 81; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 79; 72, attribute; 72, 73; 72, 78; 73, subscript; 73, 74; 73, 75; 74, identifier:states_used; 75, attribute; 75, 76; 75, 77; 76, identifier:agent; 77, identifier:name; 78, identifier:append; 79, argument_list; 79, 80; 80, identifier:act; 81, except_clause; 81, 82; 81, 83; 82, identifier:KeyError; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 91; 86, subscript; 86, 87; 86, 88; 87, identifier:states_used; 88, attribute; 88, 89; 88, 90; 89, identifier:agent; 90, identifier:name; 91, list:[act]; 91, 92; 92, identifier:act; 93, for_statement; 93, 94; 93, 97; 93, 102; 94, pattern_list; 94, 95; 94, 96; 95, identifier:k; 96, identifier:v; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:states_used; 100, identifier:items; 101, argument_list; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 108; 105, subscript; 105, 106; 105, 107; 106, identifier:states_used; 107, identifier:k; 108, call; 108, 109; 108, 110; 109, identifier:list; 110, argument_list; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:set; 113, argument_list; 113, 114; 114, identifier:v; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:stmts_out; 118, list:[]; 119, for_statement; 119, 120; 119, 121; 119, 122; 120, identifier:stmt; 121, identifier:stmts_in; 122, block; 122, 123; 122, 127; 122, 159; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:skip; 126, False; 127, if_statement; 127, 128; 127, 133; 128, call; 128, 129; 128, 130; 129, identifier:isinstance; 130, argument_list; 130, 131; 130, 132; 131, identifier:stmt; 132, identifier:RegulateActivity; 133, block; 133, 134; 133, 148; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:used; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:states_used; 140, identifier:get; 141, argument_list; 141, 142; 141, 147; 142, attribute; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:stmt; 145, identifier:obj; 146, identifier:name; 147, list:[]; 148, if_statement; 148, 149; 148, 154; 149, comparison_operator:not; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:stmt; 152, identifier:obj_activity; 153, identifier:used; 154, block; 154, 155; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:skip; 158, True; 159, if_statement; 159, 160; 159, 162; 160, not_operator; 160, 161; 161, identifier:skip; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:stmts_out; 167, identifier:append; 168, argument_list; 168, 169; 169, identifier:stmt; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:logger; 174, identifier:info; 175, argument_list; 175, 176; 176, binary_operator:%; 176, 177; 176, 178; 177, string:'%d statements after filter...'; 178, call; 178, 179; 178, 180; 179, identifier:len; 180, argument_list; 180, 181; 181, identifier:stmts_out; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:dump_pkl; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:kwargs; 188, identifier:get; 189, argument_list; 189, 190; 190, string:'save'; 191, if_statement; 191, 192; 191, 193; 192, identifier:dump_pkl; 193, block; 193, 194; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 197; 196, identifier:dump_statements; 197, argument_list; 197, 198; 197, 199; 198, identifier:stmts_out; 199, identifier:dump_pkl; 200, return_statement; 200, 201; 201, identifier:stmts_out | def filter_inconsequential_acts(stmts_in, whitelist=None, **kwargs):
if whitelist is None:
whitelist = {}
logger.info('Filtering %d statements to remove' % len(stmts_in) +
' inconsequential activations...')
states_used = whitelist
for stmt in stmts_in:
for agent in stmt.agent_list():
if agent is not None:
if agent.activity:
act = agent.activity.activity_type
try:
states_used[agent.name].append(act)
except KeyError:
states_used[agent.name] = [act]
for k, v in states_used.items():
states_used[k] = list(set(v))
stmts_out = []
for stmt in stmts_in:
skip = False
if isinstance(stmt, RegulateActivity):
used = states_used.get(stmt.obj.name, [])
if stmt.obj_activity not in used:
skip = True
if not skip:
stmts_out.append(stmt)
logger.info('%d statements after filter...' % len(stmts_out))
dump_pkl = kwargs.get('save')
if dump_pkl:
dump_statements(stmts_out, dump_pkl)
return stmts_out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:render_stmt_graph; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:statements; 5, default_parameter; 5, 6; 5, 7; 6, identifier:reduce; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:english; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:rankdir; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:agent_style; 16, None; 17, block; 17, 18; 17, 25; 17, 43; 17, 50; 17, 57; 17, 61; 17, 132; 17, 141; 17, 149; 17, 156; 17, 172; 17, 205; 17, 268; 17, 279; 18, import_from_statement; 18, 19; 18, 23; 19, dotted_name; 19, 20; 19, 21; 19, 22; 20, identifier:indra; 21, identifier:assemblers; 22, identifier:english; 23, dotted_name; 23, 24; 24, identifier:EnglishAssembler; 25, if_statement; 25, 26; 25, 29; 26, comparison_operator:is; 26, 27; 26, 28; 27, identifier:agent_style; 28, None; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:agent_style; 33, dictionary; 33, 34; 33, 37; 33, 40; 34, pair; 34, 35; 34, 36; 35, string:'color'; 36, string:'lightgray'; 37, pair; 37, 38; 37, 39; 38, string:'style'; 39, string:'filled'; 40, pair; 40, 41; 40, 42; 41, string:'fontname'; 42, string:'arial'; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:nodes; 46, call; 46, 47; 46, 48; 47, identifier:set; 48, argument_list; 48, 49; 49, list:[]; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:edges; 53, call; 53, 54; 53, 55; 54, identifier:set; 55, argument_list; 55, 56; 56, list:[]; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:stmt_dict; 60, dictionary; 61, function_definition; 61, 62; 61, 63; 61, 65; 62, function_name:process_stmt; 63, parameters; 63, 64; 64, identifier:stmt; 65, block; 65, 66; 65, 80; 65, 93; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:nodes; 70, identifier:add; 71, argument_list; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:str; 74, argument_list; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:stmt; 78, identifier:matches_key; 79, argument_list; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 92; 82, subscript; 82, 83; 82, 84; 83, identifier:stmt_dict; 84, call; 84, 85; 84, 86; 85, identifier:str; 86, argument_list; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:stmt; 90, identifier:matches_key; 91, argument_list; 92, identifier:stmt; 93, for_statement; 93, 94; 93, 97; 93, 103; 94, pattern_list; 94, 95; 94, 96; 95, identifier:sby_ix; 96, identifier:sby_stmt; 97, call; 97, 98; 97, 99; 98, identifier:enumerate; 99, argument_list; 99, 100; 100, attribute; 100, 101; 100, 102; 101, identifier:stmt; 102, identifier:supported_by; 103, block; 103, 104; 103, 127; 104, expression_statement; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:edges; 108, identifier:add; 109, argument_list; 109, 110; 110, tuple; 110, 111; 110, 119; 111, call; 111, 112; 111, 113; 112, identifier:str; 113, argument_list; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:stmt; 117, identifier:matches_key; 118, argument_list; 119, call; 119, 120; 119, 121; 120, identifier:str; 121, argument_list; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:sby_stmt; 125, identifier:matches_key; 126, argument_list; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 130; 129, identifier:process_stmt; 130, argument_list; 130, 131; 131, identifier:sby_stmt; 132, for_statement; 132, 133; 132, 134; 132, 135; 133, identifier:stmt; 134, identifier:statements; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 139; 138, identifier:process_stmt; 139, argument_list; 139, 140; 140, identifier:stmt; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:nx_graph; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:nx; 147, identifier:DiGraph; 148, argument_list; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:nx_graph; 153, identifier:add_edges_from; 154, argument_list; 154, 155; 155, identifier:edges; 156, if_statement; 156, 157; 156, 158; 157, identifier:reduce; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:nx_graph; 162, call; 162, 163; 162, 170; 163, attribute; 163, 164; 163, 169; 164, attribute; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:nx; 167, identifier:algorithms; 168, identifier:dag; 169, identifier:transitive_reduction; 170, argument_list; 170, 171; 171, identifier:nx_graph; 172, try_statement; 172, 173; 172, 191; 173, block; 173, 174; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:pgv_graph; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:pgv; 180, identifier:AGraph; 181, argument_list; 181, 182; 181, 185; 181, 188; 182, keyword_argument; 182, 183; 182, 184; 183, identifier:name; 184, string:'statements'; 185, keyword_argument; 185, 186; 185, 187; 186, identifier:directed; 187, True; 188, keyword_argument; 188, 189; 188, 190; 189, identifier:rankdir; 190, identifier:rankdir; 191, except_clause; 191, 192; 191, 193; 192, identifier:NameError; 193, block; 193, 194; 193, 203; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:logger; 198, identifier:error; 199, argument_list; 199, 200; 200, concatenated_string; 200, 201; 200, 202; 201, string:'Cannot generate graph because '; 202, string:'pygraphviz could not be imported.'; 203, return_statement; 203, 204; 204, None; 205, for_statement; 205, 206; 205, 207; 205, 212; 206, identifier:node; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:nx_graph; 210, identifier:nodes; 211, argument_list; 212, block; 212, 213; 212, 219; 212, 247; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:stmt; 216, subscript; 216, 217; 216, 218; 217, identifier:stmt_dict; 218, identifier:node; 219, if_statement; 219, 220; 219, 221; 219, 238; 220, identifier:english; 221, block; 221, 222; 221, 230; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:ea; 225, call; 225, 226; 225, 227; 226, identifier:EnglishAssembler; 227, argument_list; 227, 228; 228, list:[stmt]; 228, 229; 229, identifier:stmt; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:stmt_str; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:ea; 236, identifier:make_model; 237, argument_list; 238, else_clause; 238, 239; 239, block; 239, 240; 240, expression_statement; 240, 241; 241, assignment; 241, 242; 241, 243; 242, identifier:stmt_str; 243, call; 243, 244; 243, 245; 244, identifier:str; 245, argument_list; 245, 246; 246, identifier:stmt; 247, expression_statement; 247, 248; 248, call; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:pgv_graph; 251, identifier:add_node; 252, argument_list; 252, 253; 252, 254; 252, 266; 253, identifier:node; 254, keyword_argument; 254, 255; 254, 256; 255, identifier:label; 256, binary_operator:%; 256, 257; 256, 258; 257, string:'%s (%d)'; 258, tuple; 258, 259; 258, 260; 259, identifier:stmt_str; 260, call; 260, 261; 260, 262; 261, identifier:len; 262, argument_list; 262, 263; 263, attribute; 263, 264; 263, 265; 264, identifier:stmt; 265, identifier:evidence; 266, dictionary_splat; 266, 267; 267, identifier:agent_style; 268, expression_statement; 268, 269; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:pgv_graph; 272, identifier:add_edges_from; 273, argument_list; 273, 274; 274, call; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:nx_graph; 277, identifier:edges; 278, argument_list; 279, return_statement; 279, 280; 280, identifier:pgv_graph | def render_stmt_graph(statements, reduce=True, english=False, rankdir=None,
agent_style=None):
from indra.assemblers.english import EnglishAssembler
if agent_style is None:
agent_style = {'color': 'lightgray', 'style': 'filled',
'fontname': 'arial'}
nodes = set([])
edges = set([])
stmt_dict = {}
def process_stmt(stmt):
nodes.add(str(stmt.matches_key()))
stmt_dict[str(stmt.matches_key())] = stmt
for sby_ix, sby_stmt in enumerate(stmt.supported_by):
edges.add((str(stmt.matches_key()), str(sby_stmt.matches_key())))
process_stmt(sby_stmt)
for stmt in statements:
process_stmt(stmt)
nx_graph = nx.DiGraph()
nx_graph.add_edges_from(edges)
if reduce:
nx_graph = nx.algorithms.dag.transitive_reduction(nx_graph)
try:
pgv_graph = pgv.AGraph(name='statements', directed=True,
rankdir=rankdir)
except NameError:
logger.error('Cannot generate graph because '
'pygraphviz could not be imported.')
return None
for node in nx_graph.nodes():
stmt = stmt_dict[node]
if english:
ea = EnglishAssembler([stmt])
stmt_str = ea.make_model()
else:
stmt_str = str(stmt)
pgv_graph.add_node(node,
label='%s (%d)' % (stmt_str, len(stmt.evidence)),
**agent_style)
pgv_graph.add_edges_from(nx_graph.edges())
return pgv_graph |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:flatten_stmts; 3, parameters; 3, 4; 4, identifier:stmts; 5, block; 5, 6; 5, 13; 5, 40; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:total_stmts; 9, call; 9, 10; 9, 11; 10, identifier:set; 11, argument_list; 11, 12; 12, identifier:stmts; 13, for_statement; 13, 14; 13, 15; 13, 16; 14, identifier:stmt; 15, identifier:stmts; 16, block; 16, 17; 17, if_statement; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:stmt; 20, identifier:supported_by; 21, block; 21, 22; 21, 31; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:children; 25, call; 25, 26; 25, 27; 26, identifier:flatten_stmts; 27, argument_list; 27, 28; 28, attribute; 28, 29; 28, 30; 29, identifier:stmt; 30, identifier:supported_by; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:total_stmts; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:total_stmts; 37, identifier:union; 38, argument_list; 38, 39; 39, identifier:children; 40, return_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:list; 43, argument_list; 43, 44; 44, identifier:total_stmts | def flatten_stmts(stmts):
total_stmts = set(stmts)
for stmt in stmts:
if stmt.supported_by:
children = flatten_stmts(stmt.supported_by)
total_stmts = total_stmts.union(children)
return list(total_stmts) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:combine_duplicate_stmts; 3, parameters; 3, 4; 4, identifier:stmts; 5, block; 5, 6; 5, 38; 5, 42; 5, 329; 6, function_definition; 6, 7; 6, 8; 6, 10; 7, function_name:_ev_keys; 8, parameters; 8, 9; 9, identifier:sts; 10, block; 10, 11; 10, 15; 10, 36; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:ev_keys; 14, list:[]; 15, for_statement; 15, 16; 15, 17; 15, 18; 16, identifier:stmt; 17, identifier:sts; 18, block; 18, 19; 19, for_statement; 19, 20; 19, 21; 19, 24; 20, identifier:ev; 21, attribute; 21, 22; 21, 23; 22, identifier:stmt; 23, identifier:evidence; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:ev_keys; 29, identifier:append; 30, argument_list; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:ev; 34, identifier:matches_key; 35, argument_list; 36, return_statement; 36, 37; 37, identifier:ev_keys; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:unique_stmts; 41, list:[]; 42, for_statement; 42, 43; 42, 46; 42, 52; 43, pattern_list; 43, 44; 43, 45; 44, identifier:_; 45, identifier:duplicates; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:Preassembler; 49, identifier:_get_stmt_matching_groups; 50, argument_list; 50, 51; 51, identifier:stmts; 52, block; 52, 53; 52, 59; 52, 66; 52, 73; 52, 279; 52, 287; 52, 316; 52, 322; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:ev_keys; 56, call; 56, 57; 56, 58; 57, identifier:set; 58, argument_list; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:duplicates; 62, call; 62, 63; 62, 64; 63, identifier:list; 64, argument_list; 64, 65; 65, identifier:duplicates; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:start_ev_keys; 69, call; 69, 70; 69, 71; 70, identifier:_ev_keys; 71, argument_list; 71, 72; 72, identifier:duplicates; 73, for_statement; 73, 74; 73, 77; 73, 81; 74, pattern_list; 74, 75; 74, 76; 75, identifier:stmt_ix; 76, identifier:stmt; 77, call; 77, 78; 77, 79; 78, identifier:enumerate; 79, argument_list; 79, 80; 80, identifier:duplicates; 81, block; 81, 82; 81, 95; 81, 111; 81, 138; 81, 160; 82, if_statement; 82, 83; 82, 86; 83, comparison_operator:is; 83, 84; 83, 85; 84, identifier:stmt_ix; 85, integer:0; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:new_stmt; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:stmt; 93, identifier:make_generic_copy; 94, argument_list; 95, if_statement; 95, 96; 95, 102; 96, comparison_operator:==; 96, 97; 96, 101; 97, call; 97, 98; 97, 99; 98, identifier:len; 99, argument_list; 99, 100; 100, identifier:duplicates; 101, integer:1; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:new_stmt; 107, identifier:uuid; 108, attribute; 108, 109; 108, 110; 109, identifier:stmt; 110, identifier:uuid; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:raw_text; 114, list_comprehension; 114, 115; 114, 128; 115, conditional_expression:if; 115, 116; 115, 117; 115, 120; 116, None; 117, comparison_operator:is; 117, 118; 117, 119; 118, identifier:ag; 119, None; 120, call; 120, 121; 120, 126; 121, attribute; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:ag; 124, identifier:db_refs; 125, identifier:get; 126, argument_list; 126, 127; 127, string:'TEXT'; 128, for_in_clause; 128, 129; 128, 130; 129, identifier:ag; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:stmt; 133, identifier:agent_list; 134, argument_list; 134, 135; 135, keyword_argument; 135, 136; 135, 137; 136, identifier:deep_sorted; 137, True; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:raw_grounding; 141, list_comprehension; 141, 142; 141, 150; 142, conditional_expression:if; 142, 143; 142, 144; 142, 147; 143, None; 144, comparison_operator:is; 144, 145; 144, 146; 145, identifier:ag; 146, None; 147, attribute; 147, 148; 147, 149; 148, identifier:ag; 149, identifier:db_refs; 150, for_in_clause; 150, 151; 150, 152; 151, identifier:ag; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:stmt; 155, identifier:agent_list; 156, argument_list; 156, 157; 157, keyword_argument; 157, 158; 157, 159; 158, identifier:deep_sorted; 159, True; 160, for_statement; 160, 161; 160, 162; 160, 165; 161, identifier:ev; 162, attribute; 162, 163; 162, 164; 163, identifier:stmt; 164, identifier:evidence; 165, block; 165, 166; 165, 185; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:ev_key; 169, binary_operator:+; 169, 170; 169, 180; 169, 181; 170, binary_operator:+; 170, 171; 170, 176; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:ev; 174, identifier:matches_key; 175, argument_list; 176, call; 176, 177; 176, 178; 177, identifier:str; 178, argument_list; 178, 179; 179, identifier:raw_text; 180, line_continuation:\; 181, call; 181, 182; 181, 183; 182, identifier:str; 183, argument_list; 183, 184; 184, identifier:raw_grounding; 185, if_statement; 185, 186; 185, 189; 186, comparison_operator:not; 186, 187; 186, 188; 187, identifier:ev_key; 188, identifier:ev_keys; 189, block; 189, 190; 189, 235; 189, 250; 189, 263; 189, 272; 190, if_statement; 190, 191; 190, 196; 190, 218; 191, comparison_operator:in; 191, 192; 191, 193; 192, string:'agents'; 193, attribute; 193, 194; 193, 195; 194, identifier:ev; 195, identifier:annotations; 196, block; 196, 197; 196, 207; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 206; 199, subscript; 199, 200; 199, 205; 200, subscript; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:ev; 203, identifier:annotations; 204, string:'agents'; 205, string:'raw_text'; 206, identifier:raw_text; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 216; 208, 217; 209, subscript; 209, 210; 209, 215; 210, subscript; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:ev; 213, identifier:annotations; 214, string:'agents'; 215, string:'raw_grounding'; 216, line_continuation:\; 217, identifier:raw_grounding; 218, else_clause; 218, 219; 219, block; 219, 220; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 227; 221, 228; 222, subscript; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:ev; 225, identifier:annotations; 226, string:'agents'; 227, line_continuation:\; 228, dictionary; 228, 229; 228, 232; 229, pair; 229, 230; 229, 231; 230, string:'raw_text'; 231, identifier:raw_text; 232, pair; 232, 233; 232, 234; 233, string:'raw_grounding'; 234, identifier:raw_grounding; 235, if_statement; 235, 236; 235, 241; 236, comparison_operator:not; 236, 237; 236, 238; 237, string:'prior_uuids'; 238, attribute; 238, 239; 238, 240; 239, identifier:ev; 240, identifier:annotations; 241, block; 241, 242; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 249; 244, subscript; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:ev; 247, identifier:annotations; 248, string:'prior_uuids'; 249, list:[]; 250, expression_statement; 250, 251; 251, call; 251, 252; 251, 259; 252, attribute; 252, 253; 252, 258; 253, subscript; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:ev; 256, identifier:annotations; 257, string:'prior_uuids'; 258, identifier:append; 259, argument_list; 259, 260; 260, attribute; 260, 261; 260, 262; 261, identifier:stmt; 262, identifier:uuid; 263, expression_statement; 263, 264; 264, call; 264, 265; 264, 270; 265, attribute; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:new_stmt; 268, identifier:evidence; 269, identifier:append; 270, argument_list; 270, 271; 271, identifier:ev; 272, expression_statement; 272, 273; 273, call; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:ev_keys; 276, identifier:add; 277, argument_list; 277, 278; 278, identifier:ev_key; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:end_ev_keys; 282, call; 282, 283; 282, 284; 283, identifier:_ev_keys; 284, argument_list; 284, 285; 285, list:[new_stmt]; 285, 286; 286, identifier:new_stmt; 287, if_statement; 287, 288; 287, 297; 288, comparison_operator:!=; 288, 289; 288, 293; 289, call; 289, 290; 289, 291; 290, identifier:len; 291, argument_list; 291, 292; 292, identifier:end_ev_keys; 293, call; 293, 294; 293, 295; 294, identifier:len; 295, argument_list; 295, 296; 296, identifier:start_ev_keys; 297, block; 297, 298; 298, expression_statement; 298, 299; 299, call; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:logger; 302, identifier:debug; 303, argument_list; 303, 304; 304, binary_operator:%; 304, 305; 304, 306; 305, string:'%d redundant evidences eliminated.'; 306, parenthesized_expression; 306, 307; 307, binary_operator:-; 307, 308; 307, 312; 308, call; 308, 309; 308, 310; 309, identifier:len; 310, argument_list; 310, 311; 311, identifier:start_ev_keys; 312, call; 312, 313; 312, 314; 313, identifier:len; 314, argument_list; 314, 315; 315, identifier:end_ev_keys; 316, assert_statement; 316, 317; 317, call; 317, 318; 317, 319; 318, identifier:isinstance; 319, argument_list; 319, 320; 319, 321; 320, identifier:new_stmt; 321, identifier:Statement; 322, expression_statement; 322, 323; 323, call; 323, 324; 323, 327; 324, attribute; 324, 325; 324, 326; 325, identifier:unique_stmts; 326, identifier:append; 327, argument_list; 327, 328; 328, identifier:new_stmt; 329, return_statement; 329, 330; 330, identifier:unique_stmts | def combine_duplicate_stmts(stmts):
def _ev_keys(sts):
ev_keys = []
for stmt in sts:
for ev in stmt.evidence:
ev_keys.append(ev.matches_key())
return ev_keys
unique_stmts = []
for _, duplicates in Preassembler._get_stmt_matching_groups(stmts):
ev_keys = set()
duplicates = list(duplicates)
start_ev_keys = _ev_keys(duplicates)
for stmt_ix, stmt in enumerate(duplicates):
if stmt_ix is 0:
new_stmt = stmt.make_generic_copy()
if len(duplicates) == 1:
new_stmt.uuid = stmt.uuid
raw_text = [None if ag is None else ag.db_refs.get('TEXT')
for ag in stmt.agent_list(deep_sorted=True)]
raw_grounding = [None if ag is None else ag.db_refs
for ag in stmt.agent_list(deep_sorted=True)]
for ev in stmt.evidence:
ev_key = ev.matches_key() + str(raw_text) + \
str(raw_grounding)
if ev_key not in ev_keys:
if 'agents' in ev.annotations:
ev.annotations['agents']['raw_text'] = raw_text
ev.annotations['agents']['raw_grounding'] = \
raw_grounding
else:
ev.annotations['agents'] = \
{'raw_text': raw_text,
'raw_grounding': raw_grounding}
if 'prior_uuids' not in ev.annotations:
ev.annotations['prior_uuids'] = []
ev.annotations['prior_uuids'].append(stmt.uuid)
new_stmt.evidence.append(ev)
ev_keys.add(ev_key)
end_ev_keys = _ev_keys([new_stmt])
if len(end_ev_keys) != len(start_ev_keys):
logger.debug('%d redundant evidences eliminated.' %
(len(start_ev_keys) - len(end_ev_keys)))
assert isinstance(new_stmt, Statement)
unique_stmts.append(new_stmt)
return unique_stmts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_get_stmt_by_group; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:stmt_type; 6, identifier:stmts_this_type; 7, identifier:eh; 8, block; 8, 9; 8, 19; 8, 29; 8, 39; 8, 49; 8, 59; 8, 366; 8, 407; 8, 448; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:stmt_by_first; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:collections; 15, identifier:defaultdict; 16, argument_list; 16, 17; 17, lambda; 17, 18; 18, list:[]; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:stmt_by_second; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:collections; 25, identifier:defaultdict; 26, argument_list; 26, 27; 27, lambda; 27, 28; 28, list:[]; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:none_first; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:collections; 35, identifier:defaultdict; 36, argument_list; 36, 37; 37, lambda; 37, 38; 38, list:[]; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:none_second; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:collections; 45, identifier:defaultdict; 46, argument_list; 46, 47; 47, lambda; 47, 48; 48, list:[]; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:stmt_by_group; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:collections; 55, identifier:defaultdict; 56, argument_list; 56, 57; 57, lambda; 57, 58; 58, list:[]; 59, for_statement; 59, 60; 59, 61; 59, 62; 60, identifier:stmt_tuple; 61, identifier:stmts_this_type; 62, block; 62, 63; 62, 69; 62, 80; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, pattern_list; 65, 66; 65, 67; 66, identifier:_; 67, identifier:stmt; 68, identifier:stmt_tuple; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:entities; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:_get_entities; 76, argument_list; 76, 77; 76, 78; 76, 79; 77, identifier:stmt; 78, identifier:stmt_type; 79, identifier:eh; 80, if_statement; 80, 81; 80, 84; 80, 125; 80, 196; 80, 231; 81, comparison_operator:==; 81, 82; 81, 83; 82, identifier:stmt_type; 83, identifier:Complex; 84, block; 84, 85; 84, 89; 84, 96; 84, 102; 84, 109; 85, assert_statement; 85, 86; 86, comparison_operator:not; 86, 87; 86, 88; 87, None; 88, identifier:entities; 89, assert_statement; 89, 90; 90, comparison_operator:>; 90, 91; 90, 95; 91, call; 91, 92; 91, 93; 92, identifier:len; 93, argument_list; 93, 94; 94, identifier:entities; 95, integer:0; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:entities; 100, identifier:sort; 101, argument_list; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:key; 105, call; 105, 106; 105, 107; 106, identifier:tuple; 107, argument_list; 107, 108; 108, identifier:entities; 109, if_statement; 109, 110; 109, 115; 110, comparison_operator:not; 110, 111; 110, 112; 111, identifier:stmt_tuple; 112, subscript; 112, 113; 112, 114; 113, identifier:stmt_by_group; 114, identifier:key; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 123; 118, attribute; 118, 119; 118, 122; 119, subscript; 119, 120; 119, 121; 120, identifier:stmt_by_group; 121, identifier:key; 122, identifier:append; 123, argument_list; 123, 124; 124, identifier:stmt_tuple; 125, elif_clause; 125, 126; 125, 129; 126, comparison_operator:==; 126, 127; 126, 128; 127, identifier:stmt_type; 128, identifier:Conversion; 129, block; 129, 130; 129, 137; 129, 180; 130, assert_statement; 130, 131; 131, comparison_operator:>; 131, 132; 131, 136; 132, call; 132, 133; 132, 134; 133, identifier:len; 134, argument_list; 134, 135; 135, identifier:entities; 136, integer:0; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:key; 140, tuple; 140, 141; 140, 144; 140, 163; 141, subscript; 141, 142; 141, 143; 142, identifier:entities; 143, integer:0; 144, call; 144, 145; 144, 146; 145, identifier:tuple; 146, argument_list; 146, 147; 147, call; 147, 148; 147, 149; 148, identifier:sorted; 149, argument_list; 149, 150; 150, subscript; 150, 151; 150, 152; 151, identifier:entities; 152, slice; 152, 153; 152, 154; 152, 155; 153, integer:1; 154, colon; 155, binary_operator:+; 155, 156; 155, 162; 156, call; 156, 157; 156, 158; 157, identifier:len; 158, argument_list; 158, 159; 159, attribute; 159, 160; 159, 161; 160, identifier:stmt; 161, identifier:obj_from; 162, integer:1; 163, call; 163, 164; 163, 165; 164, identifier:tuple; 165, argument_list; 165, 166; 166, call; 166, 167; 166, 168; 167, identifier:sorted; 168, argument_list; 168, 169; 169, subscript; 169, 170; 169, 171; 170, identifier:entities; 171, slice; 171, 172; 171, 179; 172, unary_operator:-; 172, 173; 173, call; 173, 174; 173, 175; 174, identifier:len; 175, argument_list; 175, 176; 176, attribute; 176, 177; 176, 178; 177, identifier:stmt; 178, identifier:obj_to; 179, colon; 180, if_statement; 180, 181; 180, 186; 181, comparison_operator:not; 181, 182; 181, 183; 182, identifier:stmt_tuple; 183, subscript; 183, 184; 183, 185; 184, identifier:stmt_by_group; 185, identifier:key; 186, block; 186, 187; 187, expression_statement; 187, 188; 188, call; 188, 189; 188, 194; 189, attribute; 189, 190; 189, 193; 190, subscript; 190, 191; 190, 192; 191, identifier:stmt_by_group; 192, identifier:key; 193, identifier:append; 194, argument_list; 194, 195; 195, identifier:stmt_tuple; 196, elif_clause; 196, 197; 196, 203; 197, comparison_operator:==; 197, 198; 197, 202; 198, call; 198, 199; 198, 200; 199, identifier:len; 200, argument_list; 200, 201; 201, identifier:entities; 202, integer:1; 203, block; 203, 204; 203, 208; 203, 215; 204, assert_statement; 204, 205; 205, comparison_operator:not; 205, 206; 205, 207; 206, None; 207, identifier:entities; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:key; 211, call; 211, 212; 211, 213; 212, identifier:tuple; 213, argument_list; 213, 214; 214, identifier:entities; 215, if_statement; 215, 216; 215, 221; 216, comparison_operator:not; 216, 217; 216, 218; 217, identifier:stmt_tuple; 218, subscript; 218, 219; 218, 220; 219, identifier:stmt_by_group; 220, identifier:key; 221, block; 221, 222; 222, expression_statement; 222, 223; 223, call; 223, 224; 223, 229; 224, attribute; 224, 225; 224, 228; 225, subscript; 225, 226; 225, 227; 226, identifier:stmt_by_group; 227, identifier:key; 228, identifier:append; 229, argument_list; 229, 230; 230, identifier:stmt_tuple; 231, else_clause; 231, 232; 232, block; 232, 233; 232, 240; 232, 247; 232, 253; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:key; 236, call; 236, 237; 236, 238; 237, identifier:tuple; 238, argument_list; 238, 239; 239, identifier:entities; 240, assert_statement; 240, 241; 241, comparison_operator:==; 241, 242; 241, 246; 242, call; 242, 243; 242, 244; 243, identifier:len; 244, argument_list; 244, 245; 245, identifier:key; 246, integer:2; 247, assert_statement; 247, 248; 248, comparison_operator:!=; 248, 249; 248, 250; 249, identifier:key; 250, tuple; 250, 251; 250, 252; 251, None; 252, None; 253, if_statement; 253, 254; 253, 267; 253, 279; 253, 305; 254, boolean_operator:and; 254, 255; 254, 260; 255, comparison_operator:is; 255, 256; 255, 259; 256, subscript; 256, 257; 256, 258; 257, identifier:key; 258, integer:0; 259, None; 260, comparison_operator:not; 260, 261; 260, 262; 261, identifier:stmt_tuple; 262, subscript; 262, 263; 262, 264; 263, identifier:none_first; 264, subscript; 264, 265; 264, 266; 265, identifier:key; 266, integer:1; 267, block; 267, 268; 268, expression_statement; 268, 269; 269, call; 269, 270; 269, 277; 270, attribute; 270, 271; 270, 276; 271, subscript; 271, 272; 271, 273; 272, identifier:none_first; 273, subscript; 273, 274; 273, 275; 274, identifier:key; 275, integer:1; 276, identifier:append; 277, argument_list; 277, 278; 278, identifier:stmt_tuple; 279, elif_clause; 279, 280; 279, 293; 280, boolean_operator:and; 280, 281; 280, 286; 281, comparison_operator:is; 281, 282; 281, 285; 282, subscript; 282, 283; 282, 284; 283, identifier:key; 284, integer:1; 285, None; 286, comparison_operator:not; 286, 287; 286, 288; 287, identifier:stmt_tuple; 288, subscript; 288, 289; 288, 290; 289, identifier:none_second; 290, subscript; 290, 291; 290, 292; 291, identifier:key; 292, integer:0; 293, block; 293, 294; 294, expression_statement; 294, 295; 295, call; 295, 296; 295, 303; 296, attribute; 296, 297; 296, 302; 297, subscript; 297, 298; 297, 299; 298, identifier:none_second; 299, subscript; 299, 300; 299, 301; 300, identifier:key; 301, integer:0; 302, identifier:append; 303, argument_list; 303, 304; 304, identifier:stmt_tuple; 305, elif_clause; 305, 306; 305, 309; 306, comparison_operator:not; 306, 307; 306, 308; 307, None; 308, identifier:key; 309, block; 309, 310; 309, 326; 309, 346; 310, if_statement; 310, 311; 310, 316; 311, comparison_operator:not; 311, 312; 311, 313; 312, identifier:stmt_tuple; 313, subscript; 313, 314; 313, 315; 314, identifier:stmt_by_group; 315, identifier:key; 316, block; 316, 317; 317, expression_statement; 317, 318; 318, call; 318, 319; 318, 324; 319, attribute; 319, 320; 319, 323; 320, subscript; 320, 321; 320, 322; 321, identifier:stmt_by_group; 322, identifier:key; 323, identifier:append; 324, argument_list; 324, 325; 325, identifier:stmt_tuple; 326, if_statement; 326, 327; 326, 334; 327, comparison_operator:not; 327, 328; 327, 329; 328, identifier:key; 329, subscript; 329, 330; 329, 331; 330, identifier:stmt_by_first; 331, subscript; 331, 332; 331, 333; 332, identifier:key; 333, integer:0; 334, block; 334, 335; 335, expression_statement; 335, 336; 336, call; 336, 337; 336, 344; 337, attribute; 337, 338; 337, 343; 338, subscript; 338, 339; 338, 340; 339, identifier:stmt_by_first; 340, subscript; 340, 341; 340, 342; 341, identifier:key; 342, integer:0; 343, identifier:append; 344, argument_list; 344, 345; 345, identifier:key; 346, if_statement; 346, 347; 346, 354; 347, comparison_operator:not; 347, 348; 347, 349; 348, identifier:key; 349, subscript; 349, 350; 349, 351; 350, identifier:stmt_by_second; 351, subscript; 351, 352; 351, 353; 352, identifier:key; 353, integer:1; 354, block; 354, 355; 355, expression_statement; 355, 356; 356, call; 356, 357; 356, 364; 357, attribute; 357, 358; 357, 363; 358, subscript; 358, 359; 358, 360; 359, identifier:stmt_by_second; 360, subscript; 360, 361; 360, 362; 361, identifier:key; 362, integer:1; 363, identifier:append; 364, argument_list; 364, 365; 365, identifier:key; 366, if_statement; 366, 367; 366, 368; 367, identifier:none_first; 368, block; 368, 369; 369, for_statement; 369, 370; 369, 373; 369, 378; 370, pattern_list; 370, 371; 370, 372; 371, identifier:second_arg; 372, identifier:stmts; 373, call; 373, 374; 373, 377; 374, attribute; 374, 375; 374, 376; 375, identifier:none_first; 376, identifier:items; 377, argument_list; 378, block; 378, 379; 378, 385; 378, 397; 379, expression_statement; 379, 380; 380, assignment; 380, 381; 380, 382; 381, identifier:second_arg_keys; 382, subscript; 382, 383; 382, 384; 383, identifier:stmt_by_second; 384, identifier:second_arg; 385, if_statement; 385, 386; 385, 388; 386, not_operator; 386, 387; 387, identifier:second_arg_keys; 388, block; 388, 389; 389, expression_statement; 389, 390; 390, assignment; 390, 391; 390, 396; 391, subscript; 391, 392; 391, 393; 392, identifier:stmt_by_group; 393, tuple; 393, 394; 393, 395; 394, None; 395, identifier:second_arg; 396, identifier:stmts; 397, for_statement; 397, 398; 397, 399; 397, 400; 398, identifier:second_arg_key; 399, identifier:second_arg_keys; 400, block; 400, 401; 401, expression_statement; 401, 402; 402, augmented_assignment:+=; 402, 403; 402, 406; 403, subscript; 403, 404; 403, 405; 404, identifier:stmt_by_group; 405, identifier:second_arg_key; 406, identifier:stmts; 407, if_statement; 407, 408; 407, 409; 408, identifier:none_second; 409, block; 409, 410; 410, for_statement; 410, 411; 410, 414; 410, 419; 411, pattern_list; 411, 412; 411, 413; 412, identifier:first_arg; 413, identifier:stmts; 414, call; 414, 415; 414, 418; 415, attribute; 415, 416; 415, 417; 416, identifier:none_second; 417, identifier:items; 418, argument_list; 419, block; 419, 420; 419, 426; 419, 438; 420, expression_statement; 420, 421; 421, assignment; 421, 422; 421, 423; 422, identifier:first_arg_keys; 423, subscript; 423, 424; 423, 425; 424, identifier:stmt_by_first; 425, identifier:first_arg; 426, if_statement; 426, 427; 426, 429; 427, not_operator; 427, 428; 428, identifier:first_arg_keys; 429, block; 429, 430; 430, expression_statement; 430, 431; 431, assignment; 431, 432; 431, 437; 432, subscript; 432, 433; 432, 434; 433, identifier:stmt_by_group; 434, tuple; 434, 435; 434, 436; 435, identifier:first_arg; 436, None; 437, identifier:stmts; 438, for_statement; 438, 439; 438, 440; 438, 441; 439, identifier:first_arg_key; 440, identifier:first_arg_keys; 441, block; 441, 442; 442, expression_statement; 442, 443; 443, augmented_assignment:+=; 443, 444; 443, 447; 444, subscript; 444, 445; 444, 446; 445, identifier:stmt_by_group; 446, identifier:first_arg_key; 447, identifier:stmts; 448, return_statement; 448, 449; 449, identifier:stmt_by_group | def _get_stmt_by_group(self, stmt_type, stmts_this_type, eh):
stmt_by_first = collections.defaultdict(lambda: [])
stmt_by_second = collections.defaultdict(lambda: [])
none_first = collections.defaultdict(lambda: [])
none_second = collections.defaultdict(lambda: [])
stmt_by_group = collections.defaultdict(lambda: [])
for stmt_tuple in stmts_this_type:
_, stmt = stmt_tuple
entities = self._get_entities(stmt, stmt_type, eh)
if stmt_type == Complex:
assert None not in entities
assert len(entities) > 0
entities.sort()
key = tuple(entities)
if stmt_tuple not in stmt_by_group[key]:
stmt_by_group[key].append(stmt_tuple)
elif stmt_type == Conversion:
assert len(entities) > 0
key = (entities[0],
tuple(sorted(entities[1:len(stmt.obj_from)+1])),
tuple(sorted(entities[-len(stmt.obj_to):])))
if stmt_tuple not in stmt_by_group[key]:
stmt_by_group[key].append(stmt_tuple)
elif len(entities) == 1:
assert None not in entities
key = tuple(entities)
if stmt_tuple not in stmt_by_group[key]:
stmt_by_group[key].append(stmt_tuple)
else:
key = tuple(entities)
assert len(key) == 2
assert key != (None, None)
if key[0] is None and stmt_tuple not in none_first[key[1]]:
none_first[key[1]].append(stmt_tuple)
elif key[1] is None and stmt_tuple not in none_second[key[0]]:
none_second[key[0]].append(stmt_tuple)
elif None not in key:
if stmt_tuple not in stmt_by_group[key]:
stmt_by_group[key].append(stmt_tuple)
if key not in stmt_by_first[key[0]]:
stmt_by_first[key[0]].append(key)
if key not in stmt_by_second[key[1]]:
stmt_by_second[key[1]].append(key)
if none_first:
for second_arg, stmts in none_first.items():
second_arg_keys = stmt_by_second[second_arg]
if not second_arg_keys:
stmt_by_group[(None, second_arg)] = stmts
for second_arg_key in second_arg_keys:
stmt_by_group[second_arg_key] += stmts
if none_second:
for first_arg, stmts in none_second.items():
first_arg_keys = stmt_by_first[first_arg]
if not first_arg_keys:
stmt_by_group[(first_arg, None)] = stmts
for first_arg_key in first_arg_keys:
stmt_by_group[first_arg_key] += stmts
return stmt_by_group |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:combine_related; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:return_toplevel; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:poolsize; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:size_cutoff; 13, integer:100; 14, block; 14, 15; 14, 41; 14, 49; 14, 60; 14, 92; 14, 107; 14, 121; 15, if_statement; 15, 16; 15, 21; 16, comparison_operator:is; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:related_stmts; 20, None; 21, block; 21, 22; 22, if_statement; 22, 23; 22, 24; 22, 29; 23, identifier:return_toplevel; 24, block; 24, 25; 25, return_statement; 25, 26; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:related_stmts; 29, else_clause; 29, 30; 30, block; 30, 31; 30, 37; 31, assert_statement; 31, 32; 32, comparison_operator:is; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:unique_stmts; 36, None; 37, return_statement; 37, 38; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:unique_stmts; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:unique_stmts; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:combine_duplicates; 48, argument_list; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:idx_map; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:_generate_id_maps; 56, argument_list; 56, 57; 56, 58; 56, 59; 57, identifier:unique_stmts; 58, identifier:poolsize; 59, identifier:size_cutoff; 60, for_statement; 60, 61; 60, 64; 60, 65; 61, pattern_list; 61, 62; 61, 63; 62, identifier:ix1; 63, identifier:ix2; 64, identifier:idx_map; 65, block; 65, 66; 65, 79; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 75; 68, attribute; 68, 69; 68, 74; 69, attribute; 69, 70; 69, 73; 70, subscript; 70, 71; 70, 72; 71, identifier:unique_stmts; 72, identifier:ix1; 73, identifier:supported_by; 74, identifier:append; 75, argument_list; 75, 76; 76, subscript; 76, 77; 76, 78; 77, identifier:unique_stmts; 78, identifier:ix2; 79, expression_statement; 79, 80; 80, call; 80, 81; 80, 88; 81, attribute; 81, 82; 81, 87; 82, attribute; 82, 83; 82, 86; 83, subscript; 83, 84; 83, 85; 84, identifier:unique_stmts; 85, identifier:ix2; 86, identifier:supports; 87, identifier:append; 88, argument_list; 88, 89; 89, subscript; 89, 90; 89, 91; 90, identifier:unique_stmts; 91, identifier:ix1; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:related_stmts; 97, list_comprehension; 97, 98; 97, 99; 97, 102; 98, identifier:st; 99, for_in_clause; 99, 100; 99, 101; 100, identifier:st; 101, identifier:unique_stmts; 102, if_clause; 102, 103; 103, not_operator; 103, 104; 104, attribute; 104, 105; 104, 106; 105, identifier:st; 106, identifier:supports; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:logger; 111, identifier:debug; 112, argument_list; 112, 113; 113, binary_operator:%; 113, 114; 113, 115; 114, string:'%d top level'; 115, call; 115, 116; 115, 117; 116, identifier:len; 117, argument_list; 117, 118; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:related_stmts; 121, if_statement; 121, 122; 121, 123; 121, 128; 122, identifier:return_toplevel; 123, block; 123, 124; 124, return_statement; 124, 125; 125, attribute; 125, 126; 125, 127; 126, identifier:self; 127, identifier:related_stmts; 128, else_clause; 128, 129; 129, block; 129, 130; 130, return_statement; 130, 131; 131, identifier:unique_stmts | def combine_related(self, return_toplevel=True, poolsize=None,
size_cutoff=100):
if self.related_stmts is not None:
if return_toplevel:
return self.related_stmts
else:
assert self.unique_stmts is not None
return self.unique_stmts
unique_stmts = self.combine_duplicates()
idx_map = self._generate_id_maps(unique_stmts, poolsize, size_cutoff)
for ix1, ix2 in idx_map:
unique_stmts[ix1].supported_by.append(unique_stmts[ix2])
unique_stmts[ix2].supports.append(unique_stmts[ix1])
self.related_stmts = [st for st in unique_stmts if not st.supports]
logger.debug('%d top level' % len(self.related_stmts))
if return_toplevel:
return self.related_stmts
else:
return unique_stmts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:find_contradicts; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 5, 24; 5, 49; 5, 57; 5, 67; 5, 73; 5, 79; 5, 83; 5, 191; 5, 197; 5, 247; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:eh; 9, subscript; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:hierarchies; 13, string:'entity'; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:stmts_by_type; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:collections; 20, identifier:defaultdict; 21, argument_list; 21, 22; 22, lambda; 22, 23; 23, list:[]; 24, for_statement; 24, 25; 24, 28; 24, 34; 25, pattern_list; 25, 26; 25, 27; 26, identifier:idx; 27, identifier:stmt; 28, call; 28, 29; 28, 30; 29, identifier:enumerate; 30, argument_list; 30, 31; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:stmts; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 45; 37, attribute; 37, 38; 37, 44; 38, subscript; 38, 39; 38, 40; 39, identifier:stmts_by_type; 40, call; 40, 41; 40, 42; 41, identifier:indra_stmt_type; 42, argument_list; 42, 43; 43, identifier:stmt; 44, identifier:append; 45, argument_list; 45, 46; 46, tuple; 46, 47; 46, 48; 47, identifier:idx; 48, identifier:stmt; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:pos_stmts; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:AddModification; 55, identifier:__subclasses__; 56, argument_list; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:neg_stmts; 60, list_comprehension; 60, 61; 60, 64; 61, subscript; 61, 62; 61, 63; 62, identifier:modclass_to_inverse; 63, identifier:c; 64, for_in_clause; 64, 65; 64, 66; 65, identifier:c; 66, identifier:pos_stmts; 67, expression_statement; 67, 68; 68, augmented_assignment:+=; 68, 69; 68, 70; 69, identifier:pos_stmts; 70, list:[Activation, IncreaseAmount]; 70, 71; 70, 72; 71, identifier:Activation; 72, identifier:IncreaseAmount; 73, expression_statement; 73, 74; 74, augmented_assignment:+=; 74, 75; 74, 76; 75, identifier:neg_stmts; 76, list:[Inhibition, DecreaseAmount]; 76, 77; 76, 78; 77, identifier:Inhibition; 78, identifier:DecreaseAmount; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:contradicts; 82, list:[]; 83, for_statement; 83, 84; 83, 87; 83, 92; 84, pattern_list; 84, 85; 84, 86; 85, identifier:pst; 86, identifier:nst; 87, call; 87, 88; 87, 89; 88, identifier:zip; 89, argument_list; 89, 90; 89, 91; 90, identifier:pos_stmts; 91, identifier:neg_stmts; 92, block; 92, 93; 92, 103; 92, 113; 92, 124; 92, 135; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:poss; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:stmts_by_type; 99, identifier:get; 100, argument_list; 100, 101; 100, 102; 101, identifier:pst; 102, list:[]; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:negs; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:stmts_by_type; 109, identifier:get; 110, argument_list; 110, 111; 110, 112; 111, identifier:nst; 112, list:[]; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:pos_stmt_by_group; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:self; 119, identifier:_get_stmt_by_group; 120, argument_list; 120, 121; 120, 122; 120, 123; 121, identifier:pst; 122, identifier:poss; 123, identifier:eh; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:neg_stmt_by_group; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:_get_stmt_by_group; 131, argument_list; 131, 132; 131, 133; 131, 134; 132, identifier:nst; 133, identifier:negs; 134, identifier:eh; 135, for_statement; 135, 136; 135, 139; 135, 144; 136, pattern_list; 136, 137; 136, 138; 137, identifier:key; 138, identifier:pg; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:pos_stmt_by_group; 142, identifier:items; 143, argument_list; 144, block; 144, 145; 144, 155; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:ng; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:neg_stmt_by_group; 151, identifier:get; 152, argument_list; 152, 153; 152, 154; 153, identifier:key; 154, list:[]; 155, for_statement; 155, 156; 155, 163; 155, 170; 156, pattern_list; 156, 157; 156, 160; 157, tuple_pattern; 157, 158; 157, 159; 158, identifier:_; 159, identifier:st1; 160, tuple_pattern; 160, 161; 160, 162; 161, identifier:_; 162, identifier:st2; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:itertools; 166, identifier:product; 167, argument_list; 167, 168; 167, 169; 168, identifier:pg; 169, identifier:ng; 170, block; 170, 171; 171, if_statement; 171, 172; 171, 181; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:st1; 175, identifier:contradicts; 176, argument_list; 176, 177; 176, 178; 177, identifier:st2; 178, attribute; 178, 179; 178, 180; 179, identifier:self; 180, identifier:hierarchies; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:contradicts; 186, identifier:append; 187, argument_list; 187, 188; 188, tuple; 188, 189; 188, 190; 189, identifier:st1; 190, identifier:st2; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:neu_stmts; 194, list:[Influence, ActiveForm]; 194, 195; 194, 196; 195, identifier:Influence; 196, identifier:ActiveForm; 197, for_statement; 197, 198; 197, 199; 197, 200; 198, identifier:stt; 199, identifier:neu_stmts; 200, block; 200, 201; 200, 211; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:stmts; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:stmts_by_type; 207, identifier:get; 208, argument_list; 208, 209; 208, 210; 209, identifier:stt; 210, list:[]; 211, for_statement; 211, 212; 211, 219; 211, 226; 212, pattern_list; 212, 213; 212, 216; 213, tuple_pattern; 213, 214; 213, 215; 214, identifier:_; 215, identifier:st1; 216, tuple_pattern; 216, 217; 216, 218; 217, identifier:_; 218, identifier:st2; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:itertools; 222, identifier:combinations; 223, argument_list; 223, 224; 223, 225; 224, identifier:stmts; 225, integer:2; 226, block; 226, 227; 227, if_statement; 227, 228; 227, 237; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:st1; 231, identifier:contradicts; 232, argument_list; 232, 233; 232, 234; 233, identifier:st2; 234, attribute; 234, 235; 234, 236; 235, identifier:self; 236, identifier:hierarchies; 237, block; 237, 238; 238, expression_statement; 238, 239; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:contradicts; 242, identifier:append; 243, argument_list; 243, 244; 244, tuple; 244, 245; 244, 246; 245, identifier:st1; 246, identifier:st2; 247, return_statement; 247, 248; 248, identifier:contradicts | def find_contradicts(self):
eh = self.hierarchies['entity']
stmts_by_type = collections.defaultdict(lambda: [])
for idx, stmt in enumerate(self.stmts):
stmts_by_type[indra_stmt_type(stmt)].append((idx, stmt))
pos_stmts = AddModification.__subclasses__()
neg_stmts = [modclass_to_inverse[c] for c in pos_stmts]
pos_stmts += [Activation, IncreaseAmount]
neg_stmts += [Inhibition, DecreaseAmount]
contradicts = []
for pst, nst in zip(pos_stmts, neg_stmts):
poss = stmts_by_type.get(pst, [])
negs = stmts_by_type.get(nst, [])
pos_stmt_by_group = self._get_stmt_by_group(pst, poss, eh)
neg_stmt_by_group = self._get_stmt_by_group(nst, negs, eh)
for key, pg in pos_stmt_by_group.items():
ng = neg_stmt_by_group.get(key, [])
for (_, st1), (_, st2) in itertools.product(pg, ng):
if st1.contradicts(st2, self.hierarchies):
contradicts.append((st1, st2))
neu_stmts = [Influence, ActiveForm]
for stt in neu_stmts:
stmts = stmts_by_type.get(stt, [])
for (_, st1), (_, st2) in itertools.combinations(stmts, 2):
if st1.contradicts(st2, self.hierarchies):
contradicts.append((st1, st2))
return contradicts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_text_content_for_pmids; 3, parameters; 3, 4; 4, identifier:pmids; 5, block; 5, 6; 5, 21; 5, 25; 5, 62; 5, 66; 5, 72; 5, 109; 5, 120; 5, 124; 5, 151; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:pmc_pmids; 9, call; 9, 10; 9, 11; 10, identifier:set; 11, argument_list; 11, 12; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:pmc_client; 15, identifier:filter_pmids; 16, argument_list; 16, 17; 16, 18; 17, identifier:pmids; 18, keyword_argument; 18, 19; 18, 20; 19, identifier:source_type; 20, string:'fulltext'; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:pmc_ids; 24, list:[]; 25, for_statement; 25, 26; 25, 27; 25, 28; 26, identifier:pmid; 27, identifier:pmc_pmids; 28, block; 28, 29; 28, 43; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:pmc_id; 32, subscript; 32, 33; 32, 42; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:pmc_client; 36, identifier:id_lookup; 37, argument_list; 37, 38; 37, 39; 38, identifier:pmid; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:idtype; 41, string:'pmid'; 42, string:'pmcid'; 43, if_statement; 43, 44; 43, 45; 43, 53; 44, identifier:pmc_id; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:pmc_ids; 50, identifier:append; 51, argument_list; 51, 52; 52, identifier:pmc_id; 53, else_clause; 53, 54; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:pmc_pmids; 59, identifier:discard; 60, argument_list; 60, 61; 61, identifier:pmid; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:pmc_xmls; 65, list:[]; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:failed; 69, call; 69, 70; 69, 71; 70, identifier:set; 71, argument_list; 72, for_statement; 72, 73; 72, 74; 72, 75; 73, identifier:pmc_id; 74, identifier:pmc_ids; 75, block; 75, 76; 75, 102; 76, if_statement; 76, 77; 76, 80; 76, 93; 77, comparison_operator:is; 77, 78; 77, 79; 78, identifier:pmc_id; 79, None; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:pmc_xmls; 85, identifier:append; 86, argument_list; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:pmc_client; 90, identifier:get_xml; 91, argument_list; 91, 92; 92, identifier:pmc_id; 93, else_clause; 93, 94; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:failed; 99, identifier:append; 100, argument_list; 100, 101; 101, identifier:pmid; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:time; 106, identifier:sleep; 107, argument_list; 107, 108; 108, float:0.5; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:remaining_pmids; 112, binary_operator:|; 112, 113; 112, 119; 113, binary_operator:-; 113, 114; 113, 118; 114, call; 114, 115; 114, 116; 115, identifier:set; 116, argument_list; 116, 117; 117, identifier:pmids; 118, identifier:pmc_pmids; 119, identifier:failed; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:abstracts; 123, list:[]; 124, for_statement; 124, 125; 124, 126; 124, 127; 125, identifier:pmid; 126, identifier:remaining_pmids; 127, block; 127, 128; 127, 137; 127, 144; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:abstract; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:pubmed_client; 134, identifier:get_abstract; 135, argument_list; 135, 136; 136, identifier:pmid; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:abstracts; 141, identifier:append; 142, argument_list; 142, 143; 143, identifier:abstract; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:time; 148, identifier:sleep; 149, argument_list; 149, 150; 150, float:0.5; 151, return_statement; 151, 152; 152, list_comprehension; 152, 153; 152, 154; 152, 159; 152, 162; 153, identifier:text_content; 154, for_in_clause; 154, 155; 154, 156; 155, identifier:source; 156, tuple; 156, 157; 156, 158; 157, identifier:pmc_xmls; 158, identifier:abstracts; 159, for_in_clause; 159, 160; 159, 161; 160, identifier:text_content; 161, identifier:source; 162, if_clause; 162, 163; 163, comparison_operator:is; 163, 164; 163, 165; 164, identifier:text_content; 165, None | def get_text_content_for_pmids(pmids):
pmc_pmids = set(pmc_client.filter_pmids(pmids, source_type='fulltext'))
pmc_ids = []
for pmid in pmc_pmids:
pmc_id = pmc_client.id_lookup(pmid, idtype='pmid')['pmcid']
if pmc_id:
pmc_ids.append(pmc_id)
else:
pmc_pmids.discard(pmid)
pmc_xmls = []
failed = set()
for pmc_id in pmc_ids:
if pmc_id is not None:
pmc_xmls.append(pmc_client.get_xml(pmc_id))
else:
failed.append(pmid)
time.sleep(0.5)
remaining_pmids = set(pmids) - pmc_pmids | failed
abstracts = []
for pmid in remaining_pmids:
abstract = pubmed_client.get_abstract(pmid)
abstracts.append(abstract)
time.sleep(0.5)
return [text_content for source in (pmc_xmls, abstracts)
for text_content in source if text_content is not None] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:export_sbgn; 3, parameters; 3, 4; 4, identifier:model; 5, block; 5, 6; 5, 10; 5, 14; 5, 20; 5, 27; 5, 36; 5, 41; 5, 47; 5, 51; 5, 92; 5, 314; 5, 327; 6, import_statement; 6, 7; 7, dotted_name; 7, 8; 7, 9; 8, identifier:lxml; 9, identifier:etree; 10, import_statement; 10, 11; 11, dotted_name; 11, 12; 11, 13; 12, identifier:lxml; 13, identifier:builder; 14, import_from_statement; 14, 15; 14, 18; 15, dotted_name; 15, 16; 15, 17; 16, identifier:pysb; 17, identifier:bng; 18, dotted_name; 18, 19; 19, identifier:generate_equations; 20, import_from_statement; 20, 21; 20, 25; 21, dotted_name; 21, 22; 21, 23; 21, 24; 22, identifier:indra; 23, identifier:assemblers; 24, identifier:sbgn; 25, dotted_name; 25, 26; 26, identifier:SBGNAssembler; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:logger; 31, identifier:info; 32, argument_list; 32, 33; 33, binary_operator:+; 33, 34; 33, 35; 34, string:'Generating reaction network with BNG for SBGN export. '; 35, string:'This could take a long time.'; 36, expression_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:generate_equations; 39, argument_list; 39, 40; 40, identifier:model; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:sa; 44, call; 44, 45; 44, 46; 45, identifier:SBGNAssembler; 46, argument_list; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:glyphs; 50, dictionary; 51, for_statement; 51, 52; 51, 55; 51, 61; 52, pattern_list; 52, 53; 52, 54; 53, identifier:idx; 54, identifier:species; 55, call; 55, 56; 55, 57; 56, identifier:enumerate; 57, argument_list; 57, 58; 58, attribute; 58, 59; 58, 60; 59, identifier:model; 60, identifier:species; 61, block; 61, 62; 61, 71; 61, 77; 61, 86; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:glyph; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:sa; 68, identifier:_glyph_for_complex_pattern; 69, argument_list; 69, 70; 70, identifier:species; 71, if_statement; 71, 72; 71, 75; 72, comparison_operator:is; 72, 73; 72, 74; 73, identifier:glyph; 74, None; 75, block; 75, 76; 76, continue_statement; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 84; 79, attribute; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:sa; 82, identifier:_map; 83, identifier:append; 84, argument_list; 84, 85; 85, identifier:glyph; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 91; 88, subscript; 88, 89; 88, 90; 89, identifier:glyphs; 90, identifier:idx; 91, identifier:glyph; 92, for_statement; 92, 93; 92, 94; 92, 97; 93, identifier:reaction; 94, attribute; 94, 95; 94, 96; 95, identifier:model; 96, identifier:reactions; 97, block; 97, 98; 97, 114; 97, 130; 97, 146; 97, 155; 97, 223; 97, 291; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:reactants; 101, binary_operator:-; 101, 102; 101, 108; 102, call; 102, 103; 102, 104; 103, identifier:set; 104, argument_list; 104, 105; 105, subscript; 105, 106; 105, 107; 106, identifier:reaction; 107, string:'reactants'; 108, call; 108, 109; 108, 110; 109, identifier:set; 110, argument_list; 110, 111; 111, subscript; 111, 112; 111, 113; 112, identifier:reaction; 113, string:'products'; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:products; 117, binary_operator:-; 117, 118; 117, 124; 118, call; 118, 119; 118, 120; 119, identifier:set; 120, argument_list; 120, 121; 121, subscript; 121, 122; 121, 123; 122, identifier:reaction; 123, string:'products'; 124, call; 124, 125; 124, 126; 125, identifier:set; 126, argument_list; 126, 127; 127, subscript; 127, 128; 127, 129; 128, identifier:reaction; 129, string:'reactants'; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:controllers; 133, binary_operator:&; 133, 134; 133, 140; 134, call; 134, 135; 134, 136; 135, identifier:set; 136, argument_list; 136, 137; 137, subscript; 137, 138; 137, 139; 138, identifier:reaction; 139, string:'reactants'; 140, call; 140, 141; 140, 142; 141, identifier:set; 142, argument_list; 142, 143; 143, subscript; 143, 144; 143, 145; 144, identifier:reaction; 145, string:'products'; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:process_glyph; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:sa; 152, identifier:_process_glyph; 153, argument_list; 153, 154; 154, string:'process'; 155, if_statement; 155, 156; 155, 158; 155, 176; 156, not_operator; 156, 157; 157, identifier:reactants; 158, block; 158, 159; 158, 167; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:glyph_id; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:sa; 165, identifier:_none_glyph; 166, argument_list; 167, expression_statement; 167, 168; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:sa; 171, identifier:_arc; 172, argument_list; 172, 173; 172, 174; 172, 175; 173, string:'consumption'; 174, identifier:glyph_id; 175, identifier:process_glyph; 176, else_clause; 176, 177; 177, block; 177, 178; 178, for_statement; 178, 179; 178, 180; 178, 181; 179, identifier:r; 180, identifier:reactants; 181, block; 181, 182; 181, 191; 181, 214; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:glyph; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:glyphs; 188, identifier:get; 189, argument_list; 189, 190; 190, identifier:r; 191, if_statement; 191, 192; 191, 195; 191, 204; 192, comparison_operator:is; 192, 193; 192, 194; 193, identifier:glyph; 194, None; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:glyph_id; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:sa; 202, identifier:_none_glyph; 203, argument_list; 204, else_clause; 204, 205; 205, block; 205, 206; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:glyph_id; 209, subscript; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:glyph; 212, identifier:attrib; 213, string:'id'; 214, expression_statement; 214, 215; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:sa; 218, identifier:_arc; 219, argument_list; 219, 220; 219, 221; 219, 222; 220, string:'consumption'; 221, identifier:glyph_id; 222, identifier:process_glyph; 223, if_statement; 223, 224; 223, 226; 223, 244; 224, not_operator; 224, 225; 225, identifier:products; 226, block; 226, 227; 226, 235; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:glyph_id; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:sa; 233, identifier:_none_glyph; 234, argument_list; 235, expression_statement; 235, 236; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:sa; 239, identifier:_arc; 240, argument_list; 240, 241; 240, 242; 240, 243; 241, string:'production'; 242, identifier:process_glyph; 243, identifier:glyph_id; 244, else_clause; 244, 245; 245, block; 245, 246; 246, for_statement; 246, 247; 246, 248; 246, 249; 247, identifier:p; 248, identifier:products; 249, block; 249, 250; 249, 259; 249, 282; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:glyph; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:glyphs; 256, identifier:get; 257, argument_list; 257, 258; 258, identifier:p; 259, if_statement; 259, 260; 259, 263; 259, 272; 260, comparison_operator:is; 260, 261; 260, 262; 261, identifier:glyph; 262, None; 263, block; 263, 264; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 267; 266, identifier:glyph_id; 267, call; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, identifier:sa; 270, identifier:_none_glyph; 271, argument_list; 272, else_clause; 272, 273; 273, block; 273, 274; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 277; 276, identifier:glyph_id; 277, subscript; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:glyph; 280, identifier:attrib; 281, string:'id'; 282, expression_statement; 282, 283; 283, call; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:sa; 286, identifier:_arc; 287, argument_list; 287, 288; 287, 289; 287, 290; 288, string:'production'; 289, identifier:process_glyph; 290, identifier:glyph_id; 291, for_statement; 291, 292; 291, 293; 291, 294; 292, identifier:c; 293, identifier:controllers; 294, block; 294, 295; 294, 301; 295, expression_statement; 295, 296; 296, assignment; 296, 297; 296, 298; 297, identifier:glyph; 298, subscript; 298, 299; 298, 300; 299, identifier:glyphs; 300, identifier:c; 301, expression_statement; 301, 302; 302, call; 302, 303; 302, 306; 303, attribute; 303, 304; 303, 305; 304, identifier:sa; 305, identifier:_arc; 306, argument_list; 306, 307; 306, 308; 306, 313; 307, string:'catalysis'; 308, subscript; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:glyph; 311, identifier:attrib; 312, string:'id'; 313, identifier:process_glyph; 314, expression_statement; 314, 315; 315, assignment; 315, 316; 315, 317; 316, identifier:sbgn_str; 317, call; 317, 318; 317, 325; 318, attribute; 318, 319; 318, 324; 319, call; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:sa; 322, identifier:print_model; 323, argument_list; 324, identifier:decode; 325, argument_list; 325, 326; 326, string:'utf-8'; 327, return_statement; 327, 328; 328, identifier:sbgn_str | def export_sbgn(model):
import lxml.etree
import lxml.builder
from pysb.bng import generate_equations
from indra.assemblers.sbgn import SBGNAssembler
logger.info('Generating reaction network with BNG for SBGN export. ' +
'This could take a long time.')
generate_equations(model)
sa = SBGNAssembler()
glyphs = {}
for idx, species in enumerate(model.species):
glyph = sa._glyph_for_complex_pattern(species)
if glyph is None:
continue
sa._map.append(glyph)
glyphs[idx] = glyph
for reaction in model.reactions:
reactants = set(reaction['reactants']) - set(reaction['products'])
products = set(reaction['products']) - set(reaction['reactants'])
controllers = set(reaction['reactants']) & set(reaction['products'])
process_glyph = sa._process_glyph('process')
if not reactants:
glyph_id = sa._none_glyph()
sa._arc('consumption', glyph_id, process_glyph)
else:
for r in reactants:
glyph = glyphs.get(r)
if glyph is None:
glyph_id = sa._none_glyph()
else:
glyph_id = glyph.attrib['id']
sa._arc('consumption', glyph_id, process_glyph)
if not products:
glyph_id = sa._none_glyph()
sa._arc('production', process_glyph, glyph_id)
else:
for p in products:
glyph = glyphs.get(p)
if glyph is None:
glyph_id = sa._none_glyph()
else:
glyph_id = glyph.attrib['id']
sa._arc('production', process_glyph, glyph_id)
for c in controllers:
glyph = glyphs[c]
sa._arc('catalysis', glyph.attrib['id'], process_glyph)
sbgn_str = sa.print_model().decode('utf-8')
return sbgn_str |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:get_profile_data; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:study_id; 5, identifier:gene_list; 6, identifier:profile_filter; 7, default_parameter; 7, 8; 7, 9; 8, identifier:case_set_filter; 9, None; 10, block; 10, 11; 10, 19; 10, 32; 10, 41; 10, 48; 10, 73; 10, 93; 10, 101; 10, 121; 10, 137; 10, 188; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:genetic_profiles; 14, call; 14, 15; 14, 16; 15, identifier:get_genetic_profiles; 16, argument_list; 16, 17; 16, 18; 17, identifier:study_id; 18, identifier:profile_filter; 19, if_statement; 19, 20; 19, 21; 19, 28; 20, identifier:genetic_profiles; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:genetic_profile; 25, subscript; 25, 26; 25, 27; 26, identifier:genetic_profiles; 27, integer:0; 28, else_clause; 28, 29; 29, block; 29, 30; 30, return_statement; 30, 31; 31, dictionary; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:gene_list_str; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, string:','; 38, identifier:join; 39, argument_list; 39, 40; 40, identifier:gene_list; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:case_set_ids; 44, call; 44, 45; 44, 46; 45, identifier:get_case_lists; 46, argument_list; 46, 47; 47, identifier:study_id; 48, if_statement; 48, 49; 48, 50; 48, 65; 49, identifier:case_set_filter; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:case_set_id; 54, subscript; 54, 55; 54, 64; 55, list_comprehension; 55, 56; 55, 57; 55, 60; 56, identifier:x; 57, for_in_clause; 57, 58; 57, 59; 58, identifier:x; 59, identifier:case_set_ids; 60, if_clause; 60, 61; 61, comparison_operator:in; 61, 62; 61, 63; 62, identifier:case_set_filter; 63, identifier:x; 64, integer:0; 65, else_clause; 65, 66; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:case_set_id; 70, binary_operator:+; 70, 71; 70, 72; 71, identifier:study_id; 72, string:'_all'; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:data; 76, dictionary; 76, 77; 76, 80; 76, 83; 76, 86; 76, 89; 77, pair; 77, 78; 77, 79; 78, string:'cmd'; 79, string:'getProfileData'; 80, pair; 80, 81; 80, 82; 81, string:'case_set_id'; 82, identifier:case_set_id; 83, pair; 83, 84; 83, 85; 84, string:'genetic_profile_id'; 85, identifier:genetic_profile; 86, pair; 86, 87; 86, 88; 87, string:'gene_list'; 88, identifier:gene_list_str; 89, pair; 89, 90; 89, 91; 90, string:'skiprows'; 91, unary_operator:-; 91, 92; 92, integer:1; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:df; 96, call; 96, 97; 96, 98; 97, identifier:send_request; 98, argument_list; 98, 99; 99, dictionary_splat; 99, 100; 100, identifier:data; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:case_list_df; 104, list_comprehension; 104, 105; 104, 106; 104, 115; 105, identifier:x; 106, for_in_clause; 106, 107; 106, 108; 107, identifier:x; 108, call; 108, 109; 108, 114; 109, attribute; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:df; 112, identifier:columns; 113, identifier:tolist; 114, argument_list; 115, if_clause; 115, 116; 116, comparison_operator:not; 116, 117; 116, 118; 117, identifier:x; 118, list:['GENE_ID', 'COMMON']; 118, 119; 118, 120; 119, string:'GENE_ID'; 120, string:'COMMON'; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:profile_data; 124, dictionary_comprehension; 124, 125; 124, 134; 125, pair; 125, 126; 125, 127; 126, identifier:case; 127, dictionary_comprehension; 127, 128; 127, 131; 128, pair; 128, 129; 128, 130; 129, identifier:g; 130, None; 131, for_in_clause; 131, 132; 131, 133; 132, identifier:g; 133, identifier:gene_list; 134, for_in_clause; 134, 135; 134, 136; 135, identifier:case; 136, identifier:case_list_df; 137, for_statement; 137, 138; 137, 139; 137, 140; 138, identifier:case; 139, identifier:case_list_df; 140, block; 140, 141; 140, 151; 140, 161; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:profile_values; 144, call; 144, 145; 144, 150; 145, attribute; 145, 146; 145, 149; 146, subscript; 146, 147; 146, 148; 147, identifier:df; 148, identifier:case; 149, identifier:tolist; 150, argument_list; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:df_gene_list; 154, call; 154, 155; 154, 160; 155, attribute; 155, 156; 155, 159; 156, subscript; 156, 157; 156, 158; 157, identifier:df; 158, string:'COMMON'; 159, identifier:tolist; 160, argument_list; 161, for_statement; 161, 162; 161, 165; 161, 170; 162, pattern_list; 162, 163; 162, 164; 163, identifier:g; 164, identifier:cv; 165, call; 165, 166; 165, 167; 166, identifier:zip; 167, argument_list; 167, 168; 167, 169; 168, identifier:df_gene_list; 169, identifier:profile_values; 170, block; 170, 171; 171, if_statement; 171, 172; 171, 179; 172, not_operator; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:pandas; 176, identifier:isnull; 177, argument_list; 177, 178; 178, identifier:cv; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 187; 182, subscript; 182, 183; 182, 186; 183, subscript; 183, 184; 183, 185; 184, identifier:profile_data; 185, identifier:case; 186, identifier:g; 187, identifier:cv; 188, return_statement; 188, 189; 189, identifier:profile_data | def get_profile_data(study_id, gene_list,
profile_filter, case_set_filter=None):
genetic_profiles = get_genetic_profiles(study_id, profile_filter)
if genetic_profiles:
genetic_profile = genetic_profiles[0]
else:
return {}
gene_list_str = ','.join(gene_list)
case_set_ids = get_case_lists(study_id)
if case_set_filter:
case_set_id = [x for x in case_set_ids if case_set_filter in x][0]
else:
case_set_id = study_id + '_all'
data = {'cmd': 'getProfileData',
'case_set_id': case_set_id,
'genetic_profile_id': genetic_profile,
'gene_list': gene_list_str,
'skiprows': -1}
df = send_request(**data)
case_list_df = [x for x in df.columns.tolist()
if x not in ['GENE_ID', 'COMMON']]
profile_data = {case: {g: None for g in gene_list}
for case in case_list_df}
for case in case_list_df:
profile_values = df[case].tolist()
df_gene_list = df['COMMON'].tolist()
for g, cv in zip(df_gene_list, profile_values):
if not pandas.isnull(cv):
profile_data[case][g] = cv
return profile_data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:print_cx; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:pretty; 7, True; 8, block; 8, 9; 8, 64; 8, 70; 8, 80; 8, 94; 8, 100; 8, 123; 8, 141; 8, 154; 8, 171; 8, 197; 9, function_definition; 9, 10; 9, 11; 9, 13; 10, function_name:_get_aspect_metadata; 11, parameters; 11, 12; 12, identifier:aspect; 13, block; 13, 14; 13, 38; 13, 44; 13, 62; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:count; 17, conditional_expression:if; 17, 18; 17, 29; 17, 37; 18, call; 18, 19; 18, 20; 19, identifier:len; 20, argument_list; 20, 21; 21, call; 21, 22; 21, 27; 22, attribute; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:cx; 26, identifier:get; 27, argument_list; 27, 28; 28, identifier:aspect; 29, call; 29, 30; 29, 35; 30, attribute; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:cx; 34, identifier:get; 35, argument_list; 35, 36; 36, identifier:aspect; 37, integer:0; 38, if_statement; 38, 39; 38, 41; 39, not_operator; 39, 40; 40, identifier:count; 41, block; 41, 42; 42, return_statement; 42, 43; 43, None; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:data; 47, dictionary; 47, 48; 47, 51; 47, 56; 47, 59; 48, pair; 48, 49; 48, 50; 49, string:'name'; 50, identifier:aspect; 51, pair; 51, 52; 51, 53; 52, string:'idCounter'; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:_id_counter; 56, pair; 56, 57; 56, 58; 57, string:'consistencyGroup'; 58, integer:1; 59, pair; 59, 60; 59, 61; 60, string:'elementCount'; 61, identifier:count; 62, return_statement; 62, 63; 63, identifier:data; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:full_cx; 67, call; 67, 68; 67, 69; 68, identifier:OrderedDict; 69, argument_list; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 75; 72, subscript; 72, 73; 72, 74; 73, identifier:full_cx; 74, string:'numberVerification'; 75, list:[{'longNumber': 281474976710655}]; 75, 76; 76, dictionary; 76, 77; 77, pair; 77, 78; 77, 79; 78, string:'longNumber'; 79, integer:281474976710655; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:aspects; 83, list:['nodes', 'edges', 'supports', 'citations', 'edgeAttributes',
'edgeCitations', 'edgeSupports', 'networkAttributes',
'nodeAttributes', 'cartesianLayout']; 83, 84; 83, 85; 83, 86; 83, 87; 83, 88; 83, 89; 83, 90; 83, 91; 83, 92; 83, 93; 84, string:'nodes'; 85, string:'edges'; 86, string:'supports'; 87, string:'citations'; 88, string:'edgeAttributes'; 89, string:'edgeCitations'; 90, string:'edgeSupports'; 91, string:'networkAttributes'; 92, string:'nodeAttributes'; 93, string:'cartesianLayout'; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 99; 96, subscript; 96, 97; 96, 98; 97, identifier:full_cx; 98, string:'metaData'; 99, list:[]; 100, for_statement; 100, 101; 100, 102; 100, 103; 101, identifier:aspect; 102, identifier:aspects; 103, block; 103, 104; 103, 111; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:metadata; 107, call; 107, 108; 107, 109; 108, identifier:_get_aspect_metadata; 109, argument_list; 109, 110; 110, identifier:aspect; 111, if_statement; 111, 112; 111, 113; 112, identifier:metadata; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 121; 116, attribute; 116, 117; 116, 120; 117, subscript; 117, 118; 117, 119; 118, identifier:full_cx; 119, string:'metaData'; 120, identifier:append; 121, argument_list; 121, 122; 122, identifier:metadata; 123, for_statement; 123, 124; 123, 127; 123, 134; 124, pattern_list; 124, 125; 124, 126; 125, identifier:k; 126, identifier:v; 127, call; 127, 128; 127, 133; 128, attribute; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:cx; 132, identifier:items; 133, argument_list; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 140; 137, subscript; 137, 138; 137, 139; 138, identifier:full_cx; 139, identifier:k; 140, identifier:v; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 146; 143, subscript; 143, 144; 143, 145; 144, identifier:full_cx; 145, string:'status'; 146, list:[{'error': '', 'success': True}]; 146, 147; 147, dictionary; 147, 148; 147, 151; 148, pair; 148, 149; 148, 150; 149, string:'error'; 150, string:''; 151, pair; 151, 152; 151, 153; 152, string:'success'; 153, True; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:full_cx; 157, list_comprehension; 157, 158; 157, 162; 158, dictionary; 158, 159; 159, pair; 159, 160; 159, 161; 160, identifier:k; 161, identifier:v; 162, for_in_clause; 162, 163; 162, 166; 163, pattern_list; 163, 164; 163, 165; 164, identifier:k; 165, identifier:v; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:full_cx; 169, identifier:items; 170, argument_list; 171, if_statement; 171, 172; 171, 173; 171, 186; 172, identifier:pretty; 173, block; 173, 174; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:json_str; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:json; 180, identifier:dumps; 181, argument_list; 181, 182; 181, 183; 182, identifier:full_cx; 183, keyword_argument; 183, 184; 183, 185; 184, identifier:indent; 185, integer:2; 186, else_clause; 186, 187; 187, block; 187, 188; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:json_str; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:json; 194, identifier:dumps; 195, argument_list; 195, 196; 196, identifier:full_cx; 197, return_statement; 197, 198; 198, identifier:json_str | def print_cx(self, pretty=True):
def _get_aspect_metadata(aspect):
count = len(self.cx.get(aspect)) if self.cx.get(aspect) else 0
if not count:
return None
data = {'name': aspect,
'idCounter': self._id_counter,
'consistencyGroup': 1,
'elementCount': count}
return data
full_cx = OrderedDict()
full_cx['numberVerification'] = [{'longNumber': 281474976710655}]
aspects = ['nodes', 'edges', 'supports', 'citations', 'edgeAttributes',
'edgeCitations', 'edgeSupports', 'networkAttributes',
'nodeAttributes', 'cartesianLayout']
full_cx['metaData'] = []
for aspect in aspects:
metadata = _get_aspect_metadata(aspect)
if metadata:
full_cx['metaData'].append(metadata)
for k, v in self.cx.items():
full_cx[k] = v
full_cx['status'] = [{'error': '', 'success': True}]
full_cx = [{k: v} for k, v in full_cx.items()]
if pretty:
json_str = json.dumps(full_cx, indent=2)
else:
json_str = json.dumps(full_cx)
return json_str |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:set_context; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:cell_type; 6, block; 6, 7; 6, 21; 6, 32; 6, 43; 6, 52; 6, 61; 6, 79; 6, 97; 6, 105; 6, 122; 6, 126; 6, 241; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:node_names; 10, list_comprehension; 10, 11; 10, 14; 11, subscript; 11, 12; 11, 13; 12, identifier:node; 13, string:'n'; 14, for_in_clause; 14, 15; 14, 16; 15, identifier:node; 16, subscript; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:cx; 20, string:'nodes'; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:res_expr; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:context_client; 27, identifier:get_protein_expression; 28, argument_list; 28, 29; 28, 30; 29, identifier:node_names; 30, list:[cell_type]; 30, 31; 31, identifier:cell_type; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:res_mut; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:context_client; 38, identifier:get_mutations; 39, argument_list; 39, 40; 39, 41; 40, identifier:node_names; 41, list:[cell_type]; 41, 42; 42, identifier:cell_type; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:res_expr; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:res_expr; 49, identifier:get; 50, argument_list; 50, 51; 51, identifier:cell_type; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:res_mut; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:res_mut; 58, identifier:get; 59, argument_list; 59, 60; 60, identifier:cell_type; 61, if_statement; 61, 62; 61, 64; 62, not_operator; 62, 63; 63, identifier:res_expr; 64, block; 64, 65; 64, 72; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:msg; 68, binary_operator:%; 68, 69; 68, 70; 68, 71; 69, string:'Could not get protein expression for %s cell type.'; 70, line_continuation:\; 71, identifier:cell_type; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:logger; 76, identifier:warning; 77, argument_list; 77, 78; 78, identifier:msg; 79, if_statement; 79, 80; 79, 82; 80, not_operator; 80, 81; 81, identifier:res_mut; 82, block; 82, 83; 82, 90; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:msg; 86, binary_operator:%; 86, 87; 86, 88; 86, 89; 87, string:'Could not get mutational status for %s cell type.'; 88, line_continuation:\; 89, identifier:cell_type; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:logger; 94, identifier:warning; 95, argument_list; 95, 96; 96, identifier:msg; 97, if_statement; 97, 98; 97, 103; 98, boolean_operator:and; 98, 99; 98, 101; 99, not_operator; 99, 100; 100, identifier:res_expr; 101, not_operator; 101, 102; 102, identifier:res_mut; 103, block; 103, 104; 104, return_statement; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 114; 107, attribute; 107, 108; 107, 113; 108, subscript; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:self; 111, identifier:cx; 112, string:'networkAttributes'; 113, identifier:append; 114, argument_list; 114, 115; 115, dictionary; 115, 116; 115, 119; 116, pair; 116, 117; 116, 118; 117, string:'n'; 118, string:'cellular_context'; 119, pair; 119, 120; 119, 121; 120, string:'v'; 121, identifier:cell_type; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:counter; 125, integer:0; 126, for_statement; 126, 127; 126, 128; 126, 133; 127, identifier:node; 128, subscript; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:cx; 132, string:'nodes'; 133, block; 133, 134; 133, 145; 133, 156; 133, 190; 133, 228; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:amount; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:res_expr; 140, identifier:get; 141, argument_list; 141, 142; 142, subscript; 142, 143; 142, 144; 143, identifier:node; 144, string:'n'; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:mut; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:res_mut; 151, identifier:get; 152, argument_list; 152, 153; 153, subscript; 153, 154; 153, 155; 154, identifier:node; 155, string:'n'; 156, if_statement; 156, 157; 156, 160; 157, comparison_operator:is; 157, 158; 157, 159; 158, identifier:amount; 159, None; 160, block; 160, 161; 160, 179; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:node_attribute; 164, dictionary; 164, 165; 164, 170; 164, 173; 165, pair; 165, 166; 165, 167; 166, string:'po'; 167, subscript; 167, 168; 167, 169; 168, identifier:node; 169, string:'@id'; 170, pair; 170, 171; 170, 172; 171, string:'n'; 172, string:'expression_amount'; 173, pair; 173, 174; 173, 175; 174, string:'v'; 175, call; 175, 176; 175, 177; 176, identifier:int; 177, argument_list; 177, 178; 178, identifier:amount; 179, expression_statement; 179, 180; 180, call; 180, 181; 180, 188; 181, attribute; 181, 182; 181, 187; 182, subscript; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:self; 185, identifier:cx; 186, string:'nodeAttributes'; 187, identifier:append; 188, argument_list; 188, 189; 189, identifier:node_attribute; 190, if_statement; 190, 191; 190, 194; 191, comparison_operator:is; 191, 192; 191, 193; 192, identifier:mut; 193, None; 194, block; 194, 195; 194, 202; 194, 217; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:is_mutated; 198, conditional_expression:if; 198, 199; 198, 200; 198, 201; 199, integer:1; 200, identifier:mut; 201, integer:0; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:node_attribute; 205, dictionary; 205, 206; 205, 211; 205, 214; 206, pair; 206, 207; 206, 208; 207, string:'po'; 208, subscript; 208, 209; 208, 210; 209, identifier:node; 210, string:'@id'; 211, pair; 211, 212; 211, 213; 212, string:'n'; 213, string:'is_mutated'; 214, pair; 214, 215; 214, 216; 215, string:'v'; 216, identifier:is_mutated; 217, expression_statement; 217, 218; 218, call; 218, 219; 218, 226; 219, attribute; 219, 220; 219, 225; 220, subscript; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:self; 223, identifier:cx; 224, string:'nodeAttributes'; 225, identifier:append; 226, argument_list; 226, 227; 227, identifier:node_attribute; 228, if_statement; 228, 229; 228, 236; 229, boolean_operator:or; 229, 230; 229, 233; 230, comparison_operator:is; 230, 231; 230, 232; 231, identifier:mut; 232, None; 233, comparison_operator:is; 233, 234; 233, 235; 234, identifier:amount; 235, None; 236, block; 236, 237; 237, expression_statement; 237, 238; 238, augmented_assignment:+=; 238, 239; 238, 240; 239, identifier:counter; 240, integer:1; 241, expression_statement; 241, 242; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:logger; 245, identifier:info; 246, argument_list; 246, 247; 247, binary_operator:%; 247, 248; 247, 249; 248, string:'Set context for %d nodes.'; 249, identifier:counter | def set_context(self, cell_type):
node_names = [node['n'] for node in self.cx['nodes']]
res_expr = context_client.get_protein_expression(node_names,
[cell_type])
res_mut = context_client.get_mutations(node_names,
[cell_type])
res_expr = res_expr.get(cell_type)
res_mut = res_mut.get(cell_type)
if not res_expr:
msg = 'Could not get protein expression for %s cell type.' % \
cell_type
logger.warning(msg)
if not res_mut:
msg = 'Could not get mutational status for %s cell type.' % \
cell_type
logger.warning(msg)
if not res_expr and not res_mut:
return
self.cx['networkAttributes'].append({'n': 'cellular_context',
'v': cell_type})
counter = 0
for node in self.cx['nodes']:
amount = res_expr.get(node['n'])
mut = res_mut.get(node['n'])
if amount is not None:
node_attribute = {'po': node['@id'],
'n': 'expression_amount',
'v': int(amount)}
self.cx['nodeAttributes'].append(node_attribute)
if mut is not None:
is_mutated = 1 if mut else 0
node_attribute = {'po': node['@id'],
'n': 'is_mutated',
'v': is_mutated}
self.cx['nodeAttributes'].append(node_attribute)
if mut is not None or amount is not None:
counter += 1
logger.info('Set context for %d nodes.' % counter) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:get_ids; 3, parameters; 3, 4; 3, 5; 4, identifier:search_term; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 18; 7, 25; 7, 44; 7, 51; 7, 59; 7, 66; 7, 92; 7, 132; 7, 146; 7, 155; 7, 162; 7, 172; 7, 195; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:use_text_word; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:kwargs; 14, identifier:pop; 15, argument_list; 15, 16; 15, 17; 16, string:'use_text_word'; 17, True; 18, if_statement; 18, 19; 18, 20; 19, identifier:use_text_word; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, augmented_assignment:+=; 22, 23; 22, 24; 23, identifier:search_term; 24, string:'[tw]'; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:params; 28, dictionary; 28, 29; 28, 32; 28, 35; 28, 38; 28, 41; 29, pair; 29, 30; 29, 31; 30, string:'term'; 31, identifier:search_term; 32, pair; 32, 33; 32, 34; 33, string:'retmax'; 34, integer:100000; 35, pair; 35, 36; 35, 37; 36, string:'retstart'; 37, integer:0; 38, pair; 38, 39; 38, 40; 39, string:'db'; 40, string:'pubmed'; 41, pair; 41, 42; 41, 43; 42, string:'sort'; 43, string:'pub+date'; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:params; 48, identifier:update; 49, argument_list; 49, 50; 50, identifier:kwargs; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:tree; 54, call; 54, 55; 54, 56; 55, identifier:send_request; 56, argument_list; 56, 57; 56, 58; 57, identifier:pubmed_search; 58, identifier:params; 59, if_statement; 59, 60; 59, 63; 60, comparison_operator:is; 60, 61; 60, 62; 61, identifier:tree; 62, None; 63, block; 63, 64; 64, return_statement; 64, 65; 65, list:[]; 66, if_statement; 66, 67; 66, 75; 67, comparison_operator:is; 67, 68; 67, 74; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:tree; 71, identifier:find; 72, argument_list; 72, 73; 73, string:'ERROR'; 74, None; 75, block; 75, 76; 75, 90; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:logger; 80, identifier:error; 81, argument_list; 81, 82; 82, attribute; 82, 83; 82, 89; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:tree; 86, identifier:find; 87, argument_list; 87, 88; 88, string:'ERROR'; 89, identifier:text; 90, return_statement; 90, 91; 91, list:[]; 92, if_statement; 92, 93; 92, 101; 93, comparison_operator:is; 93, 94; 93, 100; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:tree; 97, identifier:find; 98, argument_list; 98, 99; 99, string:'ErrorList'; 100, None; 101, block; 101, 102; 101, 130; 102, for_statement; 102, 103; 102, 104; 102, 114; 103, identifier:err; 104, call; 104, 105; 104, 113; 105, attribute; 105, 106; 105, 112; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:tree; 109, identifier:find; 110, argument_list; 110, 111; 111, string:'ErrorList'; 112, identifier:getchildren; 113, argument_list; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:logger; 119, identifier:error; 120, argument_list; 120, 121; 121, binary_operator:%; 121, 122; 121, 123; 122, string:'Error - %s: %s'; 123, tuple; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:err; 126, identifier:tag; 127, attribute; 127, 128; 127, 129; 128, identifier:err; 129, identifier:text; 130, return_statement; 130, 131; 131, list:[]; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:count; 135, call; 135, 136; 135, 137; 136, identifier:int; 137, argument_list; 137, 138; 138, attribute; 138, 139; 138, 145; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:tree; 142, identifier:find; 143, argument_list; 143, 144; 144, string:'Count'; 145, identifier:text; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:id_terms; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:tree; 152, identifier:findall; 153, argument_list; 153, 154; 154, string:'IdList/Id'; 155, if_statement; 155, 156; 155, 159; 156, comparison_operator:is; 156, 157; 156, 158; 157, identifier:id_terms; 158, None; 159, block; 159, 160; 160, return_statement; 160, 161; 161, list:[]; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:ids; 165, list_comprehension; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:idt; 168, identifier:text; 169, for_in_clause; 169, 170; 169, 171; 170, identifier:idt; 171, identifier:id_terms; 172, if_statement; 172, 173; 172, 179; 173, comparison_operator:!=; 173, 174; 173, 175; 174, identifier:count; 175, call; 175, 176; 175, 177; 176, identifier:len; 177, argument_list; 177, 178; 178, identifier:ids; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:logger; 184, identifier:warning; 185, argument_list; 185, 186; 186, binary_operator:%; 186, 187; 186, 190; 187, concatenated_string; 187, 188; 187, 189; 188, string:'Not all ids were retrieved for search %s;\n'; 189, string:'limited at %d.'; 190, tuple; 190, 191; 190, 192; 191, identifier:search_term; 192, subscript; 192, 193; 192, 194; 193, identifier:params; 194, string:'retmax'; 195, return_statement; 195, 196; 196, identifier:ids | def get_ids(search_term, **kwargs):
use_text_word = kwargs.pop('use_text_word', True)
if use_text_word:
search_term += '[tw]'
params = {'term': search_term,
'retmax': 100000,
'retstart': 0,
'db': 'pubmed',
'sort': 'pub+date'}
params.update(kwargs)
tree = send_request(pubmed_search, params)
if tree is None:
return []
if tree.find('ERROR') is not None:
logger.error(tree.find('ERROR').text)
return []
if tree.find('ErrorList') is not None:
for err in tree.find('ErrorList').getchildren():
logger.error('Error - %s: %s' % (err.tag, err.text))
return []
count = int(tree.find('Count').text)
id_terms = tree.findall('IdList/Id')
if id_terms is None:
return []
ids = [idt.text for idt in id_terms]
if count != len(ids):
logger.warning('Not all ids were retrieved for search %s;\n'
'limited at %d.' % (search_term, params['retmax']))
return ids |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:get_ids_for_gene; 3, parameters; 3, 4; 3, 5; 4, identifier:hgnc_name; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 17; 7, 27; 7, 36; 7, 46; 7, 59; 7, 66; 7, 74; 7, 81; 7, 107; 7, 116; 7, 123; 7, 139; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:hgnc_id; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:hgnc_client; 14, identifier:get_hgnc_id; 15, argument_list; 15, 16; 16, identifier:hgnc_name; 17, if_statement; 17, 18; 17, 21; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:hgnc_id; 20, None; 21, block; 21, 22; 22, raise_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:ValueError; 25, argument_list; 25, 26; 26, string:'Invalid HGNC name.'; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:entrez_id; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:hgnc_client; 33, identifier:get_entrez_id; 34, argument_list; 34, 35; 35, identifier:hgnc_id; 36, if_statement; 36, 37; 36, 40; 37, comparison_operator:is; 37, 38; 37, 39; 38, identifier:entrez_id; 39, None; 40, block; 40, 41; 41, raise_statement; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:ValueError; 44, argument_list; 44, 45; 45, string:'Entrez ID not found in HGNC table.'; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:params; 49, dictionary; 49, 50; 49, 53; 49, 56; 50, pair; 50, 51; 50, 52; 51, string:'db'; 52, string:'gene'; 53, pair; 53, 54; 53, 55; 54, string:'retmode'; 55, string:'xml'; 56, pair; 56, 57; 56, 58; 57, string:'id'; 58, identifier:entrez_id; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:params; 63, identifier:update; 64, argument_list; 64, 65; 65, identifier:kwargs; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:tree; 69, call; 69, 70; 69, 71; 70, identifier:send_request; 71, argument_list; 71, 72; 71, 73; 72, identifier:pubmed_fetch; 73, identifier:params; 74, if_statement; 74, 75; 74, 78; 75, comparison_operator:is; 75, 76; 75, 77; 76, identifier:tree; 77, None; 78, block; 78, 79; 79, return_statement; 79, 80; 80, list:[]; 81, if_statement; 81, 82; 81, 90; 82, comparison_operator:is; 82, 83; 82, 89; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:tree; 86, identifier:find; 87, argument_list; 87, 88; 88, string:'ERROR'; 89, None; 90, block; 90, 91; 90, 105; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:logger; 95, identifier:error; 96, argument_list; 96, 97; 97, attribute; 97, 98; 97, 104; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:tree; 101, identifier:find; 102, argument_list; 102, 103; 103, string:'ERROR'; 104, identifier:text; 105, return_statement; 105, 106; 106, list:[]; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:id_terms; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:tree; 113, identifier:findall; 114, argument_list; 114, 115; 115, string:'.//PubMedId'; 116, if_statement; 116, 117; 116, 120; 117, comparison_operator:is; 117, 118; 117, 119; 118, identifier:id_terms; 119, None; 120, block; 120, 121; 121, return_statement; 121, 122; 122, list:[]; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:ids; 126, call; 126, 127; 126, 128; 127, identifier:list; 128, argument_list; 128, 129; 129, call; 129, 130; 129, 131; 130, identifier:set; 131, argument_list; 131, 132; 132, list_comprehension; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:idt; 135, identifier:text; 136, for_in_clause; 136, 137; 136, 138; 137, identifier:idt; 138, identifier:id_terms; 139, return_statement; 139, 140; 140, identifier:ids | def get_ids_for_gene(hgnc_name, **kwargs):
hgnc_id = hgnc_client.get_hgnc_id(hgnc_name)
if hgnc_id is None:
raise ValueError('Invalid HGNC name.')
entrez_id = hgnc_client.get_entrez_id(hgnc_id)
if entrez_id is None:
raise ValueError('Entrez ID not found in HGNC table.')
params = {'db': 'gene',
'retmode': 'xml',
'id': entrez_id}
params.update(kwargs)
tree = send_request(pubmed_fetch, params)
if tree is None:
return []
if tree.find('ERROR') is not None:
logger.error(tree.find('ERROR').text)
return []
id_terms = tree.findall('.//PubMedId')
if id_terms is None:
return []
ids = list(set([idt.text for idt in id_terms]))
return ids |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_im; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:force_update; 7, False; 8, block; 8, 9; 8, 21; 8, 32; 8, 123; 8, 134; 8, 289; 8, 310; 8, 317; 8, 330; 8, 342; 8, 408; 9, if_statement; 9, 10; 9, 16; 10, boolean_operator:and; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:_im; 14, not_operator; 14, 15; 15, identifier:force_update; 16, block; 16, 17; 17, return_statement; 17, 18; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_im; 21, if_statement; 21, 22; 21, 26; 22, not_operator; 22, 23; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:model; 26, block; 26, 27; 27, raise_statement; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:Exception; 30, argument_list; 30, 31; 31, string:"Cannot get influence map if there is no model."; 32, function_definition; 32, 33; 32, 34; 32, 36; 33, function_name:add_obs_for_agent; 34, parameters; 34, 35; 35, identifier:agent; 36, block; 36, 37; 36, 52; 36, 68; 36, 72; 36, 121; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:obj_mps; 40, call; 40, 41; 40, 42; 41, identifier:list; 42, argument_list; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:pa; 46, identifier:grounded_monomer_patterns; 47, argument_list; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:model; 51, identifier:agent; 52, if_statement; 52, 53; 52, 55; 53, not_operator; 53, 54; 54, identifier:obj_mps; 55, block; 55, 56; 55, 67; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:logger; 60, identifier:debug; 61, argument_list; 61, 62; 62, binary_operator:%; 62, 63; 62, 66; 63, concatenated_string; 63, 64; 63, 65; 64, string:'No monomer patterns found in model for agent %s, '; 65, string:'skipping'; 66, identifier:agent; 67, return_statement; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:obs_list; 71, list:[]; 72, for_statement; 72, 73; 72, 74; 72, 75; 73, identifier:obj_mp; 74, identifier:obj_mps; 75, block; 75, 76; 75, 85; 75, 96; 75, 103; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:obs_name; 79, binary_operator:+; 79, 80; 79, 84; 80, call; 80, 81; 80, 82; 81, identifier:_monomer_pattern_label; 82, argument_list; 82, 83; 83, identifier:obj_mp; 84, string:'_obs'; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:obj_obs; 88, call; 88, 89; 88, 90; 89, identifier:Observable; 90, argument_list; 90, 91; 90, 92; 90, 93; 91, identifier:obs_name; 92, identifier:obj_mp; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:_export; 95, False; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:obs_list; 100, identifier:append; 101, argument_list; 101, 102; 102, identifier:obs_name; 103, try_statement; 103, 104; 103, 114; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 112; 107, attribute; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:model; 111, identifier:add_component; 112, argument_list; 112, 113; 113, identifier:obj_obs; 114, except_clause; 114, 115; 114, 119; 115, as_pattern; 115, 116; 115, 117; 116, identifier:ComponentDuplicateNameError; 117, as_pattern_target; 117, 118; 118, identifier:e; 119, block; 119, 120; 120, pass_statement; 121, return_statement; 121, 122; 122, identifier:obs_list; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 130; 125, attribute; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:model; 129, identifier:observables; 130, call; 130, 131; 130, 132; 131, identifier:ComponentSet; 132, argument_list; 132, 133; 133, list:[]; 134, for_statement; 134, 135; 134, 136; 134, 139; 135, identifier:stmt; 136, attribute; 136, 137; 136, 138; 137, identifier:self; 138, identifier:statements; 139, block; 139, 140; 140, if_statement; 140, 141; 140, 146; 140, 199; 140, 239; 140, 263; 141, call; 141, 142; 141, 143; 142, identifier:isinstance; 143, argument_list; 143, 144; 143, 145; 144, identifier:stmt; 145, identifier:Modification; 146, block; 146, 147; 146, 155; 146, 168; 146, 184; 146, 191; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:mod_condition_name; 150, subscript; 150, 151; 150, 152; 151, identifier:modclass_to_modtype; 152, attribute; 152, 153; 152, 154; 153, identifier:stmt; 154, identifier:__class__; 155, if_statement; 155, 156; 155, 161; 156, call; 156, 157; 156, 158; 157, identifier:isinstance; 158, argument_list; 158, 159; 158, 160; 159, identifier:stmt; 160, identifier:RemoveModification; 161, block; 161, 162; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:mod_condition_name; 165, subscript; 165, 166; 165, 167; 166, identifier:modtype_to_inverse; 167, identifier:mod_condition_name; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:modified_sub; 171, call; 171, 172; 171, 173; 172, identifier:_add_modification_to_agent; 173, argument_list; 173, 174; 173, 177; 173, 178; 173, 181; 174, attribute; 174, 175; 174, 176; 175, identifier:stmt; 176, identifier:sub; 177, identifier:mod_condition_name; 178, attribute; 178, 179; 178, 180; 179, identifier:stmt; 180, identifier:residue; 181, attribute; 181, 182; 181, 183; 182, identifier:stmt; 183, identifier:position; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:obs_list; 187, call; 187, 188; 187, 189; 188, identifier:add_obs_for_agent; 189, argument_list; 189, 190; 190, identifier:modified_sub; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 198; 193, subscript; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:self; 196, identifier:stmt_to_obs; 197, identifier:stmt; 198, identifier:obs_list; 199, elif_clause; 199, 200; 199, 205; 200, call; 200, 201; 200, 202; 201, identifier:isinstance; 202, argument_list; 202, 203; 202, 204; 203, identifier:stmt; 204, identifier:RegulateActivity; 205, block; 205, 206; 205, 224; 205, 231; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 211; 207, 212; 208, pattern_list; 208, 209; 208, 210; 209, identifier:regulated_obj; 210, identifier:polarity; 211, line_continuation:\; 212, call; 212, 213; 212, 214; 213, identifier:_add_activity_to_agent; 214, argument_list; 214, 215; 214, 218; 214, 221; 215, attribute; 215, 216; 215, 217; 216, identifier:stmt; 217, identifier:obj; 218, attribute; 218, 219; 218, 220; 219, identifier:stmt; 220, identifier:obj_activity; 221, attribute; 221, 222; 221, 223; 222, identifier:stmt; 223, identifier:is_activation; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:obs_list; 227, call; 227, 228; 227, 229; 228, identifier:add_obs_for_agent; 229, argument_list; 229, 230; 230, identifier:regulated_obj; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 238; 233, subscript; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:self; 236, identifier:stmt_to_obs; 237, identifier:stmt; 238, identifier:obs_list; 239, elif_clause; 239, 240; 239, 245; 240, call; 240, 241; 240, 242; 241, identifier:isinstance; 242, argument_list; 242, 243; 242, 244; 243, identifier:stmt; 244, identifier:RegulateAmount; 245, block; 245, 246; 245, 255; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:obs_list; 249, call; 249, 250; 249, 251; 250, identifier:add_obs_for_agent; 251, argument_list; 251, 252; 252, attribute; 252, 253; 252, 254; 253, identifier:stmt; 254, identifier:obj; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 262; 257, subscript; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:self; 260, identifier:stmt_to_obs; 261, identifier:stmt; 262, identifier:obs_list; 263, elif_clause; 263, 264; 263, 269; 264, call; 264, 265; 264, 266; 265, identifier:isinstance; 266, argument_list; 266, 267; 266, 268; 267, identifier:stmt; 268, identifier:Influence; 269, block; 269, 270; 269, 281; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 273; 272, identifier:obs_list; 273, call; 273, 274; 273, 275; 274, identifier:add_obs_for_agent; 275, argument_list; 275, 276; 276, attribute; 276, 277; 276, 280; 277, attribute; 277, 278; 277, 279; 278, identifier:stmt; 279, identifier:obj; 280, identifier:concept; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 288; 283, subscript; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:self; 286, identifier:stmt_to_obs; 287, identifier:stmt; 288, identifier:obs_list; 289, for_statement; 289, 290; 289, 291; 289, 294; 290, identifier:ag; 291, attribute; 291, 292; 291, 293; 292, identifier:self; 293, identifier:agent_obs; 294, block; 294, 295; 294, 302; 295, expression_statement; 295, 296; 296, assignment; 296, 297; 296, 298; 297, identifier:obs_list; 298, call; 298, 299; 298, 300; 299, identifier:add_obs_for_agent; 300, argument_list; 300, 301; 301, identifier:ag; 302, expression_statement; 302, 303; 303, assignment; 303, 304; 303, 309; 304, subscript; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:self; 307, identifier:agent_to_obs; 308, identifier:ag; 309, identifier:obs_list; 310, expression_statement; 310, 311; 311, call; 311, 312; 311, 315; 312, attribute; 312, 313; 312, 314; 313, identifier:logger; 314, identifier:info; 315, argument_list; 315, 316; 316, string:"Generating influence map"; 317, expression_statement; 317, 318; 318, assignment; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:self; 321, identifier:_im; 322, call; 322, 323; 322, 326; 323, attribute; 323, 324; 323, 325; 324, identifier:self; 325, identifier:generate_im; 326, argument_list; 326, 327; 327, attribute; 327, 328; 327, 329; 328, identifier:self; 329, identifier:model; 330, expression_statement; 330, 331; 331, assignment; 331, 332; 331, 333; 332, identifier:node_attributes; 333, call; 333, 334; 333, 337; 334, attribute; 334, 335; 334, 336; 335, identifier:nx; 336, identifier:get_node_attributes; 337, argument_list; 337, 338; 337, 341; 338, attribute; 338, 339; 338, 340; 339, identifier:self; 340, identifier:_im; 341, string:'node_type'; 342, for_statement; 342, 343; 342, 344; 342, 349; 343, identifier:rule; 344, attribute; 344, 345; 344, 348; 345, attribute; 345, 346; 345, 347; 346, identifier:self; 347, identifier:model; 348, identifier:rules; 349, block; 349, 350; 349, 354; 349, 398; 350, expression_statement; 350, 351; 351, assignment; 351, 352; 351, 353; 352, identifier:obs_list; 353, list:[]; 354, for_statement; 354, 355; 354, 356; 354, 366; 355, identifier:neighb; 356, call; 356, 357; 356, 362; 357, attribute; 357, 358; 357, 361; 358, attribute; 358, 359; 358, 360; 359, identifier:self; 360, identifier:_im; 361, identifier:neighbors; 362, argument_list; 362, 363; 363, attribute; 363, 364; 363, 365; 364, identifier:rule; 365, identifier:name; 366, block; 366, 367; 366, 375; 366, 389; 367, if_statement; 367, 368; 367, 373; 368, comparison_operator:!=; 368, 369; 368, 372; 369, subscript; 369, 370; 369, 371; 370, identifier:node_attributes; 371, identifier:neighb; 372, string:'variable'; 373, block; 373, 374; 374, continue_statement; 375, expression_statement; 375, 376; 376, assignment; 376, 377; 376, 378; 377, identifier:edge_sign; 378, call; 378, 379; 378, 380; 379, identifier:_get_edge_sign; 380, argument_list; 380, 381; 380, 384; 381, attribute; 381, 382; 381, 383; 382, identifier:self; 383, identifier:_im; 384, tuple; 384, 385; 384, 388; 385, attribute; 385, 386; 385, 387; 386, identifier:rule; 387, identifier:name; 388, identifier:neighb; 389, expression_statement; 389, 390; 390, call; 390, 391; 390, 394; 391, attribute; 391, 392; 391, 393; 392, identifier:obs_list; 393, identifier:append; 394, argument_list; 394, 395; 395, tuple; 395, 396; 395, 397; 396, identifier:neighb; 397, identifier:edge_sign; 398, expression_statement; 398, 399; 399, assignment; 399, 400; 399, 407; 400, subscript; 400, 401; 400, 404; 401, attribute; 401, 402; 401, 403; 402, identifier:self; 403, identifier:rule_obs_dict; 404, attribute; 404, 405; 404, 406; 405, identifier:rule; 406, identifier:name; 407, identifier:obs_list; 408, return_statement; 408, 409; 409, attribute; 409, 410; 409, 411; 410, identifier:self; 411, identifier:_im | def get_im(self, force_update=False):
if self._im and not force_update:
return self._im
if not self.model:
raise Exception("Cannot get influence map if there is no model.")
def add_obs_for_agent(agent):
obj_mps = list(pa.grounded_monomer_patterns(self.model, agent))
if not obj_mps:
logger.debug('No monomer patterns found in model for agent %s, '
'skipping' % agent)
return
obs_list = []
for obj_mp in obj_mps:
obs_name = _monomer_pattern_label(obj_mp) + '_obs'
obj_obs = Observable(obs_name, obj_mp, _export=False)
obs_list.append(obs_name)
try:
self.model.add_component(obj_obs)
except ComponentDuplicateNameError as e:
pass
return obs_list
self.model.observables = ComponentSet([])
for stmt in self.statements:
if isinstance(stmt, Modification):
mod_condition_name = modclass_to_modtype[stmt.__class__]
if isinstance(stmt, RemoveModification):
mod_condition_name = modtype_to_inverse[mod_condition_name]
modified_sub = _add_modification_to_agent(stmt.sub,
mod_condition_name, stmt.residue,
stmt.position)
obs_list = add_obs_for_agent(modified_sub)
self.stmt_to_obs[stmt] = obs_list
elif isinstance(stmt, RegulateActivity):
regulated_obj, polarity = \
_add_activity_to_agent(stmt.obj, stmt.obj_activity,
stmt.is_activation)
obs_list = add_obs_for_agent(regulated_obj)
self.stmt_to_obs[stmt] = obs_list
elif isinstance(stmt, RegulateAmount):
obs_list = add_obs_for_agent(stmt.obj)
self.stmt_to_obs[stmt] = obs_list
elif isinstance(stmt, Influence):
obs_list = add_obs_for_agent(stmt.obj.concept)
self.stmt_to_obs[stmt] = obs_list
for ag in self.agent_obs:
obs_list = add_obs_for_agent(ag)
self.agent_to_obs[ag] = obs_list
logger.info("Generating influence map")
self._im = self.generate_im(self.model)
node_attributes = nx.get_node_attributes(self._im, 'node_type')
for rule in self.model.rules:
obs_list = []
for neighb in self._im.neighbors(rule.name):
if node_attributes[neighb] != 'variable':
continue
edge_sign = _get_edge_sign(self._im, (rule.name, neighb))
obs_list.append((neighb, edge_sign))
self.rule_obs_dict[rule.name] = obs_list
return self._im |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:check_statement; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:stmt; 6, default_parameter; 6, 7; 6, 8; 7, identifier:max_paths; 8, integer:1; 9, default_parameter; 9, 10; 9, 11; 10, identifier:max_path_length; 11, integer:5; 12, block; 12, 13; 12, 19; 12, 39; 12, 116; 12, 126; 12, 177; 12, 185; 12, 206; 12, 238; 13, expression_statement; 13, 14; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:get_im; 18, argument_list; 19, if_statement; 19, 20; 19, 30; 20, not_operator; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:isinstance; 23, argument_list; 23, 24; 23, 25; 24, identifier:stmt; 25, tuple; 25, 26; 25, 27; 25, 28; 25, 29; 26, identifier:Modification; 27, identifier:RegulateAmount; 28, identifier:RegulateActivity; 29, identifier:Influence; 30, block; 30, 31; 31, return_statement; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:PathResult; 34, argument_list; 34, 35; 34, 36; 34, 37; 34, 38; 35, False; 36, string:'STATEMENT_TYPE_NOT_HANDLED'; 37, identifier:max_paths; 38, identifier:max_path_length; 39, if_statement; 39, 40; 39, 45; 39, 58; 39, 75; 39, 94; 40, call; 40, 41; 40, 42; 41, identifier:isinstance; 42, argument_list; 42, 43; 42, 44; 43, identifier:stmt; 44, identifier:Modification; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:target_polarity; 49, conditional_expression:if; 49, 50; 49, 52; 49, 57; 50, unary_operator:-; 50, 51; 51, integer:1; 52, call; 52, 53; 52, 54; 53, identifier:isinstance; 54, argument_list; 54, 55; 54, 56; 55, identifier:stmt; 56, identifier:RemoveModification; 57, integer:1; 58, elif_clause; 58, 59; 58, 64; 59, call; 59, 60; 59, 61; 60, identifier:isinstance; 61, argument_list; 61, 62; 61, 63; 62, identifier:stmt; 63, identifier:RegulateActivity; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:target_polarity; 68, conditional_expression:if; 68, 69; 68, 70; 68, 73; 69, integer:1; 70, attribute; 70, 71; 70, 72; 71, identifier:stmt; 72, identifier:is_activation; 73, unary_operator:-; 73, 74; 74, integer:1; 75, elif_clause; 75, 76; 75, 81; 76, call; 76, 77; 76, 78; 77, identifier:isinstance; 78, argument_list; 78, 79; 78, 80; 79, identifier:stmt; 80, identifier:RegulateAmount; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:target_polarity; 85, conditional_expression:if; 85, 86; 85, 88; 85, 93; 86, unary_operator:-; 86, 87; 87, integer:1; 88, call; 88, 89; 88, 90; 89, identifier:isinstance; 90, argument_list; 90, 91; 90, 92; 91, identifier:stmt; 92, identifier:DecreaseAmount; 93, integer:1; 94, elif_clause; 94, 95; 94, 100; 95, call; 95, 96; 95, 97; 96, identifier:isinstance; 97, argument_list; 97, 98; 97, 99; 98, identifier:stmt; 99, identifier:Influence; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:target_polarity; 104, conditional_expression:if; 104, 105; 104, 107; 104, 115; 105, unary_operator:-; 105, 106; 106, integer:1; 107, comparison_operator:==; 107, 108; 107, 113; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:stmt; 111, identifier:overall_polarity; 112, argument_list; 113, unary_operator:-; 113, 114; 114, integer:1; 115, integer:1; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 121; 118, pattern_list; 118, 119; 118, 120; 119, identifier:subj; 120, identifier:obj; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:stmt; 124, identifier:agent_list; 125, argument_list; 126, if_statement; 126, 127; 126, 130; 126, 170; 127, comparison_operator:is; 127, 128; 127, 129; 128, identifier:subj; 129, None; 130, block; 130, 131; 130, 149; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:subj_mps; 134, call; 134, 135; 134, 136; 135, identifier:list; 136, argument_list; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:pa; 140, identifier:grounded_monomer_patterns; 141, argument_list; 141, 142; 141, 145; 141, 146; 142, attribute; 142, 143; 142, 144; 143, identifier:self; 144, identifier:model; 145, identifier:subj; 146, keyword_argument; 146, 147; 146, 148; 147, identifier:ignore_activities; 148, True; 149, if_statement; 149, 150; 149, 152; 150, not_operator; 150, 151; 151, identifier:subj_mps; 152, block; 152, 153; 152, 162; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:logger; 157, identifier:debug; 158, argument_list; 158, 159; 159, binary_operator:%; 159, 160; 159, 161; 160, string:'No monomers found corresponding to agent %s'; 161, identifier:subj; 162, return_statement; 162, 163; 163, call; 163, 164; 163, 165; 164, identifier:PathResult; 165, argument_list; 165, 166; 165, 167; 165, 168; 165, 169; 166, False; 167, string:'SUBJECT_MONOMERS_NOT_FOUND'; 168, identifier:max_paths; 169, identifier:max_path_length; 170, else_clause; 170, 171; 171, block; 171, 172; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:subj_mps; 175, list:[None]; 175, 176; 176, None; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:obs_names; 180, subscript; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:self; 183, identifier:stmt_to_obs; 184, identifier:stmt; 185, if_statement; 185, 186; 185, 188; 186, not_operator; 186, 187; 187, identifier:obs_names; 188, block; 188, 189; 188, 198; 189, expression_statement; 189, 190; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:logger; 193, identifier:debug; 194, argument_list; 194, 195; 195, binary_operator:%; 195, 196; 195, 197; 196, string:"No observables for stmt %s, returning False"; 197, identifier:stmt; 198, return_statement; 198, 199; 199, call; 199, 200; 199, 201; 200, identifier:PathResult; 201, argument_list; 201, 202; 201, 203; 201, 204; 201, 205; 202, False; 203, string:'OBSERVABLES_NOT_FOUND'; 204, identifier:max_paths; 205, identifier:max_path_length; 206, for_statement; 206, 207; 206, 210; 206, 217; 207, pattern_list; 207, 208; 207, 209; 208, identifier:subj_mp; 209, identifier:obs_name; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:itertools; 213, identifier:product; 214, argument_list; 214, 215; 214, 216; 215, identifier:subj_mps; 216, identifier:obs_names; 217, block; 217, 218; 217, 231; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:result; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:self; 224, identifier:_find_im_paths; 225, argument_list; 225, 226; 225, 227; 225, 228; 225, 229; 225, 230; 226, identifier:subj_mp; 227, identifier:obs_name; 228, identifier:target_polarity; 229, identifier:max_paths; 230, identifier:max_path_length; 231, if_statement; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:result; 234, identifier:path_found; 235, block; 235, 236; 236, return_statement; 236, 237; 237, identifier:result; 238, return_statement; 238, 239; 239, call; 239, 240; 239, 241; 240, identifier:PathResult; 241, argument_list; 241, 242; 241, 243; 241, 244; 241, 245; 242, False; 243, string:'NO_PATHS_FOUND'; 244, identifier:max_paths; 245, identifier:max_path_length | def check_statement(self, stmt, max_paths=1, max_path_length=5):
self.get_im()
if not isinstance(stmt, (Modification, RegulateAmount,
RegulateActivity, Influence)):
return PathResult(False, 'STATEMENT_TYPE_NOT_HANDLED',
max_paths, max_path_length)
if isinstance(stmt, Modification):
target_polarity = -1 if isinstance(stmt, RemoveModification) else 1
elif isinstance(stmt, RegulateActivity):
target_polarity = 1 if stmt.is_activation else -1
elif isinstance(stmt, RegulateAmount):
target_polarity = -1 if isinstance(stmt, DecreaseAmount) else 1
elif isinstance(stmt, Influence):
target_polarity = -1 if stmt.overall_polarity() == -1 else 1
subj, obj = stmt.agent_list()
if subj is not None:
subj_mps = list(pa.grounded_monomer_patterns(self.model, subj,
ignore_activities=True))
if not subj_mps:
logger.debug('No monomers found corresponding to agent %s' %
subj)
return PathResult(False, 'SUBJECT_MONOMERS_NOT_FOUND',
max_paths, max_path_length)
else:
subj_mps = [None]
obs_names = self.stmt_to_obs[stmt]
if not obs_names:
logger.debug("No observables for stmt %s, returning False" % stmt)
return PathResult(False, 'OBSERVABLES_NOT_FOUND',
max_paths, max_path_length)
for subj_mp, obs_name in itertools.product(subj_mps, obs_names):
result = self._find_im_paths(subj_mp, obs_name, target_polarity,
max_paths, max_path_length)
if result.path_found:
return result
return PathResult(False, 'NO_PATHS_FOUND',
max_paths, max_path_length) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:score_paths; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 4, identifier:self; 5, identifier:paths; 6, identifier:agents_values; 7, default_parameter; 7, 8; 7, 9; 8, identifier:loss_of_function; 9, False; 10, default_parameter; 10, 11; 10, 12; 11, identifier:sigma; 12, float:0.15; 13, default_parameter; 13, 14; 13, 15; 14, identifier:include_final_node; 15, False; 16, block; 16, 17; 16, 32; 16, 36; 16, 69; 16, 73; 16, 279; 16, 290; 16, 308; 16, 326; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:obs_model; 20, lambda; 20, 21; 20, 23; 21, lambda_parameters; 21, 22; 22, identifier:x; 23, call; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:scipy; 27, identifier:stats; 28, identifier:norm; 29, argument_list; 29, 30; 29, 31; 30, identifier:x; 31, identifier:sigma; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:obs_dict; 35, dictionary; 36, for_statement; 36, 37; 36, 40; 36, 45; 37, pattern_list; 37, 38; 37, 39; 38, identifier:ag; 39, identifier:val; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:agents_values; 43, identifier:items; 44, argument_list; 45, block; 45, 46; 45, 54; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:obs_list; 49, subscript; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:agent_to_obs; 53, identifier:ag; 54, if_statement; 54, 55; 54, 58; 55, comparison_operator:is; 55, 56; 55, 57; 56, identifier:obs_list; 57, None; 58, block; 58, 59; 59, for_statement; 59, 60; 59, 61; 59, 62; 60, identifier:obs; 61, identifier:obs_list; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:obs_dict; 67, identifier:obs; 68, identifier:val; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:path_scores; 72, list:[]; 73, for_statement; 73, 74; 73, 75; 73, 76; 74, identifier:path; 75, identifier:paths; 76, block; 76, 77; 76, 84; 76, 91; 76, 98; 76, 102; 76, 111; 76, 263; 76, 272; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:logger; 81, identifier:info; 82, argument_list; 82, 83; 83, string:'------'; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:logger; 88, identifier:info; 89, argument_list; 89, 90; 90, string:"Scoring path:"; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:logger; 95, identifier:info; 96, argument_list; 96, 97; 97, identifier:path; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:path_score; 101, integer:0; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:last_path_node_index; 105, conditional_expression:if; 105, 106; 105, 108; 105, 109; 106, unary_operator:-; 106, 107; 107, integer:1; 108, identifier:include_final_node; 109, unary_operator:-; 109, 110; 110, integer:2; 111, for_statement; 111, 112; 111, 115; 111, 120; 112, pattern_list; 112, 113; 112, 114; 113, identifier:node; 114, identifier:sign; 115, subscript; 115, 116; 115, 117; 116, identifier:path; 117, slice; 117, 118; 117, 119; 118, colon; 119, identifier:last_path_node_index; 120, block; 120, 121; 120, 218; 121, for_statement; 121, 122; 121, 125; 121, 130; 122, pattern_list; 122, 123; 122, 124; 123, identifier:affected_obs; 124, identifier:rule_obs_sign; 125, subscript; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:rule_obs_dict; 129, identifier:node; 130, block; 130, 131; 130, 139; 130, 147; 130, 160; 130, 169; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:flip_polarity; 134, conditional_expression:if; 134, 135; 134, 137; 134, 138; 135, unary_operator:-; 135, 136; 136, integer:1; 137, identifier:loss_of_function; 138, integer:1; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:pred_sign; 142, binary_operator:*; 142, 143; 142, 146; 143, binary_operator:*; 143, 144; 143, 145; 144, identifier:sign; 145, identifier:rule_obs_sign; 146, identifier:flip_polarity; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:logger; 151, identifier:info; 152, argument_list; 152, 153; 153, binary_operator:%; 153, 154; 153, 155; 154, string:'%s %s: effect %s %s'; 155, tuple; 155, 156; 155, 157; 155, 158; 155, 159; 156, identifier:node; 157, identifier:sign; 158, identifier:affected_obs; 159, identifier:pred_sign; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:measured_val; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:obs_dict; 166, identifier:get; 167, argument_list; 167, 168; 168, identifier:affected_obs; 169, if_statement; 169, 170; 169, 171; 170, identifier:measured_val; 171, block; 171, 172; 171, 203; 171, 214; 172, if_statement; 172, 173; 172, 176; 172, 189; 173, comparison_operator:<=; 173, 174; 173, 175; 174, identifier:pred_sign; 175, integer:0; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:prob_correct; 180, call; 180, 181; 180, 187; 181, attribute; 181, 182; 181, 186; 182, call; 182, 183; 182, 184; 183, identifier:obs_model; 184, argument_list; 184, 185; 185, identifier:measured_val; 186, identifier:logcdf; 187, argument_list; 187, 188; 188, integer:0; 189, else_clause; 189, 190; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:prob_correct; 194, call; 194, 195; 194, 201; 195, attribute; 195, 196; 195, 200; 196, call; 196, 197; 196, 198; 197, identifier:obs_model; 198, argument_list; 198, 199; 199, identifier:measured_val; 200, identifier:logsf; 201, argument_list; 201, 202; 202, integer:0; 203, expression_statement; 203, 204; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:logger; 207, identifier:info; 208, argument_list; 208, 209; 209, binary_operator:%; 209, 210; 209, 211; 210, string:'Actual: %s, Log Probability: %s'; 211, tuple; 211, 212; 211, 213; 212, identifier:measured_val; 213, identifier:prob_correct; 214, expression_statement; 214, 215; 215, augmented_assignment:+=; 215, 216; 215, 217; 216, identifier:path_score; 217, identifier:prob_correct; 218, if_statement; 218, 219; 218, 225; 219, not_operator; 219, 220; 220, subscript; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:self; 223, identifier:rule_obs_dict; 224, identifier:node; 225, block; 225, 226; 225, 237; 225, 249; 225, 259; 226, expression_statement; 226, 227; 227, call; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:logger; 230, identifier:info; 231, argument_list; 231, 232; 232, binary_operator:%; 232, 233; 232, 234; 233, string:'%s %s'; 234, tuple; 234, 235; 234, 236; 235, identifier:node; 236, identifier:sign; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:prob_correct; 240, call; 240, 241; 240, 247; 241, attribute; 241, 242; 241, 246; 242, call; 242, 243; 242, 244; 243, identifier:obs_model; 244, argument_list; 244, 245; 245, integer:0; 246, identifier:logcdf; 247, argument_list; 247, 248; 248, integer:0; 249, expression_statement; 249, 250; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:logger; 253, identifier:info; 254, argument_list; 254, 255; 255, binary_operator:%; 255, 256; 255, 257; 256, string:'Unmeasured node, Log Probability: %s'; 257, parenthesized_expression; 257, 258; 258, identifier:prob_correct; 259, expression_statement; 259, 260; 260, augmented_assignment:+=; 260, 261; 260, 262; 261, identifier:path_score; 262, identifier:prob_correct; 263, expression_statement; 263, 264; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:logger; 267, identifier:info; 268, argument_list; 268, 269; 269, binary_operator:%; 269, 270; 269, 271; 270, string:"Path score: %s"; 271, identifier:path_score; 272, expression_statement; 272, 273; 273, call; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:path_scores; 276, identifier:append; 277, argument_list; 277, 278; 278, identifier:path_score; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:path_tuples; 282, call; 282, 283; 282, 284; 283, identifier:list; 284, argument_list; 284, 285; 285, call; 285, 286; 285, 287; 286, identifier:zip; 287, argument_list; 287, 288; 287, 289; 288, identifier:paths; 289, identifier:path_scores; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 293; 292, identifier:sorted_by_length; 293, call; 293, 294; 293, 295; 294, identifier:sorted; 295, argument_list; 295, 296; 295, 297; 296, identifier:path_tuples; 297, keyword_argument; 297, 298; 297, 299; 298, identifier:key; 299, lambda; 299, 300; 299, 302; 300, lambda_parameters; 300, 301; 301, identifier:x; 302, call; 302, 303; 302, 304; 303, identifier:len; 304, argument_list; 304, 305; 305, subscript; 305, 306; 305, 307; 306, identifier:x; 307, integer:0; 308, expression_statement; 308, 309; 309, assignment; 309, 310; 309, 311; 310, identifier:scored_paths; 311, call; 311, 312; 311, 313; 312, identifier:sorted; 313, argument_list; 313, 314; 313, 315; 313, 323; 314, identifier:sorted_by_length; 315, keyword_argument; 315, 316; 315, 317; 316, identifier:key; 317, lambda; 317, 318; 317, 320; 318, lambda_parameters; 318, 319; 319, identifier:x; 320, subscript; 320, 321; 320, 322; 321, identifier:x; 322, integer:1; 323, keyword_argument; 323, 324; 323, 325; 324, identifier:reverse; 325, True; 326, return_statement; 326, 327; 327, identifier:scored_paths | def score_paths(self, paths, agents_values, loss_of_function=False,
sigma=0.15, include_final_node=False):
obs_model = lambda x: scipy.stats.norm(x, sigma)
obs_dict = {}
for ag, val in agents_values.items():
obs_list = self.agent_to_obs[ag]
if obs_list is not None:
for obs in obs_list:
obs_dict[obs] = val
path_scores = []
for path in paths:
logger.info('------')
logger.info("Scoring path:")
logger.info(path)
path_score = 0
last_path_node_index = -1 if include_final_node else -2
for node, sign in path[:last_path_node_index]:
for affected_obs, rule_obs_sign in self.rule_obs_dict[node]:
flip_polarity = -1 if loss_of_function else 1
pred_sign = sign * rule_obs_sign * flip_polarity
logger.info('%s %s: effect %s %s' %
(node, sign, affected_obs, pred_sign))
measured_val = obs_dict.get(affected_obs)
if measured_val:
if pred_sign <= 0:
prob_correct = obs_model(measured_val).logcdf(0)
else:
prob_correct = obs_model(measured_val).logsf(0)
logger.info('Actual: %s, Log Probability: %s' %
(measured_val, prob_correct))
path_score += prob_correct
if not self.rule_obs_dict[node]:
logger.info('%s %s' % (node, sign))
prob_correct = obs_model(0).logcdf(0)
logger.info('Unmeasured node, Log Probability: %s' %
(prob_correct))
path_score += prob_correct
logger.info("Path score: %s" % path_score)
path_scores.append(path_score)
path_tuples = list(zip(paths, path_scores))
sorted_by_length = sorted(path_tuples, key=lambda x: len(x[0]))
scored_paths = sorted(sorted_by_length, key=lambda x: x[1],
reverse=True)
return scored_paths |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:prune_influence_map; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 5, 21; 5, 25; 5, 63; 5, 70; 5, 78; 5, 85; 5, 89; 5, 111; 5, 118; 5, 130; 5, 144; 5, 156; 5, 160; 5, 253; 5, 265; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:im; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:get_im; 13, argument_list; 14, expression_statement; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:logger; 18, identifier:info; 19, argument_list; 19, 20; 20, string:'Removing self loops'; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:edges_to_remove; 24, list:[]; 25, for_statement; 25, 26; 25, 27; 25, 32; 26, identifier:e; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:im; 30, identifier:edges; 31, argument_list; 32, block; 32, 33; 33, if_statement; 33, 34; 33, 41; 34, comparison_operator:==; 34, 35; 34, 38; 35, subscript; 35, 36; 35, 37; 36, identifier:e; 37, integer:0; 38, subscript; 38, 39; 38, 40; 39, identifier:e; 40, integer:1; 41, block; 41, 42; 41, 50; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:logger; 46, identifier:info; 47, argument_list; 47, 48; 47, 49; 48, string:'Removing self loop: %s'; 49, identifier:e; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:edges_to_remove; 54, identifier:append; 55, argument_list; 55, 56; 56, tuple; 56, 57; 56, 60; 57, subscript; 57, 58; 57, 59; 58, identifier:e; 59, integer:0; 60, subscript; 60, 61; 60, 62; 61, identifier:e; 62, integer:1; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:im; 67, identifier:remove_edges_from; 68, argument_list; 68, 69; 69, identifier:edges_to_remove; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:remove_im_params; 73, argument_list; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:self; 76, identifier:model; 77, identifier:im; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:logger; 82, identifier:info; 83, argument_list; 83, 84; 84, string:'Get successorts of each node'; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:succ_dict; 88, dictionary; 89, for_statement; 89, 90; 89, 91; 89, 96; 90, identifier:node; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:im; 94, identifier:nodes; 95, argument_list; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 102; 99, subscript; 99, 100; 99, 101; 100, identifier:succ_dict; 101, identifier:node; 102, call; 102, 103; 102, 104; 103, identifier:set; 104, argument_list; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:im; 108, identifier:successors; 109, argument_list; 109, 110; 110, identifier:node; 111, expression_statement; 111, 112; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:logger; 115, identifier:info; 116, argument_list; 116, 117; 117, string:'Compare combinations of successors'; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:group_key_fun; 121, lambda; 121, 122; 121, 124; 122, lambda_parameters; 122, 123; 123, identifier:x; 124, call; 124, 125; 124, 126; 125, identifier:len; 126, argument_list; 126, 127; 127, subscript; 127, 128; 127, 129; 128, identifier:succ_dict; 129, identifier:x; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:nodes_sorted; 133, call; 133, 134; 133, 135; 134, identifier:sorted; 135, argument_list; 135, 136; 135, 141; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:im; 139, identifier:nodes; 140, argument_list; 141, keyword_argument; 141, 142; 141, 143; 142, identifier:key; 143, identifier:group_key_fun; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:groups; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:itertools; 150, identifier:groupby; 151, argument_list; 151, 152; 151, 153; 152, identifier:nodes_sorted; 153, keyword_argument; 153, 154; 153, 155; 154, identifier:key; 155, identifier:group_key_fun; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:edges_to_remove; 159, list:[]; 160, for_statement; 160, 161; 160, 164; 160, 165; 161, pattern_list; 161, 162; 161, 163; 162, identifier:gix; 163, identifier:group; 164, identifier:groups; 165, block; 165, 166; 165, 176; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:combos; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:itertools; 172, identifier:combinations; 173, argument_list; 173, 174; 173, 175; 174, identifier:group; 175, integer:2; 176, for_statement; 176, 177; 176, 182; 176, 186; 177, pattern_list; 177, 178; 177, 179; 178, identifier:ix; 179, tuple_pattern; 179, 180; 179, 181; 180, identifier:p1; 181, identifier:p2; 182, call; 182, 183; 182, 184; 183, identifier:enumerate; 184, argument_list; 184, 185; 185, identifier:combos; 186, block; 186, 187; 187, if_statement; 187, 188; 187, 222; 188, boolean_operator:and; 188, 189; 188, 205; 188, 206; 189, comparison_operator:==; 189, 190; 189, 200; 190, call; 190, 191; 190, 196; 191, attribute; 191, 192; 191, 195; 192, subscript; 192, 193; 192, 194; 193, identifier:succ_dict; 194, identifier:p1; 195, identifier:difference; 196, argument_list; 196, 197; 197, subscript; 197, 198; 197, 199; 198, identifier:succ_dict; 199, identifier:p2; 200, call; 200, 201; 200, 202; 201, identifier:set; 202, argument_list; 202, 203; 203, list:[p2]; 203, 204; 204, identifier:p2; 205, line_continuation:\; 206, comparison_operator:==; 206, 207; 206, 217; 207, call; 207, 208; 207, 213; 208, attribute; 208, 209; 208, 212; 209, subscript; 209, 210; 209, 211; 210, identifier:succ_dict; 211, identifier:p2; 212, identifier:difference; 213, argument_list; 213, 214; 214, subscript; 214, 215; 214, 216; 215, identifier:succ_dict; 216, identifier:p1; 217, call; 217, 218; 217, 219; 218, identifier:set; 219, argument_list; 219, 220; 220, list:[p1]; 220, 221; 221, identifier:p1; 222, block; 222, 223; 223, for_statement; 223, 224; 223, 227; 223, 234; 224, pattern_list; 224, 225; 224, 226; 225, identifier:u; 226, identifier:v; 227, tuple; 227, 228; 227, 231; 228, tuple; 228, 229; 228, 230; 229, identifier:p1; 230, identifier:p2; 231, tuple; 231, 232; 231, 233; 232, identifier:p2; 233, identifier:p1; 234, block; 234, 235; 234, 244; 235, expression_statement; 235, 236; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:edges_to_remove; 239, identifier:append; 240, argument_list; 240, 241; 241, tuple; 241, 242; 241, 243; 242, identifier:u; 243, identifier:v; 244, expression_statement; 244, 245; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:logger; 248, identifier:debug; 249, argument_list; 249, 250; 249, 251; 249, 252; 250, string:'Will remove edge (%s, %s)'; 251, identifier:u; 252, identifier:v; 253, expression_statement; 253, 254; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:logger; 257, identifier:info; 258, argument_list; 258, 259; 259, binary_operator:%; 259, 260; 259, 261; 260, string:'Removing %d edges from influence map'; 261, call; 261, 262; 261, 263; 262, identifier:len; 263, argument_list; 263, 264; 264, identifier:edges_to_remove; 265, expression_statement; 265, 266; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:im; 269, identifier:remove_edges_from; 270, argument_list; 270, 271; 271, identifier:edges_to_remove | def prune_influence_map(self):
im = self.get_im()
logger.info('Removing self loops')
edges_to_remove = []
for e in im.edges():
if e[0] == e[1]:
logger.info('Removing self loop: %s', e)
edges_to_remove.append((e[0], e[1]))
im.remove_edges_from(edges_to_remove)
remove_im_params(self.model, im)
logger.info('Get successorts of each node')
succ_dict = {}
for node in im.nodes():
succ_dict[node] = set(im.successors(node))
logger.info('Compare combinations of successors')
group_key_fun = lambda x: len(succ_dict[x])
nodes_sorted = sorted(im.nodes(), key=group_key_fun)
groups = itertools.groupby(nodes_sorted, key=group_key_fun)
edges_to_remove = []
for gix, group in groups:
combos = itertools.combinations(group, 2)
for ix, (p1, p2) in enumerate(combos):
if succ_dict[p1].difference(succ_dict[p2]) == set([p2]) and \
succ_dict[p2].difference(succ_dict[p1]) == set([p1]):
for u, v in ((p1, p2), (p2, p1)):
edges_to_remove.append((u, v))
logger.debug('Will remove edge (%s, %s)', u, v)
logger.info('Removing %d edges from influence map' %
len(edges_to_remove))
im.remove_edges_from(edges_to_remove) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:send_request; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:ndex_service_url; 5, identifier:params; 6, default_parameter; 6, 7; 6, 8; 7, identifier:is_json; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:use_get; 11, False; 12, block; 12, 13; 12, 42; 12, 48; 12, 84; 12, 97; 12, 104; 12, 108; 12, 157; 12, 164; 13, if_statement; 13, 14; 13, 15; 13, 28; 14, identifier:use_get; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:res; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:requests; 22, identifier:get; 23, argument_list; 23, 24; 23, 25; 24, identifier:ndex_service_url; 25, keyword_argument; 25, 26; 25, 27; 26, identifier:json; 27, identifier:params; 28, else_clause; 28, 29; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:res; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:requests; 36, identifier:post; 37, argument_list; 37, 38; 37, 39; 38, identifier:ndex_service_url; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:json; 41, identifier:params; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:status; 45, attribute; 45, 46; 45, 47; 46, identifier:res; 47, identifier:status_code; 48, if_statement; 48, 49; 48, 52; 48, 68; 49, comparison_operator:==; 49, 50; 49, 51; 50, identifier:status; 51, integer:200; 52, block; 52, 53; 53, if_statement; 53, 54; 53, 55; 53, 62; 54, identifier:is_json; 55, block; 55, 56; 56, return_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:res; 60, identifier:json; 61, argument_list; 62, else_clause; 62, 63; 63, block; 63, 64; 64, return_statement; 64, 65; 65, attribute; 65, 66; 65, 67; 66, identifier:res; 67, identifier:text; 68, elif_clause; 68, 69; 68, 72; 69, comparison_operator:!=; 69, 70; 69, 71; 70, identifier:status; 71, integer:300; 72, block; 72, 73; 72, 82; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:logger; 77, identifier:error; 78, argument_list; 78, 79; 79, binary_operator:%; 79, 80; 79, 81; 80, string:'Request returned with code %d'; 81, identifier:status; 82, return_statement; 82, 83; 83, None; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:task_id; 87, call; 87, 88; 87, 95; 88, attribute; 88, 89; 88, 94; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:res; 92, identifier:json; 93, argument_list; 94, identifier:get; 95, argument_list; 95, 96; 96, string:'task_id'; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:logger; 101, identifier:info; 102, argument_list; 102, 103; 103, string:'NDEx task submitted...'; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:time_used; 107, integer:0; 108, try_statement; 108, 109; 108, 150; 109, block; 109, 110; 110, while_statement; 110, 111; 110, 114; 111, comparison_operator:!=; 111, 112; 111, 113; 112, identifier:status; 113, integer:200; 114, block; 114, 115; 114, 128; 114, 134; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:res; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:requests; 121, identifier:get; 122, argument_list; 122, 123; 123, binary_operator:+; 123, 124; 123, 127; 124, binary_operator:+; 124, 125; 124, 126; 125, identifier:ndex_base_url; 126, string:'/task/'; 127, identifier:task_id; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:status; 131, attribute; 131, 132; 131, 133; 132, identifier:res; 133, identifier:status_code; 134, if_statement; 134, 135; 134, 138; 135, comparison_operator:!=; 135, 136; 135, 137; 136, identifier:status; 137, integer:200; 138, block; 138, 139; 138, 146; 139, expression_statement; 139, 140; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:time; 143, identifier:sleep; 144, argument_list; 144, 145; 145, integer:5; 146, expression_statement; 146, 147; 147, augmented_assignment:+=; 147, 148; 147, 149; 148, identifier:time_used; 149, integer:5; 150, except_clause; 150, 151; 150, 152; 151, identifier:KeyError; 152, block; 152, 153; 152, 155; 153, expression_statement; 153, 154; 154, identifier:next; 155, return_statement; 155, 156; 156, None; 157, expression_statement; 157, 158; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:logger; 161, identifier:info; 162, argument_list; 162, 163; 163, string:'NDEx task complete.'; 164, if_statement; 164, 165; 164, 166; 164, 173; 165, identifier:is_json; 166, block; 166, 167; 167, return_statement; 167, 168; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:res; 171, identifier:json; 172, argument_list; 173, else_clause; 173, 174; 174, block; 174, 175; 175, return_statement; 175, 176; 176, attribute; 176, 177; 176, 178; 177, identifier:res; 178, identifier:text | def send_request(ndex_service_url, params, is_json=True, use_get=False):
if use_get:
res = requests.get(ndex_service_url, json=params)
else:
res = requests.post(ndex_service_url, json=params)
status = res.status_code
if status == 200:
if is_json:
return res.json()
else:
return res.text
elif status != 300:
logger.error('Request returned with code %d' % status)
return None
task_id = res.json().get('task_id')
logger.info('NDEx task submitted...')
time_used = 0
try:
while status != 200:
res = requests.get(ndex_base_url + '/task/' + task_id)
status = res.status_code
if status != 200:
time.sleep(5)
time_used += 5
except KeyError:
next
return None
logger.info('NDEx task complete.')
if is_json:
return res.json()
else:
return res.text |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:get_hash; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:shallow; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:refresh; 10, False; 11, block; 11, 12; 11, 114; 12, if_statement; 12, 13; 12, 14; 12, 52; 13, identifier:shallow; 14, block; 14, 15; 14, 46; 15, if_statement; 15, 16; 15, 31; 16, boolean_operator:or; 16, 17; 16, 29; 16, 30; 17, boolean_operator:or; 17, 18; 17, 24; 18, not_operator; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:hasattr; 21, argument_list; 21, 22; 21, 23; 22, identifier:self; 23, string:'_shallow_hash'; 24, comparison_operator:is; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:_shallow_hash; 28, None; 29, line_continuation:\; 30, identifier:refresh; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:_shallow_hash; 37, call; 37, 38; 37, 39; 38, identifier:make_hash; 39, argument_list; 39, 40; 39, 45; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:matches_key; 44, argument_list; 45, integer:14; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:ret; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:_shallow_hash; 52, else_clause; 52, 53; 53, block; 53, 54; 53, 108; 54, if_statement; 54, 55; 54, 70; 55, boolean_operator:or; 55, 56; 55, 68; 55, 69; 56, boolean_operator:or; 56, 57; 56, 63; 57, not_operator; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:hasattr; 60, argument_list; 60, 61; 60, 62; 61, identifier:self; 62, string:'_full_hash'; 63, comparison_operator:is; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:_full_hash; 67, None; 68, line_continuation:\; 69, identifier:refresh; 70, block; 70, 71; 70, 88; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:ev_mk_list; 74, call; 74, 75; 74, 76; 75, identifier:sorted; 76, argument_list; 76, 77; 77, list_comprehension; 77, 78; 77, 83; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:ev; 81, identifier:matches_key; 82, argument_list; 83, for_in_clause; 83, 84; 83, 85; 84, identifier:ev; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:evidence; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 93; 89, 94; 90, attribute; 90, 91; 90, 92; 91, identifier:self; 92, identifier:_full_hash; 93, line_continuation:\; 94, call; 94, 95; 94, 96; 95, identifier:make_hash; 96, argument_list; 96, 97; 96, 107; 97, binary_operator:+; 97, 98; 97, 103; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:matches_key; 102, argument_list; 103, call; 103, 104; 103, 105; 104, identifier:str; 105, argument_list; 105, 106; 106, identifier:ev_mk_list; 107, integer:16; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:ret; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:_full_hash; 114, return_statement; 114, 115; 115, identifier:ret | def get_hash(self, shallow=True, refresh=False):
if shallow:
if not hasattr(self, '_shallow_hash') or self._shallow_hash is None\
or refresh:
self._shallow_hash = make_hash(self.matches_key(), 14)
ret = self._shallow_hash
else:
if not hasattr(self, '_full_hash') or self._full_hash is None \
or refresh:
ev_mk_list = sorted([ev.matches_key() for ev in self.evidence])
self._full_hash = \
make_hash(self.matches_key() + str(ev_mk_list), 16)
ret = self._full_hash
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:to_json; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:use_sbo; 7, False; 8, block; 8, 9; 8, 18; 8, 31; 8, 55; 8, 64; 8, 72; 8, 97; 8, 107; 8, 129; 8, 151; 8, 200; 8, 220; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:stmt_type; 12, attribute; 12, 13; 12, 17; 13, call; 13, 14; 13, 15; 14, identifier:type; 15, argument_list; 15, 16; 16, identifier:self; 17, identifier:__name__; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:all_stmts; 21, binary_operator:+; 21, 22; 21, 28; 22, binary_operator:+; 22, 23; 22, 25; 23, list:[self]; 23, 24; 24, identifier:self; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:supports; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:supported_by; 31, for_statement; 31, 32; 31, 33; 31, 34; 32, identifier:st; 33, identifier:all_stmts; 34, block; 34, 35; 35, if_statement; 35, 36; 35, 42; 36, not_operator; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:hasattr; 39, argument_list; 39, 40; 39, 41; 40, identifier:st; 41, string:'uuid'; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:st; 47, identifier:uuid; 48, binary_operator:%; 48, 49; 48, 50; 49, string:'%s'; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:uuid; 53, identifier:uuid4; 54, argument_list; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:json_dict; 58, call; 58, 59; 58, 60; 59, identifier:_o; 60, argument_list; 60, 61; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:type; 63, identifier:stmt_type; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 69; 66, subscript; 66, 67; 66, 68; 67, identifier:json_dict; 68, string:'belief'; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:belief; 72, if_statement; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:evidence; 76, block; 76, 77; 76, 91; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:evidence; 80, list_comprehension; 80, 81; 80, 86; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:ev; 84, identifier:to_json; 85, argument_list; 86, for_in_clause; 86, 87; 86, 88; 87, identifier:ev; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:evidence; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 96; 93, subscript; 93, 94; 93, 95; 94, identifier:json_dict; 95, string:'evidence'; 96, identifier:evidence; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 102; 99, subscript; 99, 100; 99, 101; 100, identifier:json_dict; 101, string:'id'; 102, binary_operator:%; 102, 103; 102, 104; 103, string:'%s'; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:uuid; 107, if_statement; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:supports; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 117; 113, 118; 114, subscript; 114, 115; 114, 116; 115, identifier:json_dict; 116, string:'supports'; 117, line_continuation:\; 118, list_comprehension; 118, 119; 118, 124; 119, binary_operator:%; 119, 120; 119, 121; 120, string:'%s'; 121, attribute; 121, 122; 121, 123; 122, identifier:st; 123, identifier:uuid; 124, for_in_clause; 124, 125; 124, 126; 125, identifier:st; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:supports; 129, if_statement; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:self; 132, identifier:supported_by; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 139; 135, 140; 136, subscript; 136, 137; 136, 138; 137, identifier:json_dict; 138, string:'supported_by'; 139, line_continuation:\; 140, list_comprehension; 140, 141; 140, 146; 141, binary_operator:%; 141, 142; 141, 143; 142, string:'%s'; 143, attribute; 143, 144; 143, 145; 144, identifier:st; 145, identifier:uuid; 146, for_in_clause; 146, 147; 146, 148; 147, identifier:st; 148, attribute; 148, 149; 148, 150; 149, identifier:self; 150, identifier:supported_by; 151, function_definition; 151, 152; 151, 153; 151, 155; 152, function_name:get_sbo_term; 153, parameters; 153, 154; 154, identifier:cls; 155, block; 155, 156; 155, 171; 155, 198; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:sbo_term; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:stmt_sbo_map; 162, identifier:get; 163, argument_list; 163, 164; 164, call; 164, 165; 164, 170; 165, attribute; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:cls; 168, identifier:__name__; 169, identifier:lower; 170, argument_list; 171, while_statement; 171, 172; 171, 174; 172, not_operator; 172, 173; 173, identifier:sbo_term; 174, block; 174, 175; 174, 183; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:cls; 178, subscript; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:cls; 181, identifier:__bases__; 182, integer:0; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:sbo_term; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:stmt_sbo_map; 189, identifier:get; 190, argument_list; 190, 191; 191, call; 191, 192; 191, 197; 192, attribute; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:cls; 195, identifier:__name__; 196, identifier:lower; 197, argument_list; 198, return_statement; 198, 199; 199, identifier:sbo_term; 200, if_statement; 200, 201; 200, 202; 201, identifier:use_sbo; 202, block; 202, 203; 202, 212; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:sbo_term; 206, call; 206, 207; 206, 208; 207, identifier:get_sbo_term; 208, argument_list; 208, 209; 209, attribute; 209, 210; 209, 211; 210, identifier:self; 211, identifier:__class__; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 217; 214, subscript; 214, 215; 214, 216; 215, identifier:json_dict; 216, string:'sbo'; 217, binary_operator:%; 217, 218; 217, 219; 218, string:'http://identifiers.org/sbo/SBO:%s'; 219, identifier:sbo_term; 220, return_statement; 220, 221; 221, identifier:json_dict | def to_json(self, use_sbo=False):
stmt_type = type(self).__name__
all_stmts = [self] + self.supports + self.supported_by
for st in all_stmts:
if not hasattr(st, 'uuid'):
st.uuid = '%s' % uuid.uuid4()
json_dict = _o(type=stmt_type)
json_dict['belief'] = self.belief
if self.evidence:
evidence = [ev.to_json() for ev in self.evidence]
json_dict['evidence'] = evidence
json_dict['id'] = '%s' % self.uuid
if self.supports:
json_dict['supports'] = \
['%s' % st.uuid for st in self.supports]
if self.supported_by:
json_dict['supported_by'] = \
['%s' % st.uuid for st in self.supported_by]
def get_sbo_term(cls):
sbo_term = stmt_sbo_map.get(cls.__name__.lower())
while not sbo_term:
cls = cls.__bases__[0]
sbo_term = stmt_sbo_map.get(cls.__name__.lower())
return sbo_term
if use_sbo:
sbo_term = get_sbo_term(self.__class__)
json_dict['sbo'] = \
'http://identifiers.org/sbo/SBO:%s' % sbo_term
return json_dict |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:to_graph; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 225; 5, 233; 5, 241; 5, 253; 6, function_definition; 6, 7; 6, 8; 6, 12; 7, function_name:json_node; 8, parameters; 8, 9; 8, 10; 8, 11; 9, identifier:graph; 10, identifier:element; 11, identifier:prefix; 12, block; 12, 13; 12, 19; 12, 28; 12, 223; 13, if_statement; 13, 14; 13, 16; 14, not_operator; 14, 15; 15, identifier:element; 16, block; 16, 17; 17, return_statement; 17, 18; 18, None; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:node_id; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, string:'|'; 25, identifier:join; 26, argument_list; 26, 27; 27, identifier:prefix; 28, if_statement; 28, 29; 28, 34; 28, 82; 28, 178; 29, call; 29, 30; 29, 31; 30, identifier:isinstance; 31, argument_list; 31, 32; 31, 33; 32, identifier:element; 33, identifier:list; 34, block; 34, 35; 34, 45; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:graph; 39, identifier:add_node; 40, argument_list; 40, 41; 40, 42; 41, identifier:node_id; 42, keyword_argument; 42, 43; 42, 44; 43, identifier:label; 44, string:''; 45, for_statement; 45, 46; 45, 49; 45, 53; 46, pattern_list; 46, 47; 46, 48; 47, identifier:i; 48, identifier:sub_element; 49, call; 49, 50; 49, 51; 50, identifier:enumerate; 51, argument_list; 51, 52; 52, identifier:element; 53, block; 53, 54; 53, 68; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:sub_id; 57, call; 57, 58; 57, 59; 58, identifier:json_node; 59, argument_list; 59, 60; 59, 61; 59, 62; 60, identifier:graph; 61, identifier:sub_element; 62, binary_operator:+; 62, 63; 62, 64; 63, identifier:prefix; 64, list:['%s' % i]; 64, 65; 65, binary_operator:%; 65, 66; 65, 67; 66, string:'%s'; 67, identifier:i; 68, if_statement; 68, 69; 68, 70; 69, identifier:sub_id; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:graph; 75, identifier:add_edge; 76, argument_list; 76, 77; 76, 78; 76, 79; 77, identifier:node_id; 78, identifier:sub_id; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:label; 81, string:''; 82, elif_clause; 82, 83; 82, 88; 83, call; 83, 84; 83, 85; 84, identifier:isinstance; 85, argument_list; 85, 86; 85, 87; 86, identifier:element; 87, identifier:dict; 88, block; 88, 89; 88, 99; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:graph; 93, identifier:add_node; 94, argument_list; 94, 95; 94, 96; 95, identifier:node_id; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:label; 98, string:''; 99, for_statement; 99, 100; 99, 103; 99, 108; 100, pattern_list; 100, 101; 100, 102; 101, identifier:k; 102, identifier:v; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:element; 106, identifier:items; 107, argument_list; 108, block; 108, 109; 108, 147; 108, 161; 109, if_statement; 109, 110; 109, 113; 109, 115; 109, 131; 110, comparison_operator:==; 110, 111; 110, 112; 111, identifier:k; 112, string:'id'; 113, block; 113, 114; 114, continue_statement; 115, elif_clause; 115, 116; 115, 119; 116, comparison_operator:==; 116, 117; 116, 118; 117, identifier:k; 118, string:'name'; 119, block; 119, 120; 119, 130; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 129; 122, subscript; 122, 123; 122, 128; 123, subscript; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:graph; 126, identifier:node; 127, identifier:node_id; 128, string:'label'; 129, identifier:v; 130, continue_statement; 131, elif_clause; 131, 132; 131, 135; 132, comparison_operator:==; 132, 133; 132, 134; 133, identifier:k; 134, string:'type'; 135, block; 135, 136; 135, 146; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 145; 138, subscript; 138, 139; 138, 144; 139, subscript; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:graph; 142, identifier:node; 143, identifier:node_id; 144, string:'label'; 145, identifier:v; 146, continue_statement; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:sub_id; 150, call; 150, 151; 150, 152; 151, identifier:json_node; 152, argument_list; 152, 153; 152, 154; 152, 155; 153, identifier:graph; 154, identifier:v; 155, binary_operator:+; 155, 156; 155, 157; 156, identifier:prefix; 157, list:['%s' % k]; 157, 158; 158, binary_operator:%; 158, 159; 158, 160; 159, string:'%s'; 160, identifier:k; 161, if_statement; 161, 162; 161, 163; 162, identifier:sub_id; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:graph; 168, identifier:add_edge; 169, argument_list; 169, 170; 169, 171; 169, 172; 170, identifier:node_id; 171, identifier:sub_id; 172, keyword_argument; 172, 173; 172, 174; 173, identifier:label; 174, parenthesized_expression; 174, 175; 175, binary_operator:%; 175, 176; 175, 177; 176, string:'%s'; 177, identifier:k; 178, else_clause; 178, 179; 179, block; 179, 180; 179, 207; 180, if_statement; 180, 181; 180, 194; 181, boolean_operator:and; 181, 182; 181, 187; 181, 188; 182, call; 182, 183; 182, 184; 183, identifier:isinstance; 184, argument_list; 184, 185; 184, 186; 185, identifier:element; 186, identifier:basestring; 187, line_continuation:\; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:element; 191, identifier:startswith; 192, argument_list; 192, 193; 193, string:'http'; 194, block; 194, 195; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:element; 198, subscript; 198, 199; 198, 205; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:element; 202, identifier:split; 203, argument_list; 203, 204; 204, string:'/'; 205, unary_operator:-; 205, 206; 206, integer:1; 207, expression_statement; 207, 208; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:graph; 211, identifier:add_node; 212, argument_list; 212, 213; 212, 214; 213, identifier:node_id; 214, keyword_argument; 214, 215; 214, 216; 215, identifier:label; 216, parenthesized_expression; 216, 217; 217, binary_operator:%; 217, 218; 217, 219; 218, string:'%s'; 219, call; 219, 220; 219, 221; 220, identifier:str; 221, argument_list; 221, 222; 222, identifier:element; 223, return_statement; 223, 224; 224, identifier:node_id; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:jd; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:self; 231, identifier:to_json; 232, argument_list; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:graph; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:networkx; 239, identifier:DiGraph; 240, argument_list; 241, expression_statement; 241, 242; 242, call; 242, 243; 242, 244; 243, identifier:json_node; 244, argument_list; 244, 245; 244, 246; 244, 247; 245, identifier:graph; 246, identifier:jd; 247, list:['%s' % self.uuid]; 247, 248; 248, binary_operator:%; 248, 249; 248, 250; 249, string:'%s'; 250, attribute; 250, 251; 250, 252; 251, identifier:self; 252, identifier:uuid; 253, return_statement; 253, 254; 254, identifier:graph | def to_graph(self):
def json_node(graph, element, prefix):
if not element:
return None
node_id = '|'.join(prefix)
if isinstance(element, list):
graph.add_node(node_id, label='')
for i, sub_element in enumerate(element):
sub_id = json_node(graph, sub_element, prefix + ['%s' % i])
if sub_id:
graph.add_edge(node_id, sub_id, label='')
elif isinstance(element, dict):
graph.add_node(node_id, label='')
for k, v in element.items():
if k == 'id':
continue
elif k == 'name':
graph.node[node_id]['label'] = v
continue
elif k == 'type':
graph.node[node_id]['label'] = v
continue
sub_id = json_node(graph, v, prefix + ['%s' % k])
if sub_id:
graph.add_edge(node_id, sub_id, label=('%s' % k))
else:
if isinstance(element, basestring) and \
element.startswith('http'):
element = element.split('/')[-1]
graph.add_node(node_id, label=('%s' % str(element)))
return node_id
jd = self.to_json()
graph = networkx.DiGraph()
json_node(graph, jd, ['%s' % self.uuid])
return graph |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_bel_stmts; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:filter; 7, False; 8, block; 8, 9; 8, 24; 8, 121; 8, 147; 9, if_statement; 9, 10; 9, 15; 10, comparison_operator:is; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:basename; 14, None; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:bel_stmt_path; 19, binary_operator:%; 19, 20; 19, 21; 20, string:'%s_bel_stmts.pkl'; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:basename; 24, if_statement; 24, 25; 24, 39; 24, 70; 25, boolean_operator:and; 25, 26; 25, 31; 26, comparison_operator:is; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:basename; 30, None; 31, call; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:os; 35, identifier:path; 36, identifier:isfile; 37, argument_list; 37, 38; 38, identifier:bel_stmt_path; 39, block; 39, 40; 39, 49; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:logger; 44, identifier:info; 45, argument_list; 45, 46; 46, binary_operator:%; 46, 47; 46, 48; 47, string:"Loading BEL statements from %s"; 48, identifier:bel_stmt_path; 49, with_statement; 49, 50; 49, 60; 50, with_clause; 50, 51; 51, with_item; 51, 52; 52, as_pattern; 52, 53; 52, 58; 53, call; 53, 54; 53, 55; 54, identifier:open; 55, argument_list; 55, 56; 55, 57; 56, identifier:bel_stmt_path; 57, string:'rb'; 58, as_pattern_target; 58, 59; 59, identifier:f; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:bel_statements; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:pickle; 67, identifier:load; 68, argument_list; 68, 69; 69, identifier:f; 70, else_clause; 70, 71; 71, block; 71, 72; 71, 88; 71, 94; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:bel_proc; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:bel; 78, identifier:process_pybel_neighborhood; 79, argument_list; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:gene_list; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:network_file; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:bel_corpus; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:bel_statements; 91, attribute; 91, 92; 91, 93; 92, identifier:bel_proc; 93, identifier:statements; 94, if_statement; 94, 95; 94, 100; 95, comparison_operator:is; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:basename; 99, None; 100, block; 100, 101; 101, with_statement; 101, 102; 101, 112; 102, with_clause; 102, 103; 103, with_item; 103, 104; 104, as_pattern; 104, 105; 104, 110; 105, call; 105, 106; 105, 107; 106, identifier:open; 107, argument_list; 107, 108; 107, 109; 108, identifier:bel_stmt_path; 109, string:'wb'; 110, as_pattern_target; 110, 111; 111, identifier:f; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:pickle; 117, identifier:dump; 118, argument_list; 118, 119; 118, 120; 119, identifier:bel_statements; 120, identifier:f; 121, if_statement; 121, 122; 121, 123; 122, identifier:filter; 123, block; 123, 124; 124, if_statement; 124, 125; 124, 133; 125, comparison_operator:>; 125, 126; 125, 132; 126, call; 126, 127; 126, 128; 127, identifier:len; 128, argument_list; 128, 129; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:gene_list; 132, integer:1; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:bel_statements; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:ac; 140, identifier:filter_gene_list; 141, argument_list; 141, 142; 141, 143; 141, 146; 142, identifier:bel_statements; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:gene_list; 146, string:'all'; 147, return_statement; 147, 148; 148, identifier:bel_statements | def get_bel_stmts(self, filter=False):
if self.basename is not None:
bel_stmt_path = '%s_bel_stmts.pkl' % self.basename
if self.basename is not None and os.path.isfile(bel_stmt_path):
logger.info("Loading BEL statements from %s" % bel_stmt_path)
with open(bel_stmt_path, 'rb') as f:
bel_statements = pickle.load(f)
else:
bel_proc = bel.process_pybel_neighborhood(self.gene_list,
network_file=self.bel_corpus)
bel_statements = bel_proc.statements
if self.basename is not None:
with open(bel_stmt_path, 'wb') as f:
pickle.dump(bel_statements, f)
if filter:
if len(self.gene_list) > 1:
bel_statements = ac.filter_gene_list(bel_statements,
self.gene_list, 'all')
return bel_statements |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:get_biopax_stmts; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:filter; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:query; 10, string:'pathsbetween'; 11, default_parameter; 11, 12; 11, 13; 12, identifier:database_filter; 13, None; 14, block; 14, 15; 14, 38; 14, 86; 14, 237; 14, 266; 14, 306; 15, if_statement; 15, 16; 15, 21; 16, comparison_operator:is; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:basename; 20, None; 21, block; 21, 22; 21, 30; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:biopax_stmt_path; 25, binary_operator:%; 25, 26; 25, 27; 26, string:'%s_biopax_stmts.pkl'; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:basename; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:biopax_ras_owl_path; 33, binary_operator:%; 33, 34; 33, 35; 34, string:'%s_pc_pathsbetween.owl'; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:basename; 38, if_statement; 38, 39; 38, 53; 39, boolean_operator:and; 39, 40; 39, 45; 40, comparison_operator:is; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:basename; 44, None; 45, call; 45, 46; 45, 51; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:os; 49, identifier:path; 50, identifier:isfile; 51, argument_list; 51, 52; 52, identifier:biopax_stmt_path; 53, block; 53, 54; 53, 63; 53, 84; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:logger; 58, identifier:info; 59, argument_list; 59, 60; 60, binary_operator:%; 60, 61; 60, 62; 61, string:"Loading Biopax statements from %s"; 62, identifier:biopax_stmt_path; 63, with_statement; 63, 64; 63, 74; 64, with_clause; 64, 65; 65, with_item; 65, 66; 66, as_pattern; 66, 67; 66, 72; 67, call; 67, 68; 67, 69; 68, identifier:open; 69, argument_list; 69, 70; 69, 71; 70, identifier:biopax_stmt_path; 71, string:'rb'; 72, as_pattern_target; 72, 73; 73, identifier:f; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:bp_statements; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:pickle; 81, identifier:load; 82, argument_list; 82, 83; 83, identifier:f; 84, return_statement; 84, 85; 85, identifier:bp_statements; 86, if_statement; 86, 87; 86, 101; 86, 120; 87, boolean_operator:and; 87, 88; 87, 93; 88, comparison_operator:is; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:basename; 92, None; 93, call; 93, 94; 93, 99; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:os; 97, identifier:path; 98, identifier:isfile; 99, argument_list; 99, 100; 100, identifier:biopax_ras_owl_path; 101, block; 101, 102; 101, 111; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:logger; 106, identifier:info; 107, argument_list; 107, 108; 108, binary_operator:%; 108, 109; 108, 110; 109, string:"Loading Biopax from OWL file %s"; 110, identifier:biopax_ras_owl_path; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:bp; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:biopax; 117, identifier:process_owl; 118, argument_list; 118, 119; 119, identifier:biopax_ras_owl_path; 120, else_clause; 120, 121; 121, block; 121, 122; 121, 149; 121, 223; 122, if_statement; 122, 123; 122, 137; 123, boolean_operator:and; 123, 124; 123, 133; 124, parenthesized_expression; 124, 125; 125, comparison_operator:<; 125, 126; 125, 132; 126, call; 126, 127; 126, 128; 127, identifier:len; 128, argument_list; 128, 129; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:gene_list; 132, integer:2; 133, parenthesized_expression; 133, 134; 134, comparison_operator:==; 134, 135; 134, 136; 135, identifier:query; 136, string:'pathsbetween'; 137, block; 137, 138; 137, 145; 138, expression_statement; 138, 139; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:logger; 142, identifier:warning; 143, argument_list; 143, 144; 144, string:'Using neighborhood query for one gene.'; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:query; 148, string:'neighborhood'; 149, if_statement; 149, 150; 149, 153; 149, 191; 149, 210; 150, comparison_operator:==; 150, 151; 150, 152; 151, identifier:query; 152, string:'pathsbetween'; 153, block; 153, 154; 153, 174; 154, if_statement; 154, 155; 154, 163; 154, 168; 155, comparison_operator:>; 155, 156; 155, 162; 156, call; 156, 157; 156, 158; 157, identifier:len; 158, argument_list; 158, 159; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:gene_list; 162, integer:60; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:block_size; 167, integer:60; 168, else_clause; 168, 169; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:block_size; 173, None; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:bp; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:biopax; 180, identifier:process_pc_pathsbetween; 181, argument_list; 181, 182; 181, 185; 181, 188; 182, attribute; 182, 183; 182, 184; 183, identifier:self; 184, identifier:gene_list; 185, keyword_argument; 185, 186; 185, 187; 186, identifier:database_filter; 187, identifier:database_filter; 188, keyword_argument; 188, 189; 188, 190; 189, identifier:block_size; 190, identifier:block_size; 191, elif_clause; 191, 192; 191, 195; 192, comparison_operator:==; 192, 193; 192, 194; 193, identifier:query; 194, string:'neighborhood'; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:bp; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:biopax; 202, identifier:process_pc_neighborhood; 203, argument_list; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:self; 206, identifier:gene_list; 207, keyword_argument; 207, 208; 207, 209; 208, identifier:database_filter; 209, identifier:database_filter; 210, else_clause; 210, 211; 211, block; 211, 212; 211, 221; 212, expression_statement; 212, 213; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:logger; 216, identifier:error; 217, argument_list; 217, 218; 218, binary_operator:%; 218, 219; 218, 220; 219, string:'Invalid query type: %s'; 220, identifier:query; 221, return_statement; 221, 222; 222, list:[]; 223, if_statement; 223, 224; 223, 229; 224, comparison_operator:is; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:self; 227, identifier:basename; 228, None; 229, block; 229, 230; 230, expression_statement; 230, 231; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:bp; 234, identifier:save_model; 235, argument_list; 235, 236; 236, identifier:biopax_ras_owl_path; 237, if_statement; 237, 238; 237, 243; 238, comparison_operator:is; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:self; 241, identifier:basename; 242, None; 243, block; 243, 244; 244, with_statement; 244, 245; 244, 255; 245, with_clause; 245, 246; 246, with_item; 246, 247; 247, as_pattern; 247, 248; 247, 253; 248, call; 248, 249; 248, 250; 249, identifier:open; 250, argument_list; 250, 251; 250, 252; 251, identifier:biopax_stmt_path; 252, string:'wb'; 253, as_pattern_target; 253, 254; 254, identifier:f; 255, block; 255, 256; 256, expression_statement; 256, 257; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:pickle; 260, identifier:dump; 261, argument_list; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:bp; 264, identifier:statements; 265, identifier:f; 266, if_statement; 266, 267; 266, 268; 266, 298; 267, identifier:filter; 268, block; 268, 269; 268, 283; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:policy; 272, conditional_expression:if; 272, 273; 272, 274; 272, 282; 273, string:'one'; 274, comparison_operator:>; 274, 275; 274, 281; 275, call; 275, 276; 275, 277; 276, identifier:len; 277, argument_list; 277, 278; 278, attribute; 278, 279; 278, 280; 279, identifier:self; 280, identifier:gene_list; 281, integer:1; 282, string:'all'; 283, expression_statement; 283, 284; 284, assignment; 284, 285; 284, 286; 285, identifier:stmts; 286, call; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:ac; 289, identifier:filter_gene_list; 290, argument_list; 290, 291; 290, 294; 290, 297; 291, attribute; 291, 292; 291, 293; 292, identifier:bp; 293, identifier:statements; 294, attribute; 294, 295; 294, 296; 295, identifier:self; 296, identifier:gene_list; 297, identifier:policy; 298, else_clause; 298, 299; 299, block; 299, 300; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:stmts; 303, attribute; 303, 304; 303, 305; 304, identifier:bp; 305, identifier:statements; 306, return_statement; 306, 307; 307, identifier:stmts | def get_biopax_stmts(self, filter=False, query='pathsbetween',
database_filter=None):
if self.basename is not None:
biopax_stmt_path = '%s_biopax_stmts.pkl' % self.basename
biopax_ras_owl_path = '%s_pc_pathsbetween.owl' % self.basename
if self.basename is not None and os.path.isfile(biopax_stmt_path):
logger.info("Loading Biopax statements from %s" % biopax_stmt_path)
with open(biopax_stmt_path, 'rb') as f:
bp_statements = pickle.load(f)
return bp_statements
if self.basename is not None and os.path.isfile(biopax_ras_owl_path):
logger.info("Loading Biopax from OWL file %s" % biopax_ras_owl_path)
bp = biopax.process_owl(biopax_ras_owl_path)
else:
if (len(self.gene_list) < 2) and (query == 'pathsbetween'):
logger.warning('Using neighborhood query for one gene.')
query = 'neighborhood'
if query == 'pathsbetween':
if len(self.gene_list) > 60:
block_size = 60
else:
block_size = None
bp = biopax.process_pc_pathsbetween(self.gene_list,
database_filter=database_filter,
block_size=block_size)
elif query == 'neighborhood':
bp = biopax.process_pc_neighborhood(self.gene_list,
database_filter=database_filter)
else:
logger.error('Invalid query type: %s' % query)
return []
if self.basename is not None:
bp.save_model(biopax_ras_owl_path)
if self.basename is not None:
with open(biopax_stmt_path, 'wb') as f:
pickle.dump(bp.statements, f)
if filter:
policy = 'one' if len(self.gene_list) > 1 else 'all'
stmts = ac.filter_gene_list(bp.statements, self.gene_list, policy)
else:
stmts = bp.statements
return stmts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:run_preassembly; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:stmts; 6, default_parameter; 6, 7; 6, 8; 7, identifier:print_summary; 8, True; 9, block; 9, 10; 9, 18; 9, 25; 9, 31; 9, 38; 9, 51; 9, 55; 9, 87; 9, 93; 9, 101; 9, 108; 9, 114; 9, 120; 9, 126; 9, 134; 9, 144; 9, 152; 9, 160; 9, 168; 9, 178; 9, 188; 9, 269; 9, 306; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:pa1; 13, call; 13, 14; 13, 15; 14, identifier:Preassembler; 15, argument_list; 15, 16; 15, 17; 16, identifier:hierarchies; 17, identifier:stmts; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:logger; 22, identifier:info; 23, argument_list; 23, 24; 24, string:"Combining duplicates"; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:pa1; 29, identifier:combine_duplicates; 30, argument_list; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:logger; 35, identifier:info; 36, argument_list; 36, 37; 37, string:"Mapping sites"; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 43; 40, tuple_pattern; 40, 41; 40, 42; 41, identifier:valid; 42, identifier:mapped; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:sm; 46, identifier:map_sites; 47, argument_list; 47, 48; 48, attribute; 48, 49; 48, 50; 49, identifier:pa1; 50, identifier:unique_stmts; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:correctly_mapped_stmts; 54, list:[]; 55, for_statement; 55, 56; 55, 57; 55, 58; 56, identifier:ms; 57, identifier:mapped; 58, block; 58, 59; 59, if_statement; 59, 60; 59, 77; 60, call; 60, 61; 60, 62; 61, identifier:all; 62, argument_list; 62, 63; 63, list_comprehension; 63, 64; 63, 72; 64, conditional_expression:if; 64, 65; 64, 66; 64, 71; 65, True; 66, comparison_operator:is; 66, 67; 66, 70; 67, subscript; 67, 68; 67, 69; 68, identifier:mm; 69, integer:1; 70, None; 71, False; 72, for_in_clause; 72, 73; 72, 74; 73, identifier:mm; 74, attribute; 74, 75; 74, 76; 75, identifier:ms; 76, identifier:mapped_mods; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:correctly_mapped_stmts; 82, identifier:append; 83, argument_list; 83, 84; 84, attribute; 84, 85; 84, 86; 85, identifier:ms; 86, identifier:mapped_stmt; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:mapped_stmts; 90, binary_operator:+; 90, 91; 90, 92; 91, identifier:valid; 92, identifier:correctly_mapped_stmts; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:pa2; 96, call; 96, 97; 96, 98; 97, identifier:Preassembler; 98, argument_list; 98, 99; 98, 100; 99, identifier:hierarchies; 100, identifier:mapped_stmts; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:logger; 105, identifier:info; 106, argument_list; 106, 107; 107, string:"Combining duplicates again"; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:pa2; 112, identifier:combine_duplicates; 113, argument_list; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:pa2; 118, identifier:combine_related; 119, argument_list; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:results; 125, dictionary; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 133; 128, subscript; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:results; 132, string:'raw'; 133, identifier:stmts; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 141; 136, subscript; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:self; 139, identifier:results; 140, string:'duplicates1'; 141, attribute; 141, 142; 141, 143; 142, identifier:pa1; 143, identifier:unique_stmts; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 151; 146, subscript; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:results; 150, string:'valid'; 151, identifier:valid; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 159; 154, subscript; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:results; 158, string:'mapped'; 159, identifier:mapped; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 167; 162, subscript; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:self; 165, identifier:results; 166, string:'mapped_stmts'; 167, identifier:mapped_stmts; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 175; 170, subscript; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:self; 173, identifier:results; 174, string:'duplicates2'; 175, attribute; 175, 176; 175, 177; 176, identifier:pa2; 177, identifier:unique_stmts; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 185; 180, subscript; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:self; 183, identifier:results; 184, string:'related2'; 185, attribute; 185, 186; 185, 187; 186, identifier:pa2; 187, identifier:related_stmts; 188, if_statement; 188, 189; 188, 190; 189, identifier:print_summary; 190, block; 190, 191; 190, 203; 190, 217; 190, 229; 190, 241; 190, 255; 191, expression_statement; 191, 192; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:logger; 195, identifier:info; 196, argument_list; 196, 197; 197, binary_operator:%; 197, 198; 197, 199; 198, string:"\nStarting number of statements: %d"; 199, call; 199, 200; 199, 201; 200, identifier:len; 201, argument_list; 201, 202; 202, identifier:stmts; 203, expression_statement; 203, 204; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:logger; 207, identifier:info; 208, argument_list; 208, 209; 209, binary_operator:%; 209, 210; 209, 211; 210, string:"After duplicate removal: %d"; 211, call; 211, 212; 211, 213; 212, identifier:len; 213, argument_list; 213, 214; 214, attribute; 214, 215; 214, 216; 215, identifier:pa1; 216, identifier:unique_stmts; 217, expression_statement; 217, 218; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:logger; 221, identifier:info; 222, argument_list; 222, 223; 223, binary_operator:%; 223, 224; 223, 225; 224, string:"Unique statements with valid sites: %d"; 225, call; 225, 226; 225, 227; 226, identifier:len; 227, argument_list; 227, 228; 228, identifier:valid; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:logger; 233, identifier:info; 234, argument_list; 234, 235; 235, binary_operator:%; 235, 236; 235, 237; 236, string:"Unique statements with invalid sites: %d"; 237, call; 237, 238; 237, 239; 238, identifier:len; 239, argument_list; 239, 240; 240, identifier:mapped; 241, expression_statement; 241, 242; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:logger; 245, identifier:info; 246, argument_list; 246, 247; 247, binary_operator:%; 247, 248; 247, 249; 248, string:"After post-mapping duplicate removal: %d"; 249, call; 249, 250; 249, 251; 250, identifier:len; 251, argument_list; 251, 252; 252, attribute; 252, 253; 252, 254; 253, identifier:pa2; 254, identifier:unique_stmts; 255, expression_statement; 255, 256; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:logger; 259, identifier:info; 260, argument_list; 260, 261; 261, binary_operator:%; 261, 262; 261, 263; 262, string:"After combining related statements: %d"; 263, call; 263, 264; 263, 265; 264, identifier:len; 265, argument_list; 265, 266; 266, attribute; 266, 267; 266, 268; 267, identifier:pa2; 268, identifier:related_stmts; 269, if_statement; 269, 270; 269, 275; 270, comparison_operator:is; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:self; 273, identifier:basename; 274, None; 275, block; 275, 276; 275, 284; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 278, identifier:results_filename; 279, binary_operator:%; 279, 280; 279, 281; 280, string:'%s_results.pkl'; 281, attribute; 281, 282; 281, 283; 282, identifier:self; 283, identifier:basename; 284, with_statement; 284, 285; 284, 295; 285, with_clause; 285, 286; 286, with_item; 286, 287; 287, as_pattern; 287, 288; 287, 293; 288, call; 288, 289; 288, 290; 289, identifier:open; 290, argument_list; 290, 291; 290, 292; 291, identifier:results_filename; 292, string:'wb'; 293, as_pattern_target; 293, 294; 294, identifier:f; 295, block; 295, 296; 296, expression_statement; 296, 297; 297, call; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:pickle; 300, identifier:dump; 301, argument_list; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:self; 304, identifier:results; 305, identifier:f; 306, return_statement; 306, 307; 307, attribute; 307, 308; 307, 309; 308, identifier:self; 309, identifier:results | def run_preassembly(self, stmts, print_summary=True):
pa1 = Preassembler(hierarchies, stmts)
logger.info("Combining duplicates")
pa1.combine_duplicates()
logger.info("Mapping sites")
(valid, mapped) = sm.map_sites(pa1.unique_stmts)
correctly_mapped_stmts = []
for ms in mapped:
if all([True if mm[1] is not None else False
for mm in ms.mapped_mods]):
correctly_mapped_stmts.append(ms.mapped_stmt)
mapped_stmts = valid + correctly_mapped_stmts
pa2 = Preassembler(hierarchies, mapped_stmts)
logger.info("Combining duplicates again")
pa2.combine_duplicates()
pa2.combine_related()
self.results = {}
self.results['raw'] = stmts
self.results['duplicates1'] = pa1.unique_stmts
self.results['valid'] = valid
self.results['mapped'] = mapped
self.results['mapped_stmts'] = mapped_stmts
self.results['duplicates2'] = pa2.unique_stmts
self.results['related2'] = pa2.related_stmts
if print_summary:
logger.info("\nStarting number of statements: %d" % len(stmts))
logger.info("After duplicate removal: %d" % len(pa1.unique_stmts))
logger.info("Unique statements with valid sites: %d" % len(valid))
logger.info("Unique statements with invalid sites: %d" %
len(mapped))
logger.info("After post-mapping duplicate removal: %d" %
len(pa2.unique_stmts))
logger.info("After combining related statements: %d" %
len(pa2.related_stmts))
if self.basename is not None:
results_filename = '%s_results.pkl' % self.basename
with open(results_filename, 'wb') as f:
pickle.dump(self.results, f)
return self.results |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_get_grounding; 3, parameters; 3, 4; 4, identifier:entity; 5, block; 5, 6; 5, 15; 5, 24; 5, 30; 5, 100; 5, 117; 5, 121; 5, 146; 5, 186; 5, 195; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:db_refs; 9, dictionary; 9, 10; 10, pair; 10, 11; 10, 12; 11, string:'TEXT'; 12, subscript; 12, 13; 12, 14; 13, identifier:entity; 14, string:'text'; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:groundings; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:entity; 21, identifier:get; 22, argument_list; 22, 23; 23, string:'grounding'; 24, if_statement; 24, 25; 24, 27; 25, not_operator; 25, 26; 26, identifier:groundings; 27, block; 27, 28; 28, return_statement; 28, 29; 29, identifier:db_refs; 30, function_definition; 30, 31; 30, 32; 30, 34; 31, function_name:get_ont_concept; 32, parameters; 32, 33; 33, identifier:concept; 34, block; 34, 35; 34, 98; 35, if_statement; 35, 36; 35, 42; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:concept; 39, identifier:startswith; 40, argument_list; 40, 41; 41, string:'/'; 42, block; 42, 43; 42, 51; 42, 61; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:concept; 46, subscript; 46, 47; 46, 48; 47, identifier:concept; 48, slice; 48, 49; 48, 50; 49, integer:1; 50, colon; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:concept; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:concept; 57, identifier:replace; 58, argument_list; 58, 59; 58, 60; 59, string:' '; 60, string:'_'; 61, while_statement; 61, 62; 61, 65; 62, comparison_operator:not; 62, 63; 62, 64; 63, identifier:concept; 64, identifier:hume_onto_entries; 65, block; 65, 66; 65, 75; 65, 84; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:parts; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:concept; 72, identifier:split; 73, argument_list; 73, 74; 74, string:'/'; 75, if_statement; 75, 76; 75, 82; 76, comparison_operator:==; 76, 77; 76, 81; 77, call; 77, 78; 77, 79; 78, identifier:len; 79, argument_list; 79, 80; 80, identifier:parts; 81, integer:1; 82, block; 82, 83; 83, break_statement; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:concept; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, string:'/'; 90, identifier:join; 91, argument_list; 91, 92; 92, subscript; 92, 93; 92, 94; 93, identifier:parts; 94, slice; 94, 95; 94, 96; 95, colon; 96, unary_operator:-; 96, 97; 97, integer:1; 98, return_statement; 98, 99; 99, identifier:concept; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:raw_grounding_entries; 103, list_comprehension; 103, 104; 103, 114; 104, tuple; 104, 105; 104, 111; 105, call; 105, 106; 105, 107; 106, identifier:get_ont_concept; 107, argument_list; 107, 108; 108, subscript; 108, 109; 108, 110; 109, identifier:g; 110, string:'ontologyConcept'; 111, subscript; 111, 112; 111, 113; 112, identifier:g; 113, string:'value'; 114, for_in_clause; 114, 115; 114, 116; 115, identifier:g; 116, identifier:groundings; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:grounding_dict; 120, dictionary; 121, for_statement; 121, 122; 121, 125; 121, 126; 122, pattern_list; 122, 123; 122, 124; 123, identifier:cat; 124, identifier:score; 125, identifier:raw_grounding_entries; 126, block; 126, 127; 127, if_statement; 127, 128; 127, 139; 128, boolean_operator:or; 128, 129; 128, 133; 129, parenthesized_expression; 129, 130; 130, comparison_operator:not; 130, 131; 130, 132; 131, identifier:cat; 132, identifier:grounding_dict; 133, parenthesized_expression; 133, 134; 134, comparison_operator:>; 134, 135; 134, 136; 135, identifier:score; 136, subscript; 136, 137; 136, 138; 137, identifier:grounding_dict; 138, identifier:cat; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 145; 142, subscript; 142, 143; 142, 144; 143, identifier:grounding_dict; 144, identifier:cat; 145, identifier:score; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:grounding_entries; 149, call; 149, 150; 149, 151; 150, identifier:sorted; 151, argument_list; 151, 152; 151, 163; 151, 183; 152, call; 152, 153; 152, 154; 153, identifier:list; 154, argument_list; 154, 155; 155, call; 155, 156; 155, 157; 156, identifier:set; 157, argument_list; 157, 158; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:grounding_dict; 161, identifier:items; 162, argument_list; 163, keyword_argument; 163, 164; 163, 165; 164, identifier:key; 165, lambda; 165, 166; 165, 168; 166, lambda_parameters; 166, 167; 167, identifier:x; 168, tuple; 168, 169; 168, 172; 168, 180; 169, subscript; 169, 170; 169, 171; 170, identifier:x; 171, integer:1; 172, call; 172, 173; 172, 178; 173, attribute; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:x; 176, integer:0; 177, identifier:count; 178, argument_list; 178, 179; 179, string:'/'; 180, subscript; 180, 181; 180, 182; 181, identifier:x; 182, integer:0; 183, keyword_argument; 183, 184; 183, 185; 184, identifier:reverse; 185, True; 186, if_statement; 186, 187; 186, 188; 187, identifier:grounding_entries; 188, block; 188, 189; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 194; 191, subscript; 191, 192; 191, 193; 192, identifier:db_refs; 193, string:'HUME'; 194, identifier:grounding_entries; 195, return_statement; 195, 196; 196, identifier:db_refs | def _get_grounding(entity):
db_refs = {'TEXT': entity['text']}
groundings = entity.get('grounding')
if not groundings:
return db_refs
def get_ont_concept(concept):
if concept.startswith('/'):
concept = concept[1:]
concept = concept.replace(' ', '_')
while concept not in hume_onto_entries:
parts = concept.split('/')
if len(parts) == 1:
break
concept = '/'.join(parts[:-1])
return concept
raw_grounding_entries = [(get_ont_concept(g['ontologyConcept']),
g['value']) for g in groundings]
grounding_dict = {}
for cat, score in raw_grounding_entries:
if (cat not in grounding_dict) or (score > grounding_dict[cat]):
grounding_dict[cat] = score
grounding_entries = sorted(list(set(grounding_dict.items())),
key=lambda x: (x[1], x[0].count('/'), x[0]),
reverse=True)
if grounding_entries:
db_refs['HUME'] = grounding_entries
return db_refs |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_is_statement_in_list; 3, parameters; 3, 4; 3, 5; 4, identifier:new_stmt; 5, identifier:old_stmt_list; 6, block; 6, 7; 6, 252; 7, for_statement; 7, 8; 7, 9; 7, 10; 8, identifier:old_stmt; 9, identifier:old_stmt_list; 10, block; 10, 11; 11, if_statement; 11, 12; 11, 18; 11, 21; 11, 181; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:old_stmt; 15, identifier:equals; 16, argument_list; 16, 17; 17, identifier:new_stmt; 18, block; 18, 19; 19, return_statement; 19, 20; 20, True; 21, elif_clause; 21, 22; 21, 35; 22, boolean_operator:and; 22, 23; 22, 29; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:old_stmt; 26, identifier:evidence_equals; 27, argument_list; 27, 28; 28, identifier:new_stmt; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:old_stmt; 32, identifier:matches; 33, argument_list; 33, 34; 34, identifier:new_stmt; 35, block; 35, 36; 35, 77; 35, 179; 36, if_statement; 36, 37; 36, 42; 36, 59; 37, call; 37, 38; 37, 39; 38, identifier:isinstance; 39, argument_list; 39, 40; 39, 41; 40, identifier:new_stmt; 41, identifier:Complex; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:agent_pairs; 46, call; 46, 47; 46, 48; 47, identifier:zip; 48, argument_list; 48, 49; 48, 54; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:old_stmt; 52, identifier:sorted_members; 53, argument_list; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:new_stmt; 57, identifier:sorted_members; 58, argument_list; 59, else_clause; 59, 60; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:agent_pairs; 64, call; 64, 65; 64, 66; 65, identifier:zip; 66, argument_list; 66, 67; 66, 72; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:old_stmt; 70, identifier:agent_list; 71, argument_list; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:new_stmt; 75, identifier:agent_list; 76, argument_list; 77, for_statement; 77, 78; 77, 81; 77, 82; 78, pattern_list; 78, 79; 78, 80; 79, identifier:ag_old; 80, identifier:ag_new; 81, identifier:agent_pairs; 82, block; 82, 83; 82, 96; 82, 109; 82, 115; 82, 122; 82, 140; 82, 154; 82, 168; 82, 177; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:s_old; 86, call; 86, 87; 86, 88; 87, identifier:set; 88, argument_list; 88, 89; 89, call; 89, 90; 89, 95; 90, attribute; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:ag_old; 93, identifier:db_refs; 94, identifier:items; 95, argument_list; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:s_new; 99, call; 99, 100; 99, 101; 100, identifier:set; 101, argument_list; 101, 102; 102, call; 102, 103; 102, 108; 103, attribute; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:ag_new; 106, identifier:db_refs; 107, identifier:items; 108, argument_list; 109, if_statement; 109, 110; 109, 113; 110, comparison_operator:==; 110, 111; 110, 112; 111, identifier:s_old; 112, identifier:s_new; 113, block; 113, 114; 114, continue_statement; 115, if_statement; 115, 116; 115, 119; 116, comparison_operator:>; 116, 117; 116, 118; 117, identifier:s_old; 118, identifier:s_new; 119, block; 119, 120; 120, return_statement; 120, 121; 121, True; 122, if_statement; 122, 123; 122, 126; 123, comparison_operator:>; 123, 124; 123, 125; 124, identifier:s_new; 125, identifier:s_old; 126, block; 126, 127; 126, 138; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 134; 129, attribute; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:ag_old; 132, identifier:db_refs; 133, identifier:update; 134, argument_list; 134, 135; 135, attribute; 135, 136; 135, 137; 136, identifier:ag_new; 137, identifier:db_refs; 138, return_statement; 138, 139; 139, True; 140, if_statement; 140, 141; 140, 147; 141, call; 141, 142; 141, 143; 142, identifier:_fix_different_refs; 143, argument_list; 143, 144; 143, 145; 143, 146; 144, identifier:ag_old; 145, identifier:ag_new; 146, string:'CHEBI'; 147, block; 147, 148; 148, return_statement; 148, 149; 149, call; 149, 150; 149, 151; 150, identifier:_is_statement_in_list; 151, argument_list; 151, 152; 151, 153; 152, identifier:new_stmt; 153, identifier:old_stmt_list; 154, if_statement; 154, 155; 154, 161; 155, call; 155, 156; 155, 157; 156, identifier:_fix_different_refs; 157, argument_list; 157, 158; 157, 159; 157, 160; 158, identifier:ag_old; 159, identifier:ag_new; 160, string:'UMLS'; 161, block; 161, 162; 162, return_statement; 162, 163; 163, call; 163, 164; 163, 165; 164, identifier:_is_statement_in_list; 165, argument_list; 165, 166; 165, 167; 166, identifier:new_stmt; 167, identifier:old_stmt_list; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:logger; 172, identifier:warning; 173, argument_list; 173, 174; 174, concatenated_string; 174, 175; 174, 176; 175, string:"Found an unexpected kind of duplicate. "; 176, string:"Ignoring it."; 177, return_statement; 177, 178; 178, True; 179, return_statement; 179, 180; 180, True; 181, elif_clause; 181, 182; 181, 197; 182, comparison_operator:==; 182, 183; 182, 190; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:old_stmt; 186, identifier:get_hash; 187, argument_list; 187, 188; 187, 189; 188, True; 189, True; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:new_stmt; 193, identifier:get_hash; 194, argument_list; 194, 195; 194, 196; 195, True; 196, True; 197, block; 197, 198; 197, 206; 197, 214; 197, 235; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:e_old; 201, subscript; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:old_stmt; 204, identifier:evidence; 205, integer:0; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:e_new; 209, subscript; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:new_stmt; 212, identifier:evidence; 213, integer:0; 214, if_statement; 214, 215; 214, 222; 215, comparison_operator:is; 215, 216; 215, 221; 216, subscript; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:e_old; 219, identifier:annotations; 220, string:'last_verb'; 221, None; 222, block; 222, 223; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 230; 225, subscript; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:e_old; 228, identifier:annotations; 229, string:'last_verb'; 230, subscript; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:e_new; 233, identifier:annotations; 234, string:'last_verb'; 235, if_statement; 235, 236; 235, 249; 236, comparison_operator:==; 236, 237; 236, 243; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:e_old; 240, identifier:get_source_hash; 241, argument_list; 241, 242; 242, True; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:e_new; 246, identifier:get_source_hash; 247, argument_list; 247, 248; 248, True; 249, block; 249, 250; 250, return_statement; 250, 251; 251, True; 252, return_statement; 252, 253; 253, False | def _is_statement_in_list(new_stmt, old_stmt_list):
for old_stmt in old_stmt_list:
if old_stmt.equals(new_stmt):
return True
elif old_stmt.evidence_equals(new_stmt) and old_stmt.matches(new_stmt):
if isinstance(new_stmt, Complex):
agent_pairs = zip(old_stmt.sorted_members(),
new_stmt.sorted_members())
else:
agent_pairs = zip(old_stmt.agent_list(), new_stmt.agent_list())
for ag_old, ag_new in agent_pairs:
s_old = set(ag_old.db_refs.items())
s_new = set(ag_new.db_refs.items())
if s_old == s_new:
continue
if s_old > s_new:
return True
if s_new > s_old:
ag_old.db_refs.update(ag_new.db_refs)
return True
if _fix_different_refs(ag_old, ag_new, 'CHEBI'):
return _is_statement_in_list(new_stmt, old_stmt_list)
if _fix_different_refs(ag_old, ag_new, 'UMLS'):
return _is_statement_in_list(new_stmt, old_stmt_list)
logger.warning("Found an unexpected kind of duplicate. "
"Ignoring it.")
return True
return True
elif old_stmt.get_hash(True, True) == new_stmt.get_hash(True, True):
e_old = old_stmt.evidence[0]
e_new = new_stmt.evidence[0]
if e_old.annotations['last_verb'] is None:
e_old.annotations['last_verb'] = e_new.annotations['last_verb']
if e_old.get_source_hash(True) == e_new.get_source_hash(True):
return True
return False |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_urn_to_db_refs; 3, parameters; 3, 4; 4, identifier:urn; 5, block; 5, 6; 5, 15; 5, 24; 5, 33; 5, 43; 5, 47; 5, 51; 5, 227; 5, 233; 5, 263; 5, 305; 5, 311; 5, 324; 5, 351; 6, if_statement; 6, 7; 6, 10; 7, comparison_operator:is; 7, 8; 7, 9; 8, identifier:urn; 9, None; 10, block; 10, 11; 11, return_statement; 11, 12; 12, expression_list; 12, 13; 12, 14; 13, dictionary; 14, None; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:m; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:URN_PATT; 21, identifier:match; 22, argument_list; 22, 23; 23, identifier:urn; 24, if_statement; 24, 25; 24, 28; 25, comparison_operator:is; 25, 26; 25, 27; 26, identifier:m; 27, None; 28, block; 28, 29; 29, return_statement; 29, 30; 30, expression_list; 30, 31; 30, 32; 31, None; 32, None; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 38; 35, pattern_list; 35, 36; 35, 37; 36, identifier:urn_type; 37, identifier:urn_id; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:m; 41, identifier:groups; 42, argument_list; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:db_refs; 46, dictionary; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:db_name; 50, None; 51, if_statement; 51, 52; 51, 55; 51, 81; 51, 129; 51, 201; 51, 214; 52, comparison_operator:==; 52, 53; 52, 54; 53, identifier:urn_type; 54, string:'agi-cas'; 55, block; 55, 56; 55, 63; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:chebi_id; 59, call; 59, 60; 59, 61; 60, identifier:get_chebi_id_from_cas; 61, argument_list; 61, 62; 62, identifier:urn_id; 63, if_statement; 63, 64; 63, 65; 64, identifier:chebi_id; 65, block; 65, 66; 65, 74; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 71; 68, subscript; 68, 69; 68, 70; 69, identifier:db_refs; 70, string:'CHEBI'; 71, binary_operator:%; 71, 72; 71, 73; 72, string:'CHEBI:%s'; 73, identifier:chebi_id; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:db_name; 77, call; 77, 78; 77, 79; 78, identifier:get_chebi_name_from_id; 79, argument_list; 79, 80; 80, identifier:chebi_id; 81, elif_clause; 81, 82; 81, 85; 82, comparison_operator:==; 82, 83; 82, 84; 83, identifier:urn_type; 84, string:'agi-llid'; 85, block; 85, 86; 85, 93; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:hgnc_id; 89, call; 89, 90; 89, 91; 90, identifier:get_hgnc_from_entrez; 91, argument_list; 91, 92; 92, identifier:urn_id; 93, if_statement; 93, 94; 93, 97; 94, comparison_operator:is; 94, 95; 94, 96; 95, identifier:hgnc_id; 96, None; 97, block; 97, 98; 97, 104; 97, 111; 97, 122; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 103; 100, subscript; 100, 101; 100, 102; 101, identifier:db_refs; 102, string:'HGNC'; 103, identifier:hgnc_id; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:uniprot_id; 107, call; 107, 108; 107, 109; 108, identifier:get_uniprot_id; 109, argument_list; 109, 110; 110, identifier:hgnc_id; 111, if_statement; 111, 112; 111, 115; 112, comparison_operator:is; 112, 113; 112, 114; 113, identifier:uniprot_id; 114, None; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 121; 118, subscript; 118, 119; 118, 120; 119, identifier:db_refs; 120, string:'UP'; 121, identifier:uniprot_id; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:db_name; 125, call; 125, 126; 125, 127; 126, identifier:get_hgnc_name; 127, argument_list; 127, 128; 128, identifier:hgnc_id; 129, elif_clause; 129, 130; 129, 137; 130, comparison_operator:in; 130, 131; 130, 132; 131, identifier:urn_type; 132, list:['agi-meshdis', 'agi-ncimorgan', 'agi-ncimtissue',
'agi-ncimcelltype']; 132, 133; 132, 134; 132, 135; 132, 136; 133, string:'agi-meshdis'; 134, string:'agi-ncimorgan'; 135, string:'agi-ncimtissue'; 136, string:'agi-ncimcelltype'; 137, block; 137, 138; 138, if_statement; 138, 139; 138, 155; 138, 162; 139, boolean_operator:and; 139, 140; 139, 146; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:urn_id; 143, identifier:startswith; 144, argument_list; 144, 145; 145, string:'C'; 146, call; 146, 147; 146, 154; 147, attribute; 147, 148; 147, 153; 148, subscript; 148, 149; 148, 150; 149, identifier:urn_id; 150, slice; 150, 151; 150, 152; 151, integer:1; 152, colon; 153, identifier:isdigit; 154, argument_list; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 161; 158, subscript; 158, 159; 158, 160; 159, identifier:db_refs; 160, string:'UMLS'; 161, identifier:urn_id; 162, else_clause; 162, 163; 163, block; 163, 164; 163, 171; 163, 182; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:urn_mesh_name; 167, call; 167, 168; 167, 169; 168, identifier:unquote; 169, argument_list; 169, 170; 170, identifier:urn_id; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 176; 173, pattern_list; 173, 174; 173, 175; 174, identifier:mesh_id; 175, identifier:mesh_name; 176, call; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:mesh_client; 179, identifier:get_mesh_id_name; 180, argument_list; 180, 181; 181, identifier:urn_mesh_name; 182, if_statement; 182, 183; 182, 184; 182, 195; 183, identifier:mesh_id; 184, block; 184, 185; 184, 191; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 190; 187, subscript; 187, 188; 187, 189; 188, identifier:db_refs; 189, string:'MESH'; 190, identifier:mesh_id; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:db_name; 194, identifier:mesh_name; 195, else_clause; 195, 196; 196, block; 196, 197; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 200; 199, identifier:db_name; 200, identifier:urn_mesh_name; 201, elif_clause; 201, 202; 201, 205; 202, comparison_operator:==; 202, 203; 202, 204; 203, identifier:urn_type; 204, string:'agi-gocomplex'; 205, block; 205, 206; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 211; 208, subscript; 208, 209; 208, 210; 209, identifier:db_refs; 210, string:'GO'; 211, binary_operator:%; 211, 212; 211, 213; 212, string:'GO:%s'; 213, identifier:urn_id; 214, elif_clause; 214, 215; 214, 218; 215, comparison_operator:==; 215, 216; 215, 217; 216, identifier:urn_type; 217, string:'agi-go'; 218, block; 218, 219; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 224; 221, subscript; 221, 222; 221, 223; 222, identifier:db_refs; 223, string:'GO'; 224, binary_operator:%; 224, 225; 224, 226; 225, string:'GO:%s'; 226, identifier:urn_id; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:db_sometimes_maps_to_famplex; 230, list:['GO', 'MESH']; 230, 231; 230, 232; 231, string:'GO'; 232, string:'MESH'; 233, for_statement; 233, 234; 233, 235; 233, 236; 234, identifier:db; 235, identifier:db_sometimes_maps_to_famplex; 236, block; 236, 237; 237, if_statement; 237, 238; 237, 241; 238, comparison_operator:in; 238, 239; 238, 240; 239, identifier:db; 240, identifier:db_refs; 241, block; 241, 242; 241, 250; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:key; 245, tuple; 245, 246; 245, 247; 246, identifier:db; 247, subscript; 247, 248; 247, 249; 248, identifier:db_refs; 249, identifier:db; 250, if_statement; 250, 251; 250, 254; 251, comparison_operator:in; 251, 252; 251, 253; 252, identifier:key; 253, identifier:famplex_map; 254, block; 254, 255; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 260; 257, subscript; 257, 258; 257, 259; 258, identifier:db_refs; 259, string:'FPLX'; 260, subscript; 260, 261; 260, 262; 261, identifier:famplex_map; 262, identifier:key; 263, if_statement; 263, 264; 263, 270; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:urn; 267, identifier:startswith; 268, argument_list; 268, 269; 269, string:'urn:agi-enz'; 270, block; 270, 271; 270, 280; 270, 286; 270, 292; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:tokens; 274, call; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:urn; 277, identifier:split; 278, argument_list; 278, 279; 279, string:':'; 280, expression_statement; 280, 281; 281, assignment; 281, 282; 281, 283; 282, identifier:eccode; 283, subscript; 283, 284; 283, 285; 284, identifier:tokens; 285, integer:2; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 288, identifier:key; 289, tuple; 289, 290; 289, 291; 290, string:'ECCODE'; 291, identifier:eccode; 292, if_statement; 292, 293; 292, 296; 293, comparison_operator:in; 293, 294; 293, 295; 294, identifier:key; 295, identifier:famplex_map; 296, block; 296, 297; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 302; 299, subscript; 299, 300; 299, 301; 300, identifier:db_refs; 301, string:'FPLX'; 302, subscript; 302, 303; 302, 304; 303, identifier:famplex_map; 304, identifier:key; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 308; 307, identifier:key; 308, tuple; 308, 309; 308, 310; 309, string:'MEDSCAN'; 310, identifier:urn; 311, if_statement; 311, 312; 311, 315; 312, comparison_operator:in; 312, 313; 312, 314; 313, identifier:key; 314, identifier:famplex_map; 315, block; 315, 316; 316, expression_statement; 316, 317; 317, assignment; 317, 318; 317, 321; 318, subscript; 318, 319; 318, 320; 319, identifier:db_refs; 320, string:'FPLX'; 321, subscript; 321, 322; 321, 323; 322, identifier:famplex_map; 323, identifier:key; 324, if_statement; 324, 325; 324, 328; 324, 335; 325, comparison_operator:in; 325, 326; 325, 327; 326, string:'FPLX'; 327, identifier:db_refs; 328, block; 328, 329; 329, expression_statement; 329, 330; 330, assignment; 330, 331; 330, 332; 331, identifier:db_name; 332, subscript; 332, 333; 332, 334; 333, identifier:db_refs; 334, string:'FPLX'; 335, elif_clause; 335, 336; 335, 339; 336, comparison_operator:in; 336, 337; 336, 338; 337, string:'GO'; 338, identifier:db_refs; 339, block; 339, 340; 340, expression_statement; 340, 341; 341, assignment; 341, 342; 341, 343; 342, identifier:db_name; 343, call; 343, 344; 343, 347; 344, attribute; 344, 345; 344, 346; 345, identifier:go_client; 346, identifier:get_go_label; 347, argument_list; 347, 348; 348, subscript; 348, 349; 348, 350; 349, identifier:db_refs; 350, string:'GO'; 351, return_statement; 351, 352; 352, expression_list; 352, 353; 352, 354; 353, identifier:db_refs; 354, identifier:db_name | def _urn_to_db_refs(urn):
if urn is None:
return {}, None
m = URN_PATT.match(urn)
if m is None:
return None, None
urn_type, urn_id = m.groups()
db_refs = {}
db_name = None
if urn_type == 'agi-cas':
chebi_id = get_chebi_id_from_cas(urn_id)
if chebi_id:
db_refs['CHEBI'] = 'CHEBI:%s' % chebi_id
db_name = get_chebi_name_from_id(chebi_id)
elif urn_type == 'agi-llid':
hgnc_id = get_hgnc_from_entrez(urn_id)
if hgnc_id is not None:
db_refs['HGNC'] = hgnc_id
uniprot_id = get_uniprot_id(hgnc_id)
if uniprot_id is not None:
db_refs['UP'] = uniprot_id
db_name = get_hgnc_name(hgnc_id)
elif urn_type in ['agi-meshdis', 'agi-ncimorgan', 'agi-ncimtissue',
'agi-ncimcelltype']:
if urn_id.startswith('C') and urn_id[1:].isdigit():
db_refs['UMLS'] = urn_id
else:
urn_mesh_name = unquote(urn_id)
mesh_id, mesh_name = mesh_client.get_mesh_id_name(urn_mesh_name)
if mesh_id:
db_refs['MESH'] = mesh_id
db_name = mesh_name
else:
db_name = urn_mesh_name
elif urn_type == 'agi-gocomplex':
db_refs['GO'] = 'GO:%s' % urn_id
elif urn_type == 'agi-go':
db_refs['GO'] = 'GO:%s' % urn_id
db_sometimes_maps_to_famplex = ['GO', 'MESH']
for db in db_sometimes_maps_to_famplex:
if db in db_refs:
key = (db, db_refs[db])
if key in famplex_map:
db_refs['FPLX'] = famplex_map[key]
if urn.startswith('urn:agi-enz'):
tokens = urn.split(':')
eccode = tokens[2]
key = ('ECCODE', eccode)
if key in famplex_map:
db_refs['FPLX'] = famplex_map[key]
key = ('MEDSCAN', urn)
if key in famplex_map:
db_refs['FPLX'] = famplex_map[key]
if 'FPLX' in db_refs:
db_name = db_refs['FPLX']
elif 'GO' in db_refs:
db_name = go_client.get_go_label(db_refs['GO'])
return db_refs, db_name |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:symmetricsys; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 4, default_parameter; 4, 5; 4, 6; 5, identifier:dep_tr; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:indep_tr; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:SuperClass; 12, identifier:TransformedSys; 13, dictionary_splat_pattern; 13, 14; 14, identifier:kwargs; 15, block; 15, 16; 15, 43; 15, 70; 15, 240; 16, if_statement; 16, 17; 16, 20; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:dep_tr; 19, None; 20, block; 20, 21; 21, if_statement; 21, 22; 21, 37; 22, boolean_operator:or; 22, 23; 22, 30; 23, not_operator; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:callable; 26, argument_list; 26, 27; 27, subscript; 27, 28; 27, 29; 28, identifier:dep_tr; 29, integer:0; 30, not_operator; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:callable; 33, argument_list; 33, 34; 34, subscript; 34, 35; 34, 36; 35, identifier:dep_tr; 36, integer:1; 37, block; 37, 38; 38, raise_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:ValueError; 41, argument_list; 41, 42; 42, string:"Exceptected dep_tr to be a pair of callables"; 43, if_statement; 43, 44; 43, 47; 44, comparison_operator:is; 44, 45; 44, 46; 45, identifier:indep_tr; 46, None; 47, block; 47, 48; 48, if_statement; 48, 49; 48, 64; 49, boolean_operator:or; 49, 50; 49, 57; 50, not_operator; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:callable; 53, argument_list; 53, 54; 54, subscript; 54, 55; 54, 56; 55, identifier:indep_tr; 56, integer:0; 57, not_operator; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:callable; 60, argument_list; 60, 61; 61, subscript; 61, 62; 61, 63; 62, identifier:indep_tr; 63, integer:1; 64, block; 64, 65; 65, raise_statement; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:ValueError; 68, argument_list; 68, 69; 69, string:"Exceptected indep_tr to be a pair of callables"; 70, class_definition; 70, 71; 70, 72; 70, 74; 71, identifier:_SymmetricSys; 72, argument_list; 72, 73; 73, identifier:SuperClass; 74, block; 74, 75; 74, 183; 75, function_definition; 75, 76; 75, 77; 75, 85; 76, function_name:__init__; 77, parameters; 77, 78; 77, 79; 77, 80; 77, 83; 78, identifier:self; 79, identifier:dep_exprs; 80, default_parameter; 80, 81; 80, 82; 81, identifier:indep; 82, None; 83, dictionary_splat_pattern; 83, 84; 84, identifier:inner_kwargs; 85, block; 85, 86; 85, 94; 85, 101; 85, 111; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:new_kwargs; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:kwargs; 92, identifier:copy; 93, argument_list; 94, expression_statement; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:new_kwargs; 98, identifier:update; 99, argument_list; 99, 100; 100, identifier:inner_kwargs; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 106; 103, pattern_list; 103, 104; 103, 105; 104, identifier:dep; 105, identifier:exprs; 106, call; 106, 107; 106, 108; 107, identifier:zip; 108, argument_list; 108, 109; 109, list_splat; 109, 110; 110, identifier:dep_exprs; 111, expression_statement; 111, 112; 112, call; 112, 113; 112, 120; 113, attribute; 113, 114; 113, 119; 114, call; 114, 115; 114, 116; 115, identifier:super; 116, argument_list; 116, 117; 116, 118; 117, identifier:_SymmetricSys; 118, identifier:self; 119, identifier:__init__; 120, argument_list; 120, 121; 120, 126; 120, 127; 120, 160; 120, 181; 121, call; 121, 122; 121, 123; 122, identifier:zip; 123, argument_list; 123, 124; 123, 125; 124, identifier:dep; 125, identifier:exprs; 126, identifier:indep; 127, keyword_argument; 127, 128; 127, 129; 128, identifier:dep_transf; 129, conditional_expression:if; 129, 130; 129, 156; 129, 159; 130, call; 130, 131; 130, 132; 131, identifier:list; 132, argument_list; 132, 133; 133, call; 133, 134; 133, 135; 134, identifier:zip; 135, argument_list; 135, 136; 135, 146; 136, call; 136, 137; 136, 138; 137, identifier:list; 138, argument_list; 138, 139; 139, call; 139, 140; 139, 141; 140, identifier:map; 141, argument_list; 141, 142; 141, 145; 142, subscript; 142, 143; 142, 144; 143, identifier:dep_tr; 144, integer:0; 145, identifier:dep; 146, call; 146, 147; 146, 148; 147, identifier:list; 148, argument_list; 148, 149; 149, call; 149, 150; 149, 151; 150, identifier:map; 151, argument_list; 151, 152; 151, 155; 152, subscript; 152, 153; 152, 154; 153, identifier:dep_tr; 154, integer:1; 155, identifier:dep; 156, comparison_operator:is; 156, 157; 156, 158; 157, identifier:dep_tr; 158, None; 159, None; 160, keyword_argument; 160, 161; 160, 162; 161, identifier:indep_transf; 162, parenthesized_expression; 162, 163; 163, conditional_expression:if; 163, 164; 163, 177; 163, 180; 164, tuple; 164, 165; 164, 171; 165, call; 165, 166; 165, 169; 166, subscript; 166, 167; 166, 168; 167, identifier:indep_tr; 168, integer:0; 169, argument_list; 169, 170; 170, identifier:indep; 171, call; 171, 172; 171, 175; 172, subscript; 172, 173; 172, 174; 173, identifier:indep_tr; 174, integer:1; 175, argument_list; 175, 176; 176, identifier:indep; 177, comparison_operator:is; 177, 178; 177, 179; 178, identifier:indep_tr; 179, None; 180, None; 181, dictionary_splat; 181, 182; 182, identifier:new_kwargs; 183, decorated_definition; 183, 184; 183, 186; 184, decorator; 184, 185; 185, identifier:classmethod; 186, function_definition; 186, 187; 186, 188; 186, 199; 187, function_name:from_callback; 188, parameters; 188, 189; 188, 190; 188, 191; 188, 194; 188, 197; 189, identifier:cls; 190, identifier:cb; 191, default_parameter; 191, 192; 191, 193; 192, identifier:ny; 193, None; 194, default_parameter; 194, 195; 194, 196; 195, identifier:nparams; 196, None; 197, dictionary_splat_pattern; 197, 198; 198, identifier:inner_kwargs; 199, block; 199, 200; 199, 208; 199, 215; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 203; 202, identifier:new_kwargs; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:kwargs; 206, identifier:copy; 207, argument_list; 208, expression_statement; 208, 209; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:new_kwargs; 212, identifier:update; 213, argument_list; 213, 214; 214, identifier:inner_kwargs; 215, return_statement; 215, 216; 216, call; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:SuperClass; 219, identifier:from_callback; 220, argument_list; 220, 221; 220, 222; 220, 223; 220, 224; 220, 235; 220, 238; 221, identifier:cb; 222, identifier:ny; 223, identifier:nparams; 224, keyword_argument; 224, 225; 224, 226; 225, identifier:dep_transf_cbs; 226, conditional_expression:if; 226, 227; 226, 231; 226, 234; 227, call; 227, 228; 227, 229; 228, identifier:repeat; 229, argument_list; 229, 230; 230, identifier:dep_tr; 231, comparison_operator:is; 231, 232; 231, 233; 232, identifier:dep_tr; 233, None; 234, None; 235, keyword_argument; 235, 236; 235, 237; 236, identifier:indep_transf_cbs; 237, identifier:indep_tr; 238, dictionary_splat; 238, 239; 239, identifier:new_kwargs; 240, return_statement; 240, 241; 241, identifier:_SymmetricSys | def symmetricsys(dep_tr=None, indep_tr=None, SuperClass=TransformedSys, **kwargs):
if dep_tr is not None:
if not callable(dep_tr[0]) or not callable(dep_tr[1]):
raise ValueError("Exceptected dep_tr to be a pair of callables")
if indep_tr is not None:
if not callable(indep_tr[0]) or not callable(indep_tr[1]):
raise ValueError("Exceptected indep_tr to be a pair of callables")
class _SymmetricSys(SuperClass):
def __init__(self, dep_exprs, indep=None, **inner_kwargs):
new_kwargs = kwargs.copy()
new_kwargs.update(inner_kwargs)
dep, exprs = zip(*dep_exprs)
super(_SymmetricSys, self).__init__(
zip(dep, exprs), indep,
dep_transf=list(zip(
list(map(dep_tr[0], dep)),
list(map(dep_tr[1], dep))
)) if dep_tr is not None else None,
indep_transf=((indep_tr[0](indep), indep_tr[1](indep))
if indep_tr is not None else None),
**new_kwargs)
@classmethod
def from_callback(cls, cb, ny=None, nparams=None, **inner_kwargs):
new_kwargs = kwargs.copy()
new_kwargs.update(inner_kwargs)
return SuperClass.from_callback(
cb, ny, nparams,
dep_transf_cbs=repeat(dep_tr) if dep_tr is not None else None,
indep_transf_cbs=indep_tr,
**new_kwargs)
return _SymmetricSys |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:from_other; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:cls; 5, identifier:ori; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 45; 8, 66; 8, 87; 8, 120; 8, 153; 8, 172; 8, 185; 8, 193; 8, 217; 9, for_statement; 9, 10; 9, 11; 9, 20; 10, identifier:k; 11, binary_operator:+; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:cls; 14, identifier:_attrs_to_copy; 15, tuple; 15, 16; 15, 17; 15, 18; 15, 19; 16, string:'params'; 17, string:'roots'; 18, string:'init_indep'; 19, string:'init_dep'; 20, block; 20, 21; 21, if_statement; 21, 22; 21, 25; 22, comparison_operator:not; 22, 23; 22, 24; 23, identifier:k; 24, identifier:kwargs; 25, block; 25, 26; 25, 34; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:val; 29, call; 29, 30; 29, 31; 30, identifier:getattr; 31, argument_list; 31, 32; 31, 33; 32, identifier:ori; 33, identifier:k; 34, if_statement; 34, 35; 34, 38; 35, comparison_operator:is; 35, 36; 35, 37; 36, identifier:val; 37, None; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 44; 41, subscript; 41, 42; 41, 43; 42, identifier:kwargs; 43, identifier:k; 44, identifier:val; 45, if_statement; 45, 46; 45, 57; 46, boolean_operator:and; 46, 47; 46, 50; 47, comparison_operator:not; 47, 48; 47, 49; 48, string:'lower_bounds'; 49, identifier:kwargs; 50, comparison_operator:is; 50, 51; 50, 56; 51, call; 51, 52; 51, 53; 52, identifier:getattr; 53, argument_list; 53, 54; 53, 55; 54, identifier:ori; 55, string:'lower_bounds'; 56, None; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 63; 60, subscript; 60, 61; 60, 62; 61, identifier:kwargs; 62, string:'lower_bounds'; 63, attribute; 63, 64; 63, 65; 64, identifier:ori; 65, identifier:lower_bounds; 66, if_statement; 66, 67; 66, 78; 67, boolean_operator:and; 67, 68; 67, 71; 68, comparison_operator:not; 68, 69; 68, 70; 69, string:'upper_bounds'; 70, identifier:kwargs; 71, comparison_operator:is; 71, 72; 71, 77; 72, call; 72, 73; 72, 74; 73, identifier:getattr; 74, argument_list; 74, 75; 74, 76; 75, identifier:ori; 76, string:'upper_bounds'; 77, None; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 84; 81, subscript; 81, 82; 81, 83; 82, identifier:kwargs; 83, string:'upper_bounds'; 84, attribute; 84, 85; 84, 86; 85, identifier:ori; 86, identifier:upper_bounds; 87, if_statement; 87, 88; 87, 96; 88, comparison_operator:>; 88, 89; 88, 95; 89, call; 89, 90; 89, 91; 90, identifier:len; 91, argument_list; 91, 92; 92, attribute; 92, 93; 92, 94; 93, identifier:ori; 94, identifier:pre_processors; 95, integer:0; 96, block; 96, 97; 96, 108; 97, if_statement; 97, 98; 97, 101; 98, comparison_operator:not; 98, 99; 98, 100; 99, string:'pre_processors'; 100, identifier:kwargs; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:kwargs; 106, string:'pre_processors'; 107, list:[]; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 113; 110, subscript; 110, 111; 110, 112; 111, identifier:kwargs; 112, string:'pre_processors'; 113, binary_operator:+; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:kwargs; 116, string:'pre_processors'; 117, attribute; 117, 118; 117, 119; 118, identifier:ori; 119, identifier:pre_processors; 120, if_statement; 120, 121; 120, 129; 121, comparison_operator:>; 121, 122; 121, 128; 122, call; 122, 123; 122, 124; 123, identifier:len; 124, argument_list; 124, 125; 125, attribute; 125, 126; 125, 127; 126, identifier:ori; 127, identifier:post_processors; 128, integer:0; 129, block; 129, 130; 129, 141; 130, if_statement; 130, 131; 130, 134; 131, comparison_operator:not; 131, 132; 131, 133; 132, string:'post_processors'; 133, identifier:kwargs; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 140; 137, subscript; 137, 138; 137, 139; 138, identifier:kwargs; 139, string:'post_processors'; 140, list:[]; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 146; 143, subscript; 143, 144; 143, 145; 144, identifier:kwargs; 145, string:'post_processors'; 146, binary_operator:+; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:ori; 149, identifier:post_processors; 150, subscript; 150, 151; 150, 152; 151, identifier:kwargs; 152, string:'post_processors'; 153, if_statement; 153, 154; 153, 157; 154, comparison_operator:not; 154, 155; 154, 156; 155, string:'dep_exprs'; 156, identifier:kwargs; 157, block; 157, 158; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 163; 160, subscript; 160, 161; 160, 162; 161, identifier:kwargs; 162, string:'dep_exprs'; 163, call; 163, 164; 163, 165; 164, identifier:zip; 165, argument_list; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:ori; 168, identifier:dep; 169, attribute; 169, 170; 169, 171; 170, identifier:ori; 171, identifier:exprs; 172, if_statement; 172, 173; 172, 176; 173, comparison_operator:not; 173, 174; 173, 175; 174, string:'indep'; 175, identifier:kwargs; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 182; 179, subscript; 179, 180; 179, 181; 180, identifier:kwargs; 181, string:'indep'; 182, attribute; 182, 183; 182, 184; 183, identifier:ori; 184, identifier:indep; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:instance; 188, call; 188, 189; 188, 190; 189, identifier:cls; 190, argument_list; 190, 191; 191, dictionary_splat; 191, 192; 192, identifier:kwargs; 193, for_statement; 193, 194; 193, 195; 193, 198; 194, identifier:attr; 195, attribute; 195, 196; 195, 197; 196, identifier:ori; 197, identifier:_attrs_to_copy; 198, block; 198, 199; 199, if_statement; 199, 200; 199, 205; 200, comparison_operator:not; 200, 201; 200, 202; 201, identifier:attr; 202, attribute; 202, 203; 202, 204; 203, identifier:cls; 204, identifier:_attrs_to_copy; 205, block; 205, 206; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 209; 208, identifier:setattr; 209, argument_list; 209, 210; 209, 211; 209, 212; 210, identifier:instance; 211, identifier:attr; 212, call; 212, 213; 212, 214; 213, identifier:getattr; 214, argument_list; 214, 215; 214, 216; 215, identifier:ori; 216, identifier:attr; 217, return_statement; 217, 218; 218, identifier:instance | def from_other(cls, ori, **kwargs):
for k in cls._attrs_to_copy + ('params', 'roots', 'init_indep', 'init_dep'):
if k not in kwargs:
val = getattr(ori, k)
if val is not None:
kwargs[k] = val
if 'lower_bounds' not in kwargs and getattr(ori, 'lower_bounds') is not None:
kwargs['lower_bounds'] = ori.lower_bounds
if 'upper_bounds' not in kwargs and getattr(ori, 'upper_bounds') is not None:
kwargs['upper_bounds'] = ori.upper_bounds
if len(ori.pre_processors) > 0:
if 'pre_processors' not in kwargs:
kwargs['pre_processors'] = []
kwargs['pre_processors'] = kwargs['pre_processors'] + ori.pre_processors
if len(ori.post_processors) > 0:
if 'post_processors' not in kwargs:
kwargs['post_processors'] = []
kwargs['post_processors'] = ori.post_processors + kwargs['post_processors']
if 'dep_exprs' not in kwargs:
kwargs['dep_exprs'] = zip(ori.dep, ori.exprs)
if 'indep' not in kwargs:
kwargs['indep'] = ori.indep
instance = cls(**kwargs)
for attr in ori._attrs_to_copy:
if attr not in cls._attrs_to_copy:
setattr(instance, attr, getattr(ori, attr))
return instance |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:from_linear_invariants; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:cls; 5, identifier:ori_sys; 6, default_parameter; 6, 7; 6, 8; 7, identifier:preferred; 8, None; 9, dictionary_splat_pattern; 9, 10; 10, identifier:kwargs; 11, block; 11, 12; 11, 18; 11, 29; 11, 39; 11, 56; 11, 87; 11, 117; 11, 152; 11, 156; 11, 220; 11, 299; 11, 307; 11, 359; 11, 385; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:_be; 15, attribute; 15, 16; 15, 17; 16, identifier:ori_sys; 17, identifier:be; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:A; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:_be; 24, identifier:Matrix; 25, argument_list; 25, 26; 26, attribute; 26, 27; 26, 28; 27, identifier:ori_sys; 28, identifier:linear_invariants; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 34; 31, pattern_list; 31, 32; 31, 33; 32, identifier:rA; 33, identifier:pivots; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:A; 37, identifier:rref; 38, argument_list; 39, if_statement; 39, 40; 39, 50; 40, comparison_operator:<; 40, 41; 40, 45; 41, call; 41, 42; 41, 43; 42, identifier:len; 43, argument_list; 43, 44; 44, identifier:pivots; 45, subscript; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:A; 48, identifier:shape; 49, integer:0; 50, block; 50, 51; 51, raise_statement; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:NotImplementedError; 54, argument_list; 54, 55; 55, string:"Linear invariants contain linear dependencies."; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:per_row_cols; 59, list_comprehension; 59, 60; 59, 79; 60, tuple; 60, 61; 60, 62; 61, identifier:ri; 62, list_comprehension; 62, 63; 62, 64; 62, 72; 63, identifier:ci; 64, for_in_clause; 64, 65; 64, 66; 65, identifier:ci; 66, call; 66, 67; 66, 68; 67, identifier:range; 68, argument_list; 68, 69; 69, attribute; 69, 70; 69, 71; 70, identifier:A; 71, identifier:cols; 72, if_clause; 72, 73; 73, comparison_operator:!=; 73, 74; 73, 78; 74, subscript; 74, 75; 74, 76; 74, 77; 75, identifier:A; 76, identifier:ri; 77, identifier:ci; 78, integer:0; 79, for_in_clause; 79, 80; 79, 81; 80, identifier:ri; 81, call; 81, 82; 81, 83; 82, identifier:range; 83, argument_list; 83, 84; 84, attribute; 84, 85; 84, 86; 85, identifier:A; 86, identifier:rows; 87, if_statement; 87, 88; 87, 91; 88, comparison_operator:is; 88, 89; 88, 90; 89, identifier:preferred; 90, None; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:preferred; 95, conditional_expression:if; 95, 96; 95, 105; 95, 108; 96, subscript; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:ori_sys; 99, identifier:names; 100, slice; 100, 101; 100, 102; 101, colon; 102, attribute; 102, 103; 102, 104; 103, identifier:A; 104, identifier:rows; 105, attribute; 105, 106; 105, 107; 106, identifier:ori_sys; 107, identifier:dep_by_name; 108, call; 108, 109; 108, 110; 109, identifier:list; 110, argument_list; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:range; 113, argument_list; 113, 114; 114, attribute; 114, 115; 114, 116; 115, identifier:A; 116, identifier:rows; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:targets; 120, list_comprehension; 120, 121; 120, 149; 121, conditional_expression:if; 121, 122; 121, 130; 121, 133; 122, call; 122, 123; 122, 128; 123, attribute; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:ori_sys; 126, identifier:names; 127, identifier:index; 128, argument_list; 128, 129; 129, identifier:dep; 130, attribute; 130, 131; 130, 132; 131, identifier:ori_sys; 132, identifier:dep_by_name; 133, parenthesized_expression; 133, 134; 134, conditional_expression:if; 134, 135; 134, 136; 134, 141; 135, identifier:dep; 136, call; 136, 137; 136, 138; 137, identifier:isinstance; 138, argument_list; 138, 139; 138, 140; 139, identifier:dep; 140, identifier:int; 141, call; 141, 142; 141, 147; 142, attribute; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:ori_sys; 145, identifier:dep; 146, identifier:index; 147, argument_list; 147, 148; 148, identifier:dep; 149, for_in_clause; 149, 150; 149, 151; 150, identifier:dep; 151, identifier:preferred; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:row_tgt; 155, list:[]; 156, for_statement; 156, 157; 156, 160; 156, 175; 156, 211; 157, pattern_list; 157, 158; 157, 159; 158, identifier:ri; 159, identifier:colids; 160, call; 160, 161; 160, 162; 161, identifier:sorted; 162, argument_list; 162, 163; 162, 164; 163, identifier:per_row_cols; 164, keyword_argument; 164, 165; 164, 166; 165, identifier:key; 166, lambda; 166, 167; 166, 169; 167, lambda_parameters; 167, 168; 168, identifier:k; 169, call; 169, 170; 169, 171; 170, identifier:len; 171, argument_list; 171, 172; 172, subscript; 172, 173; 172, 174; 173, identifier:k; 174, integer:1; 175, block; 175, 176; 175, 202; 176, for_statement; 176, 177; 176, 178; 176, 179; 177, identifier:tgt; 178, identifier:targets; 179, block; 179, 180; 180, if_statement; 180, 181; 180, 184; 181, comparison_operator:in; 181, 182; 181, 183; 182, identifier:tgt; 183, identifier:colids; 184, block; 184, 185; 184, 194; 184, 201; 185, expression_statement; 185, 186; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:row_tgt; 189, identifier:append; 190, argument_list; 190, 191; 191, tuple; 191, 192; 191, 193; 192, identifier:ri; 193, identifier:tgt; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:targets; 198, identifier:remove; 199, argument_list; 199, 200; 200, identifier:tgt; 201, break_statement; 202, if_statement; 202, 203; 202, 209; 203, comparison_operator:==; 203, 204; 203, 208; 204, call; 204, 205; 204, 206; 205, identifier:len; 206, argument_list; 206, 207; 207, identifier:targets; 208, integer:0; 209, block; 209, 210; 210, break_statement; 211, else_clause; 211, 212; 212, block; 212, 213; 213, raise_statement; 213, 214; 214, call; 214, 215; 214, 216; 215, identifier:ValueError; 216, argument_list; 216, 217; 217, binary_operator:%; 217, 218; 217, 219; 218, string:"Could not find a solutions for: %s"; 219, identifier:targets; 220, function_definition; 220, 221; 220, 222; 220, 227; 221, function_name:analytic_factory; 222, parameters; 222, 223; 222, 224; 222, 225; 222, 226; 223, identifier:x0; 224, identifier:y0; 225, identifier:p0; 226, identifier:be; 227, block; 227, 228; 228, return_statement; 228, 229; 229, dictionary_comprehension; 229, 230; 229, 294; 230, pair; 230, 231; 230, 236; 231, subscript; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:ori_sys; 234, identifier:dep; 235, identifier:tgt; 236, binary_operator:-; 236, 237; 236, 249; 237, subscript; 237, 238; 237, 239; 238, identifier:y0; 239, conditional_expression:if; 239, 240; 239, 245; 239, 248; 240, subscript; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:ori_sys; 243, identifier:dep; 244, identifier:tgt; 245, attribute; 245, 246; 245, 247; 246, identifier:ori_sys; 247, identifier:dep_by_name; 248, identifier:tgt; 249, binary_operator:/; 249, 250; 249, 290; 250, call; 250, 251; 250, 252; 251, identifier:sum; 252, argument_list; 252, 253; 253, list_comprehension; 253, 254; 253, 278; 253, 286; 254, binary_operator:*; 254, 255; 254, 259; 255, subscript; 255, 256; 255, 257; 255, 258; 256, identifier:A; 257, identifier:ri; 258, identifier:ci; 259, parenthesized_expression; 259, 260; 260, binary_operator:-; 260, 261; 260, 266; 261, subscript; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:ori_sys; 264, identifier:dep; 265, identifier:ci; 266, subscript; 266, 267; 266, 268; 267, identifier:y0; 268, conditional_expression:if; 268, 269; 268, 274; 268, 277; 269, subscript; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:ori_sys; 272, identifier:dep; 273, identifier:ci; 274, attribute; 274, 275; 274, 276; 275, identifier:ori_sys; 276, identifier:dep_by_name; 277, identifier:ci; 278, for_in_clause; 278, 279; 278, 280; 279, identifier:ci; 280, call; 280, 281; 280, 282; 281, identifier:range; 282, argument_list; 282, 283; 283, attribute; 283, 284; 283, 285; 284, identifier:A; 285, identifier:cols; 286, if_clause; 286, 287; 287, comparison_operator:!=; 287, 288; 287, 289; 288, identifier:ci; 289, identifier:tgt; 290, subscript; 290, 291; 290, 292; 290, 293; 291, identifier:A; 292, identifier:ri; 293, identifier:tgt; 294, for_in_clause; 294, 295; 294, 298; 295, pattern_list; 295, 296; 295, 297; 296, identifier:ri; 297, identifier:tgt; 298, identifier:row_tgt; 299, expression_statement; 299, 300; 300, assignment; 300, 301; 300, 302; 301, identifier:ori_li_nms; 302, boolean_operator:or; 302, 303; 302, 306; 303, attribute; 303, 304; 303, 305; 304, identifier:ori_sys; 305, identifier:linear_invariant_names; 306, tuple; 307, expression_statement; 307, 308; 308, assignment; 308, 309; 308, 310; 309, identifier:new_lin_invar; 310, list_comprehension; 310, 311; 310, 334; 310, 346; 311, list_comprehension; 311, 312; 311, 313; 311, 321; 312, identifier:cell; 313, for_in_clause; 313, 314; 313, 317; 314, pattern_list; 314, 315; 314, 316; 315, identifier:ci; 316, identifier:cell; 317, call; 317, 318; 317, 319; 318, identifier:enumerate; 319, argument_list; 319, 320; 320, identifier:row; 321, if_clause; 321, 322; 322, comparison_operator:not; 322, 323; 322, 324; 323, identifier:ci; 324, subscript; 324, 325; 324, 333; 325, call; 325, 326; 325, 327; 326, identifier:list; 327, argument_list; 327, 328; 328, call; 328, 329; 328, 330; 329, identifier:zip; 330, argument_list; 330, 331; 331, list_splat; 331, 332; 332, identifier:row_tgt; 333, integer:1; 334, for_in_clause; 334, 335; 334, 338; 335, pattern_list; 335, 336; 335, 337; 336, identifier:ri; 337, identifier:row; 338, call; 338, 339; 338, 340; 339, identifier:enumerate; 340, argument_list; 340, 341; 341, call; 341, 342; 341, 345; 342, attribute; 342, 343; 342, 344; 343, identifier:A; 344, identifier:tolist; 345, argument_list; 346, if_clause; 346, 347; 347, comparison_operator:not; 347, 348; 347, 349; 348, identifier:ri; 349, subscript; 349, 350; 349, 358; 350, call; 350, 351; 350, 352; 351, identifier:list; 352, argument_list; 352, 353; 353, call; 353, 354; 353, 355; 354, identifier:zip; 355, argument_list; 355, 356; 356, list_splat; 356, 357; 357, identifier:row_tgt; 358, integer:0; 359, expression_statement; 359, 360; 360, assignment; 360, 361; 360, 362; 361, identifier:new_lin_i_nms; 362, list_comprehension; 362, 363; 362, 364; 362, 372; 363, identifier:nam; 364, for_in_clause; 364, 365; 364, 368; 365, pattern_list; 365, 366; 365, 367; 366, identifier:ri; 367, identifier:nam; 368, call; 368, 369; 368, 370; 369, identifier:enumerate; 370, argument_list; 370, 371; 371, identifier:ori_li_nms; 372, if_clause; 372, 373; 373, comparison_operator:not; 373, 374; 373, 375; 374, identifier:ri; 375, subscript; 375, 376; 375, 384; 376, call; 376, 377; 376, 378; 377, identifier:list; 378, argument_list; 378, 379; 379, call; 379, 380; 379, 381; 380, identifier:zip; 381, argument_list; 381, 382; 382, list_splat; 382, 383; 383, identifier:row_tgt; 384, integer:0; 385, return_statement; 385, 386; 386, call; 386, 387; 386, 388; 387, identifier:cls; 388, argument_list; 388, 389; 388, 390; 388, 391; 388, 394; 388, 397; 389, identifier:ori_sys; 390, identifier:analytic_factory; 391, keyword_argument; 391, 392; 391, 393; 392, identifier:linear_invariants; 393, identifier:new_lin_invar; 394, keyword_argument; 394, 395; 394, 396; 395, identifier:linear_invariant_names; 396, identifier:new_lin_i_nms; 397, dictionary_splat; 397, 398; 398, identifier:kwargs | def from_linear_invariants(cls, ori_sys, preferred=None, **kwargs):
_be = ori_sys.be
A = _be.Matrix(ori_sys.linear_invariants)
rA, pivots = A.rref()
if len(pivots) < A.shape[0]:
raise NotImplementedError("Linear invariants contain linear dependencies.")
per_row_cols = [(ri, [ci for ci in range(A.cols) if A[ri, ci] != 0]) for ri in range(A.rows)]
if preferred is None:
preferred = ori_sys.names[:A.rows] if ori_sys.dep_by_name else list(range(A.rows))
targets = [
ori_sys.names.index(dep) if ori_sys.dep_by_name else (
dep if isinstance(dep, int) else ori_sys.dep.index(dep))
for dep in preferred]
row_tgt = []
for ri, colids in sorted(per_row_cols, key=lambda k: len(k[1])):
for tgt in targets:
if tgt in colids:
row_tgt.append((ri, tgt))
targets.remove(tgt)
break
if len(targets) == 0:
break
else:
raise ValueError("Could not find a solutions for: %s" % targets)
def analytic_factory(x0, y0, p0, be):
return {
ori_sys.dep[tgt]: y0[ori_sys.dep[tgt] if ori_sys.dep_by_name else tgt] - sum(
[A[ri, ci]*(ori_sys.dep[ci] - y0[ori_sys.dep[ci] if ori_sys.dep_by_name else ci]) for
ci in range(A.cols) if ci != tgt])/A[ri, tgt] for ri, tgt in row_tgt
}
ori_li_nms = ori_sys.linear_invariant_names or ()
new_lin_invar = [[cell for ci, cell in enumerate(row) if ci not in list(zip(*row_tgt))[1]]
for ri, row in enumerate(A.tolist()) if ri not in list(zip(*row_tgt))[0]]
new_lin_i_nms = [nam for ri, nam in enumerate(ori_li_nms) if ri not in list(zip(*row_tgt))[0]]
return cls(ori_sys, analytic_factory, linear_invariants=new_lin_invar,
linear_invariant_names=new_lin_i_nms, **kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:chained_parameter_variation; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:subject; 5, identifier:durations; 6, identifier:y0; 7, identifier:varied_params; 8, default_parameter; 8, 9; 8, 10; 9, identifier:default_params; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:integrate_kwargs; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:x0; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:npoints; 19, integer:1; 20, default_parameter; 20, 21; 20, 22; 21, identifier:numpy; 22, None; 23, block; 23, 24; 23, 32; 23, 37; 23, 63; 23, 96; 23, 102; 23, 108; 23, 160; 23, 169; 23, 300; 24, assert_statement; 24, 25; 24, 31; 25, comparison_operator:>; 25, 26; 25, 30; 26, call; 26, 27; 26, 28; 27, identifier:len; 28, argument_list; 28, 29; 29, identifier:durations; 30, integer:0; 31, string:'need at least 1 duration (preferably many)'; 32, assert_statement; 32, 33; 32, 36; 33, comparison_operator:>; 33, 34; 33, 35; 34, identifier:npoints; 35, integer:0; 36, string:'need at least 1 point per duration'; 37, for_statement; 37, 38; 37, 41; 37, 46; 38, pattern_list; 38, 39; 38, 40; 39, identifier:k; 40, identifier:v; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:varied_params; 44, identifier:items; 45, argument_list; 46, block; 46, 47; 47, if_statement; 47, 48; 47, 57; 48, comparison_operator:!=; 48, 49; 48, 53; 49, call; 49, 50; 49, 51; 50, identifier:len; 51, argument_list; 51, 52; 52, identifier:v; 53, call; 53, 54; 53, 55; 54, identifier:len; 55, argument_list; 55, 56; 56, identifier:durations; 57, block; 57, 58; 58, raise_statement; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:ValueError; 61, argument_list; 61, 62; 62, string:"Mismathced lengths of durations and varied_params"; 63, if_statement; 63, 64; 63, 69; 63, 84; 64, call; 64, 65; 64, 66; 65, identifier:isinstance; 66, argument_list; 66, 67; 66, 68; 67, identifier:subject; 68, identifier:ODESys; 69, block; 69, 70; 69, 76; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:integrate; 73, attribute; 73, 74; 73, 75; 74, identifier:subject; 75, identifier:integrate; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:numpy; 79, boolean_operator:or; 79, 80; 79, 81; 80, identifier:numpy; 81, attribute; 81, 82; 81, 83; 82, identifier:subject; 83, identifier:numpy; 84, else_clause; 84, 85; 85, block; 85, 86; 85, 90; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:integrate; 89, identifier:subject; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:numpy; 93, boolean_operator:or; 93, 94; 93, 95; 94, identifier:numpy; 95, identifier:np; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:default_params; 99, boolean_operator:or; 99, 100; 99, 101; 100, identifier:default_params; 101, dictionary; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:integrate_kwargs; 105, boolean_operator:or; 105, 106; 105, 107; 106, identifier:integrate_kwargs; 107, dictionary; 108, function_definition; 108, 109; 108, 110; 108, 113; 109, function_name:_get_idx; 110, parameters; 110, 111; 110, 112; 111, identifier:cont; 112, identifier:idx; 113, block; 113, 114; 114, if_statement; 114, 115; 114, 120; 114, 154; 115, call; 115, 116; 115, 117; 116, identifier:isinstance; 117, argument_list; 117, 118; 117, 119; 118, identifier:cont; 119, identifier:dict; 120, block; 120, 121; 121, return_statement; 121, 122; 122, dictionary_comprehension; 122, 123; 122, 145; 123, pair; 123, 124; 123, 125; 124, identifier:k; 125, parenthesized_expression; 125, 126; 126, conditional_expression:if; 126, 127; 126, 130; 126, 144; 127, subscript; 127, 128; 127, 129; 128, identifier:v; 129, identifier:idx; 130, boolean_operator:and; 130, 131; 130, 136; 131, call; 131, 132; 131, 133; 132, identifier:hasattr; 133, argument_list; 133, 134; 133, 135; 134, identifier:v; 135, string:'__len__'; 136, comparison_operator:>; 136, 137; 136, 143; 137, call; 137, 138; 137, 139; 138, identifier:getattr; 139, argument_list; 139, 140; 139, 141; 139, 142; 140, identifier:v; 141, string:'ndim'; 142, integer:1; 143, integer:0; 144, identifier:v; 145, for_in_clause; 145, 146; 145, 149; 146, pattern_list; 146, 147; 146, 148; 147, identifier:k; 148, identifier:v; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:cont; 152, identifier:items; 153, argument_list; 154, else_clause; 154, 155; 155, block; 155, 156; 156, return_statement; 156, 157; 157, subscript; 157, 158; 157, 159; 158, identifier:cont; 159, identifier:idx; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:durations; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:numpy; 166, identifier:cumsum; 167, argument_list; 167, 168; 168, identifier:durations; 169, for_statement; 169, 170; 169, 171; 169, 178; 170, identifier:idx_dur; 171, call; 171, 172; 171, 173; 172, identifier:range; 173, argument_list; 173, 174; 174, call; 174, 175; 174, 176; 175, identifier:len; 176, argument_list; 176, 177; 177, identifier:durations; 178, block; 178, 179; 178, 188; 178, 206; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:params; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:copy; 185, identifier:copy; 186, argument_list; 186, 187; 187, identifier:default_params; 188, for_statement; 188, 189; 188, 192; 188, 197; 189, pattern_list; 189, 190; 189, 191; 190, identifier:k; 191, identifier:v; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:varied_params; 195, identifier:items; 196, argument_list; 197, block; 197, 198; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 203; 200, subscript; 200, 201; 200, 202; 201, identifier:params; 202, identifier:k; 203, subscript; 203, 204; 203, 205; 204, identifier:v; 205, identifier:idx_dur; 206, if_statement; 206, 207; 206, 210; 206, 246; 207, comparison_operator:==; 207, 208; 207, 209; 208, identifier:idx_dur; 209, integer:0; 210, block; 210, 211; 210, 224; 211, if_statement; 211, 212; 211, 215; 212, comparison_operator:is; 212, 213; 212, 214; 213, identifier:x0; 214, None; 215, block; 215, 216; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:x0; 219, binary_operator:*; 219, 220; 219, 223; 220, subscript; 220, 221; 220, 222; 221, identifier:durations; 222, integer:0; 223, integer:0; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:out; 227, call; 227, 228; 227, 229; 228, identifier:integrate; 229, argument_list; 229, 230; 229, 242; 229, 243; 229, 244; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:numpy; 233, identifier:linspace; 234, argument_list; 234, 235; 234, 236; 234, 239; 235, identifier:x0; 236, subscript; 236, 237; 236, 238; 237, identifier:durations; 238, integer:0; 239, binary_operator:+; 239, 240; 239, 241; 240, identifier:npoints; 241, integer:1; 242, identifier:y0; 243, identifier:params; 244, dictionary_splat; 244, 245; 245, identifier:integrate_kwargs; 246, else_clause; 246, 247; 247, block; 247, 248; 248, if_statement; 248, 249; 248, 254; 248, 270; 249, call; 249, 250; 249, 251; 250, identifier:isinstance; 251, argument_list; 251, 252; 251, 253; 252, identifier:out; 253, identifier:Result; 254, block; 254, 255; 255, expression_statement; 255, 256; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:out; 259, identifier:extend_by_integration; 260, argument_list; 260, 261; 260, 264; 260, 265; 260, 268; 261, subscript; 261, 262; 261, 263; 262, identifier:durations; 263, identifier:idx_dur; 264, identifier:params; 265, keyword_argument; 265, 266; 265, 267; 266, identifier:npoints; 267, identifier:npoints; 268, dictionary_splat; 268, 269; 269, identifier:integrate_kwargs; 270, else_clause; 270, 271; 271, block; 271, 272; 272, for_statement; 272, 273; 272, 276; 272, 280; 273, pattern_list; 273, 274; 273, 275; 274, identifier:idx_res; 275, identifier:r; 276, call; 276, 277; 276, 278; 277, identifier:enumerate; 278, argument_list; 278, 279; 279, identifier:out; 280, block; 280, 281; 281, expression_statement; 281, 282; 282, call; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:r; 285, identifier:extend_by_integration; 286, argument_list; 286, 287; 286, 290; 286, 295; 286, 298; 287, subscript; 287, 288; 287, 289; 288, identifier:durations; 289, identifier:idx_dur; 290, call; 290, 291; 290, 292; 291, identifier:_get_idx; 292, argument_list; 292, 293; 292, 294; 293, identifier:params; 294, identifier:idx_res; 295, keyword_argument; 295, 296; 295, 297; 296, identifier:npoints; 297, identifier:npoints; 298, dictionary_splat; 298, 299; 299, identifier:integrate_kwargs; 300, return_statement; 300, 301; 301, identifier:out | def chained_parameter_variation(subject, durations, y0, varied_params, default_params=None,
integrate_kwargs=None, x0=None, npoints=1, numpy=None):
assert len(durations) > 0, 'need at least 1 duration (preferably many)'
assert npoints > 0, 'need at least 1 point per duration'
for k, v in varied_params.items():
if len(v) != len(durations):
raise ValueError("Mismathced lengths of durations and varied_params")
if isinstance(subject, ODESys):
integrate = subject.integrate
numpy = numpy or subject.numpy
else:
integrate = subject
numpy = numpy or np
default_params = default_params or {}
integrate_kwargs = integrate_kwargs or {}
def _get_idx(cont, idx):
if isinstance(cont, dict):
return {k: (v[idx] if hasattr(v, '__len__') and getattr(v, 'ndim', 1) > 0 else v)
for k, v in cont.items()}
else:
return cont[idx]
durations = numpy.cumsum(durations)
for idx_dur in range(len(durations)):
params = copy.copy(default_params)
for k, v in varied_params.items():
params[k] = v[idx_dur]
if idx_dur == 0:
if x0 is None:
x0 = durations[0]*0
out = integrate(numpy.linspace(x0, durations[0], npoints + 1), y0, params, **integrate_kwargs)
else:
if isinstance(out, Result):
out.extend_by_integration(durations[idx_dur], params, npoints=npoints, **integrate_kwargs)
else:
for idx_res, r in enumerate(out):
r.extend_by_integration(durations[idx_dur], _get_idx(params, idx_res),
npoints=npoints, **integrate_kwargs)
return out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:integrate; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 4, identifier:self; 5, identifier:x; 6, identifier:y0; 7, default_parameter; 7, 8; 7, 9; 8, identifier:params; 9, tuple; 10, default_parameter; 10, 11; 10, 12; 11, identifier:atol; 12, float:1e-8; 13, default_parameter; 13, 14; 13, 15; 14, identifier:rtol; 15, float:1e-8; 16, dictionary_splat_pattern; 16, 17; 17, identifier:kwargs; 18, block; 18, 19; 18, 30; 18, 45; 18, 55; 18, 86; 18, 108; 18, 132; 18, 161; 18, 167; 18, 177; 18, 194; 18, 212; 18, 218; 18, 272; 18, 408; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:arrs; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:to_arrays; 26, argument_list; 26, 27; 26, 28; 26, 29; 27, identifier:x; 28, identifier:y0; 29, identifier:params; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 36; 32, pattern_list; 32, 33; 32, 34; 32, 35; 33, identifier:_x; 34, identifier:_y; 35, identifier:_p; 36, assignment; 36, 37; 36, 38; 37, identifier:_arrs; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:pre_process; 42, argument_list; 42, 43; 43, list_splat; 43, 44; 44, identifier:arrs; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:ndims; 48, list_comprehension; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:a; 51, identifier:ndim; 52, for_in_clause; 52, 53; 52, 54; 53, identifier:a; 54, identifier:_arrs; 55, if_statement; 55, 56; 55, 62; 55, 67; 55, 79; 56, comparison_operator:==; 56, 57; 56, 58; 57, identifier:ndims; 58, list:[1, 1, 1]; 58, 59; 58, 60; 58, 61; 59, integer:1; 60, integer:1; 61, integer:1; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:twodim; 66, False; 67, elif_clause; 67, 68; 67, 74; 68, comparison_operator:==; 68, 69; 68, 70; 69, identifier:ndims; 70, list:[2, 2, 2]; 70, 71; 70, 72; 70, 73; 71, integer:2; 72, integer:2; 73, integer:2; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:twodim; 78, True; 79, else_clause; 79, 80; 80, block; 80, 81; 81, raise_statement; 81, 82; 82, call; 82, 83; 82, 84; 83, identifier:ValueError; 84, argument_list; 84, 85; 85, string:"Pre-processor made ndims inconsistent?"; 86, if_statement; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:append_iv; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:_p; 94, call; 94, 95; 94, 100; 95, attribute; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:numpy; 99, identifier:concatenate; 100, argument_list; 100, 101; 100, 104; 101, tuple; 101, 102; 101, 103; 102, identifier:_p; 103, identifier:_y; 104, keyword_argument; 104, 105; 104, 106; 105, identifier:axis; 106, unary_operator:-; 106, 107; 107, integer:1; 108, if_statement; 108, 109; 108, 114; 109, call; 109, 110; 109, 111; 110, identifier:hasattr; 111, argument_list; 111, 112; 111, 113; 112, identifier:self; 113, string:'ny'; 114, block; 114, 115; 115, if_statement; 115, 116; 115, 126; 116, comparison_operator:!=; 116, 117; 116, 123; 117, subscript; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:_y; 120, identifier:shape; 121, unary_operator:-; 121, 122; 122, integer:1; 123, attribute; 123, 124; 123, 125; 124, identifier:self; 125, identifier:ny; 126, block; 126, 127; 127, raise_statement; 127, 128; 128, call; 128, 129; 128, 130; 129, identifier:ValueError; 130, argument_list; 130, 131; 131, string:"Incorrect shape of intern_y0"; 132, if_statement; 132, 133; 132, 138; 132, 153; 133, call; 133, 134; 133, 135; 134, identifier:isinstance; 135, argument_list; 135, 136; 135, 137; 136, identifier:atol; 137, identifier:dict; 138, block; 138, 139; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 144; 141, subscript; 141, 142; 141, 143; 142, identifier:kwargs; 143, string:'atol'; 144, list_comprehension; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:atol; 147, identifier:k; 148, for_in_clause; 148, 149; 148, 150; 149, identifier:k; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:names; 153, else_clause; 153, 154; 154, block; 154, 155; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 160; 157, subscript; 157, 158; 157, 159; 158, identifier:kwargs; 159, string:'atol'; 160, identifier:atol; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 166; 163, subscript; 163, 164; 163, 165; 164, identifier:kwargs; 165, string:'rtol'; 166, identifier:rtol; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:integrator; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:kwargs; 173, identifier:pop; 174, argument_list; 174, 175; 174, 176; 175, string:'integrator'; 176, None; 177, if_statement; 177, 178; 177, 181; 178, comparison_operator:is; 178, 179; 178, 180; 179, identifier:integrator; 180, None; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:integrator; 185, call; 185, 186; 185, 191; 186, attribute; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:os; 189, identifier:environ; 190, identifier:get; 191, argument_list; 191, 192; 191, 193; 192, string:'PYODESYS_INTEGRATOR'; 193, string:'scipy'; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:args; 197, call; 197, 198; 197, 199; 198, identifier:tuple; 199, argument_list; 199, 200; 200, call; 200, 201; 200, 202; 201, identifier:map; 202, argument_list; 202, 203; 202, 208; 203, attribute; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:self; 206, identifier:numpy; 207, identifier:atleast_2d; 208, tuple; 208, 209; 208, 210; 208, 211; 209, identifier:_x; 210, identifier:_y; 211, identifier:_p; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:self; 216, identifier:_current_integration_kwargs; 217, identifier:kwargs; 218, if_statement; 218, 219; 218, 224; 218, 241; 219, call; 219, 220; 219, 221; 220, identifier:isinstance; 221, argument_list; 221, 222; 221, 223; 222, identifier:integrator; 223, identifier:str; 224, block; 224, 225; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:nfo; 228, call; 228, 229; 228, 236; 229, call; 229, 230; 229, 231; 230, identifier:getattr; 231, argument_list; 231, 232; 231, 233; 232, identifier:self; 233, binary_operator:+; 233, 234; 233, 235; 234, string:'_integrate_'; 235, identifier:integrator; 236, argument_list; 236, 237; 236, 239; 237, list_splat; 237, 238; 238, identifier:args; 239, dictionary_splat; 239, 240; 240, identifier:kwargs; 241, else_clause; 241, 242; 242, block; 242, 243; 242, 254; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 248; 245, subscript; 245, 246; 245, 247; 246, identifier:kwargs; 247, string:'with_jacobian'; 248, call; 248, 249; 248, 250; 249, identifier:getattr; 250, argument_list; 250, 251; 250, 252; 250, 253; 251, identifier:integrator; 252, string:'with_jacobian'; 253, None; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:nfo; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:self; 260, identifier:_integrate; 261, argument_list; 261, 262; 261, 265; 261, 268; 261, 270; 262, attribute; 262, 263; 262, 264; 263, identifier:integrator; 264, identifier:integrate_adaptive; 265, attribute; 265, 266; 265, 267; 266, identifier:integrator; 267, identifier:integrate_predefined; 268, list_splat; 268, 269; 269, identifier:args; 270, dictionary_splat; 270, 271; 271, identifier:kwargs; 272, if_statement; 272, 273; 272, 274; 272, 343; 273, identifier:twodim; 274, block; 274, 275; 274, 285; 274, 295; 274, 305; 275, expression_statement; 275, 276; 276, assignment; 276, 277; 276, 278; 277, identifier:_xout; 278, list_comprehension; 278, 279; 278, 282; 279, subscript; 279, 280; 279, 281; 280, identifier:d; 281, string:'internal_xout'; 282, for_in_clause; 282, 283; 282, 284; 283, identifier:d; 284, identifier:nfo; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:_yout; 288, list_comprehension; 288, 289; 288, 292; 289, subscript; 289, 290; 289, 291; 290, identifier:d; 291, string:'internal_yout'; 292, for_in_clause; 292, 293; 292, 294; 293, identifier:d; 294, identifier:nfo; 295, expression_statement; 295, 296; 296, assignment; 296, 297; 296, 298; 297, identifier:_params; 298, list_comprehension; 298, 299; 298, 302; 299, subscript; 299, 300; 299, 301; 300, identifier:d; 301, string:'internal_params'; 302, for_in_clause; 302, 303; 302, 304; 303, identifier:d; 304, identifier:nfo; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 308; 307, identifier:res; 308, list_comprehension; 308, 309; 308, 334; 309, call; 309, 310; 309, 311; 310, identifier:Result; 311, argument_list; 311, 312; 312, list_splat; 312, 313; 313, parenthesized_expression; 313, 314; 314, binary_operator:+; 314, 315; 314, 329; 315, call; 315, 316; 315, 319; 316, attribute; 316, 317; 316, 318; 317, identifier:self; 318, identifier:post_process; 319, argument_list; 319, 320; 319, 323; 319, 326; 320, subscript; 320, 321; 320, 322; 321, identifier:_xout; 322, identifier:i; 323, subscript; 323, 324; 323, 325; 324, identifier:_yout; 325, identifier:i; 326, subscript; 326, 327; 326, 328; 327, identifier:_params; 328, identifier:i; 329, tuple; 329, 330; 329, 333; 330, subscript; 330, 331; 330, 332; 331, identifier:nfo; 332, identifier:i; 333, identifier:self; 334, for_in_clause; 334, 335; 334, 336; 335, identifier:i; 336, call; 336, 337; 336, 338; 337, identifier:range; 338, argument_list; 338, 339; 339, call; 339, 340; 339, 341; 340, identifier:len; 341, argument_list; 341, 342; 342, identifier:nfo; 343, else_clause; 343, 344; 344, block; 344, 345; 344, 353; 344, 361; 344, 382; 344, 388; 345, expression_statement; 345, 346; 346, assignment; 346, 347; 346, 348; 347, identifier:_xout; 348, subscript; 348, 349; 348, 352; 349, subscript; 349, 350; 349, 351; 350, identifier:nfo; 351, integer:0; 352, string:'internal_xout'; 353, expression_statement; 353, 354; 354, assignment; 354, 355; 354, 356; 355, identifier:_yout; 356, subscript; 356, 357; 356, 360; 357, subscript; 357, 358; 357, 359; 358, identifier:nfo; 359, integer:0; 360, string:'internal_yout'; 361, expression_statement; 361, 362; 362, assignment; 362, 363; 362, 366; 363, attribute; 363, 364; 363, 365; 364, identifier:self; 365, identifier:_internal; 366, expression_list; 366, 367; 366, 372; 366, 377; 367, call; 367, 368; 367, 371; 368, attribute; 368, 369; 368, 370; 369, identifier:_xout; 370, identifier:copy; 371, argument_list; 372, call; 372, 373; 372, 376; 373, attribute; 373, 374; 373, 375; 374, identifier:_yout; 375, identifier:copy; 376, argument_list; 377, call; 377, 378; 377, 381; 378, attribute; 378, 379; 378, 380; 379, identifier:_p; 380, identifier:copy; 381, argument_list; 382, expression_statement; 382, 383; 383, assignment; 383, 384; 383, 385; 384, identifier:nfo; 385, subscript; 385, 386; 385, 387; 386, identifier:nfo; 387, integer:0; 388, expression_statement; 388, 389; 389, assignment; 389, 390; 389, 391; 390, identifier:res; 391, call; 391, 392; 391, 393; 392, identifier:Result; 393, argument_list; 393, 394; 394, list_splat; 394, 395; 395, parenthesized_expression; 395, 396; 396, binary_operator:+; 396, 397; 396, 405; 397, call; 397, 398; 397, 401; 398, attribute; 398, 399; 398, 400; 399, identifier:self; 400, identifier:post_process; 401, argument_list; 401, 402; 401, 403; 401, 404; 402, identifier:_xout; 403, identifier:_yout; 404, identifier:_p; 405, tuple; 405, 406; 405, 407; 406, identifier:nfo; 407, identifier:self; 408, return_statement; 408, 409; 409, identifier:res | def integrate(self, x, y0, params=(), atol=1e-8, rtol=1e-8, **kwargs):
arrs = self.to_arrays(x, y0, params)
_x, _y, _p = _arrs = self.pre_process(*arrs)
ndims = [a.ndim for a in _arrs]
if ndims == [1, 1, 1]:
twodim = False
elif ndims == [2, 2, 2]:
twodim = True
else:
raise ValueError("Pre-processor made ndims inconsistent?")
if self.append_iv:
_p = self.numpy.concatenate((_p, _y), axis=-1)
if hasattr(self, 'ny'):
if _y.shape[-1] != self.ny:
raise ValueError("Incorrect shape of intern_y0")
if isinstance(atol, dict):
kwargs['atol'] = [atol[k] for k in self.names]
else:
kwargs['atol'] = atol
kwargs['rtol'] = rtol
integrator = kwargs.pop('integrator', None)
if integrator is None:
integrator = os.environ.get('PYODESYS_INTEGRATOR', 'scipy')
args = tuple(map(self.numpy.atleast_2d, (_x, _y, _p)))
self._current_integration_kwargs = kwargs
if isinstance(integrator, str):
nfo = getattr(self, '_integrate_' + integrator)(*args, **kwargs)
else:
kwargs['with_jacobian'] = getattr(integrator, 'with_jacobian', None)
nfo = self._integrate(integrator.integrate_adaptive,
integrator.integrate_predefined,
*args, **kwargs)
if twodim:
_xout = [d['internal_xout'] for d in nfo]
_yout = [d['internal_yout'] for d in nfo]
_params = [d['internal_params'] for d in nfo]
res = [Result(*(self.post_process(_xout[i], _yout[i], _params[i]) + (nfo[i], self)))
for i in range(len(nfo))]
else:
_xout = nfo[0]['internal_xout']
_yout = nfo[0]['internal_yout']
self._internal = _xout.copy(), _yout.copy(), _p.copy()
nfo = nfo[0]
res = Result(*(self.post_process(_xout, _yout, _p) + (nfo, self)))
return res |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sort_data; 3, parameters; 3, 4; 3, 5; 4, identifier:data; 5, identifier:cols; 6, block; 6, 7; 7, return_statement; 7, 8; 8, call; 8, 9; 8, 22; 9, attribute; 9, 10; 9, 21; 10, subscript; 10, 11; 10, 17; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:data; 14, identifier:sort_values; 15, argument_list; 15, 16; 16, identifier:cols; 17, binary_operator:+; 17, 18; 17, 19; 18, identifier:cols; 19, list:['value']; 19, 20; 20, string:'value'; 21, identifier:reset_index; 22, argument_list; 22, 23; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:drop; 25, True | def sort_data(data, cols):
return data.sort_values(cols)[cols + ['value']].reset_index(drop=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:filter_by_meta; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:data; 5, identifier:df; 6, default_parameter; 6, 7; 6, 8; 7, identifier:join_meta; 8, False; 9, dictionary_splat_pattern; 9, 10; 10, identifier:kwargs; 11, block; 11, 12; 11, 40; 11, 68; 11, 83; 11, 87; 11, 158; 11, 164; 11, 172; 11, 194; 11, 207; 11, 224; 11, 232; 11, 245; 11, 253; 11, 265; 11, 280; 11, 293; 12, if_statement; 12, 13; 12, 34; 13, not_operator; 13, 14; 14, call; 14, 15; 14, 21; 15, attribute; 15, 16; 15, 20; 16, call; 16, 17; 16, 18; 17, identifier:set; 18, argument_list; 18, 19; 19, identifier:META_IDX; 20, identifier:issubset; 21, argument_list; 21, 22; 22, binary_operator:+; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:data; 26, identifier:index; 27, identifier:names; 28, call; 28, 29; 28, 30; 29, identifier:list; 30, argument_list; 30, 31; 31, attribute; 31, 32; 31, 33; 32, identifier:data; 33, identifier:columns; 34, block; 34, 35; 35, raise_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:ValueError; 38, argument_list; 38, 39; 39, string:'missing required index dimensions or columns!'; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:meta; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:pd; 46, identifier:DataFrame; 47, argument_list; 47, 48; 48, call; 48, 49; 48, 67; 49, attribute; 49, 50; 49, 66; 50, subscript; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:df; 53, identifier:meta; 54, call; 54, 55; 54, 56; 55, identifier:list; 56, argument_list; 56, 57; 57, binary_operator:-; 57, 58; 57, 62; 58, call; 58, 59; 58, 60; 59, identifier:set; 60, argument_list; 60, 61; 61, identifier:kwargs; 62, call; 62, 63; 62, 64; 63, identifier:set; 64, argument_list; 64, 65; 65, identifier:META_IDX; 66, identifier:copy; 67, argument_list; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:keep; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:np; 74, identifier:array; 75, argument_list; 75, 76; 76, binary_operator:*; 76, 77; 76, 79; 77, list:[True]; 77, 78; 78, True; 79, call; 79, 80; 79, 81; 80, identifier:len; 81, argument_list; 81, 82; 82, identifier:meta; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:apply_filter; 86, False; 87, for_statement; 87, 88; 87, 91; 87, 96; 88, pattern_list; 88, 89; 88, 90; 89, identifier:col; 90, identifier:values; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:kwargs; 94, identifier:items; 95, argument_list; 96, block; 96, 97; 96, 152; 97, if_statement; 97, 98; 97, 105; 97, 137; 98, boolean_operator:and; 98, 99; 98, 102; 99, comparison_operator:in; 99, 100; 99, 101; 100, identifier:col; 101, identifier:META_IDX; 102, comparison_operator:is; 102, 103; 102, 104; 103, identifier:values; 104, None; 105, block; 105, 106; 105, 122; 105, 133; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:_col; 109, call; 109, 110; 109, 115; 110, attribute; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:meta; 113, identifier:index; 114, identifier:get_level_values; 115, argument_list; 115, 116; 116, conditional_expression:if; 116, 117; 116, 118; 116, 121; 117, integer:0; 118, comparison_operator:is; 118, 119; 118, 120; 119, identifier:col; 120, string:'model'; 121, integer:1; 122, expression_statement; 122, 123; 123, augmented_assignment:&=; 123, 124; 123, 125; 124, identifier:keep; 125, call; 125, 126; 125, 127; 126, identifier:pattern_match; 127, argument_list; 127, 128; 127, 129; 127, 130; 128, identifier:_col; 129, identifier:values; 130, keyword_argument; 130, 131; 130, 132; 131, identifier:has_nan; 132, False; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:apply_filter; 136, True; 137, elif_clause; 137, 138; 137, 141; 138, comparison_operator:is; 138, 139; 138, 140; 139, identifier:values; 140, None; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, augmented_assignment:&=; 143, 144; 143, 145; 144, identifier:keep; 145, call; 145, 146; 145, 147; 146, identifier:pattern_match; 147, argument_list; 147, 148; 147, 151; 148, subscript; 148, 149; 148, 150; 149, identifier:meta; 150, identifier:col; 151, identifier:values; 152, expression_statement; 152, 153; 153, augmented_assignment:|=; 153, 154; 153, 155; 154, identifier:apply_filter; 155, comparison_operator:is; 155, 156; 155, 157; 156, identifier:values; 157, None; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:meta; 161, subscript; 161, 162; 161, 163; 162, identifier:meta; 163, identifier:keep; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:data; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:data; 170, identifier:copy; 171, argument_list; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:idx; 175, conditional_expression:if; 175, 176; 175, 184; 175, 193; 176, call; 176, 177; 176, 178; 177, identifier:list; 178, argument_list; 178, 179; 179, attribute; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:data; 182, identifier:index; 183, identifier:names; 184, not_operator; 184, 185; 185, comparison_operator:==; 185, 186; 185, 191; 186, attribute; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:data; 189, identifier:index; 190, identifier:names; 191, list:[None]; 191, 192; 192, None; 193, None; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:data; 197, call; 197, 198; 197, 205; 198, attribute; 198, 199; 198, 204; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:data; 202, identifier:reset_index; 203, argument_list; 204, identifier:set_index; 205, argument_list; 205, 206; 206, identifier:META_IDX; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:meta; 210, subscript; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:meta; 213, identifier:loc; 214, call; 214, 215; 214, 220; 215, attribute; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:meta; 218, identifier:index; 219, identifier:intersection; 220, argument_list; 220, 221; 221, attribute; 221, 222; 221, 223; 222, identifier:data; 223, identifier:index; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 231; 226, attribute; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:meta; 229, identifier:index; 230, identifier:names; 231, identifier:META_IDX; 232, if_statement; 232, 233; 232, 234; 233, identifier:apply_filter; 234, block; 234, 235; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:data; 238, subscript; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:data; 241, identifier:loc; 242, attribute; 242, 243; 242, 244; 243, identifier:meta; 244, identifier:index; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 252; 247, attribute; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:data; 250, identifier:index; 251, identifier:names; 252, identifier:META_IDX; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:data; 256, conditional_expression:if; 256, 257; 256, 263; 256, 264; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:data; 260, identifier:join; 261, argument_list; 261, 262; 262, identifier:meta; 263, identifier:join_meta; 264, identifier:data; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 268; 267, identifier:data; 268, call; 268, 269; 268, 276; 269, attribute; 269, 270; 269, 275; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:data; 273, identifier:reset_index; 274, argument_list; 275, identifier:set_index; 276, argument_list; 276, 277; 277, boolean_operator:or; 277, 278; 277, 279; 278, identifier:idx; 279, string:'index'; 280, if_statement; 280, 281; 280, 284; 281, comparison_operator:is; 281, 282; 281, 283; 282, identifier:idx; 283, None; 284, block; 284, 285; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 292; 287, attribute; 287, 288; 287, 291; 288, attribute; 288, 289; 288, 290; 289, identifier:data; 290, identifier:index; 291, identifier:name; 292, None; 293, return_statement; 293, 294; 294, identifier:data | def filter_by_meta(data, df, join_meta=False, **kwargs):
if not set(META_IDX).issubset(data.index.names + list(data.columns)):
raise ValueError('missing required index dimensions or columns!')
meta = pd.DataFrame(df.meta[list(set(kwargs) - set(META_IDX))].copy())
keep = np.array([True] * len(meta))
apply_filter = False
for col, values in kwargs.items():
if col in META_IDX and values is not None:
_col = meta.index.get_level_values(0 if col is 'model' else 1)
keep &= pattern_match(_col, values, has_nan=False)
apply_filter = True
elif values is not None:
keep &= pattern_match(meta[col], values)
apply_filter |= values is not None
meta = meta[keep]
data = data.copy()
idx = list(data.index.names) if not data.index.names == [None] else None
data = data.reset_index().set_index(META_IDX)
meta = meta.loc[meta.index.intersection(data.index)]
meta.index.names = META_IDX
if apply_filter:
data = data.loc[meta.index]
data.index.names = META_IDX
data = data.join(meta) if join_meta else data
data = data.reset_index().set_index(idx or 'index')
if idx is None:
data.index.name = None
return data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:append; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:other; 6, default_parameter; 6, 7; 6, 8; 7, identifier:ignore_meta_conflict; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:inplace; 11, False; 12, dictionary_splat_pattern; 12, 13; 13, identifier:kwargs; 14, block; 14, 15; 14, 36; 14, 50; 14, 63; 14, 80; 14, 97; 14, 266; 14, 322; 14, 352; 14, 370; 14, 385; 14, 401; 15, if_statement; 15, 16; 15, 22; 16, not_operator; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:isinstance; 19, argument_list; 19, 20; 19, 21; 20, identifier:other; 21, identifier:IamDataFrame; 22, block; 22, 23; 22, 32; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:other; 26, call; 26, 27; 26, 28; 27, identifier:IamDataFrame; 28, argument_list; 28, 29; 28, 30; 29, identifier:other; 30, dictionary_splat; 30, 31; 31, identifier:kwargs; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:ignore_meta_conflict; 35, True; 36, if_statement; 36, 37; 36, 44; 37, comparison_operator:is; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:time_col; 41, attribute; 41, 42; 41, 43; 42, identifier:other; 43, identifier:time_col; 44, block; 44, 45; 45, raise_statement; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:ValueError; 48, argument_list; 48, 49; 49, string:'incompatible time format (years vs. datetime)!'; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:ret; 53, conditional_expression:if; 53, 54; 53, 60; 53, 62; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:copy; 57, identifier:deepcopy; 58, argument_list; 58, 59; 59, identifier:self; 60, not_operator; 60, 61; 61, identifier:inplace; 62, identifier:self; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:diff; 66, call; 66, 67; 66, 74; 67, attribute; 67, 68; 67, 73; 68, attribute; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:other; 71, identifier:meta; 72, identifier:index; 73, identifier:difference; 74, argument_list; 74, 75; 75, attribute; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:ret; 78, identifier:meta; 79, identifier:index; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:intersect; 83, call; 83, 84; 83, 91; 84, attribute; 84, 85; 84, 90; 85, attribute; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:other; 88, identifier:meta; 89, identifier:index; 90, identifier:intersection; 91, argument_list; 91, 92; 92, attribute; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:ret; 95, identifier:meta; 96, identifier:index; 97, if_statement; 97, 98; 97, 102; 98, not_operator; 98, 99; 99, attribute; 99, 100; 99, 101; 100, identifier:intersect; 101, identifier:empty; 102, block; 102, 103; 102, 213; 102, 233; 102, 244; 103, if_statement; 103, 104; 103, 106; 104, not_operator; 104, 105; 105, identifier:ignore_meta_conflict; 106, block; 106, 107; 106, 127; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:cols; 110, list_comprehension; 110, 111; 110, 112; 110, 119; 111, identifier:i; 112, for_in_clause; 112, 113; 112, 114; 113, identifier:i; 114, attribute; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:other; 117, identifier:meta; 118, identifier:columns; 119, if_clause; 119, 120; 120, comparison_operator:in; 120, 121; 120, 122; 121, identifier:i; 122, attribute; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:ret; 125, identifier:meta; 126, identifier:columns; 127, if_statement; 127, 128; 127, 149; 128, not_operator; 128, 129; 129, call; 129, 130; 129, 140; 130, attribute; 130, 131; 130, 139; 131, subscript; 131, 132; 131, 137; 131, 138; 132, attribute; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:ret; 135, identifier:meta; 136, identifier:loc; 137, identifier:intersect; 138, identifier:cols; 139, identifier:equals; 140, argument_list; 140, 141; 141, subscript; 141, 142; 141, 147; 141, 148; 142, attribute; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:other; 145, identifier:meta; 146, identifier:loc; 147, identifier:intersect; 148, identifier:cols; 149, block; 149, 150; 149, 186; 149, 208; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:conflict_idx; 153, parenthesized_expression; 153, 154; 154, call; 154, 155; 154, 185; 155, attribute; 155, 156; 155, 184; 156, attribute; 156, 157; 156, 183; 157, call; 157, 158; 157, 182; 158, attribute; 158, 159; 158, 181; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:pd; 162, identifier:concat; 163, argument_list; 163, 164; 164, list:[ret.meta.loc[intersect, cols],
other.meta.loc[intersect, cols]]; 164, 165; 164, 173; 165, subscript; 165, 166; 165, 171; 165, 172; 166, attribute; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:ret; 169, identifier:meta; 170, identifier:loc; 171, identifier:intersect; 172, identifier:cols; 173, subscript; 173, 174; 173, 179; 173, 180; 174, attribute; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:other; 177, identifier:meta; 178, identifier:loc; 179, identifier:intersect; 180, identifier:cols; 181, identifier:drop_duplicates; 182, argument_list; 183, identifier:index; 184, identifier:drop_duplicates; 185, argument_list; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:msg; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, string:'conflict in `meta` for scenarios {}'; 192, identifier:format; 193, argument_list; 193, 194; 194, list_comprehension; 194, 195; 194, 196; 195, identifier:i; 196, for_in_clause; 196, 197; 196, 198; 197, identifier:i; 198, attribute; 198, 199; 198, 207; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:pd; 202, identifier:DataFrame; 203, argument_list; 203, 204; 204, keyword_argument; 204, 205; 204, 206; 205, identifier:index; 206, identifier:conflict_idx; 207, identifier:index; 208, raise_statement; 208, 209; 209, call; 209, 210; 209, 211; 210, identifier:ValueError; 211, argument_list; 211, 212; 212, identifier:msg; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:cols; 216, list_comprehension; 216, 217; 216, 218; 216, 225; 217, identifier:i; 218, for_in_clause; 218, 219; 218, 220; 219, identifier:i; 220, attribute; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:other; 223, identifier:meta; 224, identifier:columns; 225, if_clause; 225, 226; 226, comparison_operator:not; 226, 227; 226, 228; 227, identifier:i; 228, attribute; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:ret; 231, identifier:meta; 232, identifier:columns; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:_meta; 236, subscript; 236, 237; 236, 242; 236, 243; 237, attribute; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:other; 240, identifier:meta; 241, identifier:loc; 242, identifier:intersect; 243, identifier:cols; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:ret; 248, identifier:meta; 249, call; 249, 250; 249, 255; 250, attribute; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:ret; 253, identifier:meta; 254, identifier:merge; 255, argument_list; 255, 256; 255, 257; 255, 260; 255, 263; 256, identifier:_meta; 257, keyword_argument; 257, 258; 257, 259; 258, identifier:how; 259, string:'outer'; 260, keyword_argument; 260, 261; 260, 262; 261, identifier:left_index; 262, True; 263, keyword_argument; 263, 264; 263, 265; 264, identifier:right_index; 265, True; 266, if_statement; 266, 267; 266, 271; 267, not_operator; 267, 268; 268, attribute; 268, 269; 268, 270; 269, identifier:diff; 270, identifier:empty; 271, block; 271, 272; 271, 299; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 275; 274, identifier:sort_kwarg; 275, conditional_expression:if; 275, 276; 275, 277; 275, 292; 275, 293; 276, dictionary; 277, comparison_operator:<; 277, 278; 277, 291; 278, call; 278, 279; 278, 280; 279, identifier:int; 280, argument_list; 280, 281; 281, subscript; 281, 282; 281, 290; 282, call; 282, 283; 282, 288; 283, attribute; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:pd; 286, identifier:__version__; 287, identifier:split; 288, argument_list; 288, 289; 289, string:'.'; 290, integer:1; 291, integer:23; 292, line_continuation:\; 293, call; 293, 294; 293, 295; 294, identifier:dict; 295, argument_list; 295, 296; 296, keyword_argument; 296, 297; 296, 298; 297, identifier:sort; 298, False; 299, expression_statement; 299, 300; 300, assignment; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:ret; 303, identifier:meta; 304, call; 304, 305; 304, 310; 305, attribute; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:ret; 308, identifier:meta; 309, identifier:append; 310, argument_list; 310, 311; 310, 320; 311, subscript; 311, 312; 311, 317; 311, 318; 312, attribute; 312, 313; 312, 316; 313, attribute; 313, 314; 313, 315; 314, identifier:other; 315, identifier:meta; 316, identifier:loc; 317, identifier:diff; 318, slice; 318, 319; 319, colon; 320, dictionary_splat; 320, 321; 321, identifier:sort_kwarg; 322, expression_statement; 322, 323; 323, assignment; 323, 324; 323, 325; 324, identifier:_data; 325, call; 325, 326; 325, 338; 326, attribute; 326, 327; 326, 337; 327, call; 327, 328; 327, 333; 328, attribute; 328, 329; 328, 332; 329, attribute; 329, 330; 329, 331; 330, identifier:ret; 331, identifier:data; 332, identifier:set_index; 333, argument_list; 333, 334; 334, attribute; 334, 335; 334, 336; 335, identifier:ret; 336, identifier:_LONG_IDX; 337, identifier:append; 338, argument_list; 338, 339; 338, 349; 339, call; 339, 340; 339, 345; 340, attribute; 340, 341; 340, 344; 341, attribute; 341, 342; 341, 343; 342, identifier:other; 343, identifier:data; 344, identifier:set_index; 345, argument_list; 345, 346; 346, attribute; 346, 347; 346, 348; 347, identifier:other; 348, identifier:_LONG_IDX; 349, keyword_argument; 349, 350; 349, 351; 350, identifier:verify_integrity; 351, True; 352, expression_statement; 352, 353; 353, augmented_assignment:+=; 353, 354; 353, 357; 354, attribute; 354, 355; 354, 356; 355, identifier:ret; 356, identifier:extra_cols; 357, list_comprehension; 357, 358; 357, 359; 357, 364; 358, identifier:i; 359, for_in_clause; 359, 360; 359, 361; 360, identifier:i; 361, attribute; 361, 362; 361, 363; 362, identifier:other; 363, identifier:extra_cols; 364, if_clause; 364, 365; 365, comparison_operator:not; 365, 366; 365, 367; 366, identifier:i; 367, attribute; 367, 368; 367, 369; 368, identifier:ret; 369, identifier:extra_cols; 370, expression_statement; 370, 371; 371, assignment; 371, 372; 371, 375; 372, attribute; 372, 373; 372, 374; 373, identifier:ret; 374, identifier:_LONG_IDX; 375, binary_operator:+; 375, 376; 375, 382; 376, binary_operator:+; 376, 377; 376, 378; 377, identifier:IAMC_IDX; 378, list:[ret.time_col]; 378, 379; 379, attribute; 379, 380; 379, 381; 380, identifier:ret; 381, identifier:time_col; 382, attribute; 382, 383; 382, 384; 383, identifier:ret; 384, identifier:extra_cols; 385, expression_statement; 385, 386; 386, assignment; 386, 387; 386, 390; 387, attribute; 387, 388; 387, 389; 388, identifier:ret; 389, identifier:data; 390, call; 390, 391; 390, 392; 391, identifier:sort_data; 392, argument_list; 392, 393; 392, 398; 393, call; 393, 394; 393, 397; 394, attribute; 394, 395; 394, 396; 395, identifier:_data; 396, identifier:reset_index; 397, argument_list; 398, attribute; 398, 399; 398, 400; 399, identifier:ret; 400, identifier:_LONG_IDX; 401, if_statement; 401, 402; 401, 404; 402, not_operator; 402, 403; 403, identifier:inplace; 404, block; 404, 405; 405, return_statement; 405, 406; 406, identifier:ret | def append(self, other, ignore_meta_conflict=False, inplace=False,
**kwargs):
if not isinstance(other, IamDataFrame):
other = IamDataFrame(other, **kwargs)
ignore_meta_conflict = True
if self.time_col is not other.time_col:
raise ValueError('incompatible time format (years vs. datetime)!')
ret = copy.deepcopy(self) if not inplace else self
diff = other.meta.index.difference(ret.meta.index)
intersect = other.meta.index.intersection(ret.meta.index)
if not intersect.empty:
if not ignore_meta_conflict:
cols = [i for i in other.meta.columns if i in ret.meta.columns]
if not ret.meta.loc[intersect, cols].equals(
other.meta.loc[intersect, cols]):
conflict_idx = (
pd.concat([ret.meta.loc[intersect, cols],
other.meta.loc[intersect, cols]]
).drop_duplicates()
.index.drop_duplicates()
)
msg = 'conflict in `meta` for scenarios {}'.format(
[i for i in pd.DataFrame(index=conflict_idx).index])
raise ValueError(msg)
cols = [i for i in other.meta.columns if i not in ret.meta.columns]
_meta = other.meta.loc[intersect, cols]
ret.meta = ret.meta.merge(_meta, how='outer',
left_index=True, right_index=True)
if not diff.empty:
sort_kwarg = {} if int(pd.__version__.split('.')[1]) < 23 \
else dict(sort=False)
ret.meta = ret.meta.append(other.meta.loc[diff, :], **sort_kwarg)
_data = ret.data.set_index(ret._LONG_IDX).append(
other.data.set_index(other._LONG_IDX), verify_integrity=True)
ret.extra_cols += [i for i in other.extra_cols
if i not in ret.extra_cols]
ret._LONG_IDX = IAMC_IDX + [ret.time_col] + ret.extra_cols
ret.data = sort_data(_data.reset_index(), ret._LONG_IDX)
if not inplace:
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 2, function_name:pivot_table; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 4, identifier:self; 5, identifier:index; 6, identifier:columns; 7, default_parameter; 7, 8; 7, 9; 8, identifier:values; 9, string:'value'; 10, default_parameter; 10, 11; 10, 12; 11, identifier:aggfunc; 12, string:'count'; 13, default_parameter; 13, 14; 13, 15; 14, identifier:fill_value; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:style; 18, None; 19, block; 19, 20; 19, 31; 19, 42; 19, 48; 19, 149; 19, 172; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:index; 23, conditional_expression:if; 23, 24; 23, 26; 23, 30; 24, list:[index]; 24, 25; 25, identifier:index; 26, call; 26, 27; 26, 28; 27, identifier:isstr; 28, argument_list; 28, 29; 29, identifier:index; 30, identifier:index; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:columns; 34, conditional_expression:if; 34, 35; 34, 37; 34, 41; 35, list:[columns]; 35, 36; 36, identifier:columns; 37, call; 37, 38; 37, 39; 38, identifier:isstr; 39, argument_list; 39, 40; 40, identifier:columns; 41, identifier:columns; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:df; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:data; 48, if_statement; 48, 49; 48, 53; 49, call; 49, 50; 49, 51; 50, identifier:isstr; 51, argument_list; 51, 52; 52, identifier:aggfunc; 53, block; 53, 54; 54, if_statement; 54, 55; 54, 58; 54, 83; 54, 129; 55, comparison_operator:==; 55, 56; 55, 57; 56, identifier:aggfunc; 57, string:'count'; 58, block; 58, 59; 58, 79; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:df; 62, call; 62, 63; 62, 78; 63, attribute; 63, 64; 63, 77; 64, call; 64, 65; 64, 70; 65, attribute; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:data; 69, identifier:groupby; 70, argument_list; 70, 71; 70, 74; 71, binary_operator:+; 71, 72; 71, 73; 72, identifier:index; 73, identifier:columns; 74, keyword_argument; 74, 75; 74, 76; 75, identifier:as_index; 76, False; 77, identifier:count; 78, argument_list; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:fill_value; 82, integer:0; 83, elif_clause; 83, 84; 83, 87; 84, comparison_operator:==; 84, 85; 84, 86; 85, identifier:aggfunc; 86, string:'mean'; 87, block; 87, 88; 87, 114; 87, 120; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:df; 91, call; 91, 92; 91, 112; 92, attribute; 92, 93; 92, 110; 92, 111; 93, call; 93, 94; 93, 109; 94, attribute; 94, 95; 94, 108; 95, call; 95, 96; 95, 101; 96, attribute; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:data; 100, identifier:groupby; 101, argument_list; 101, 102; 101, 105; 102, binary_operator:+; 102, 103; 102, 104; 103, identifier:index; 104, identifier:columns; 105, keyword_argument; 105, 106; 105, 107; 106, identifier:as_index; 107, False; 108, identifier:mean; 109, argument_list; 110, line_continuation:\; 111, identifier:round; 112, argument_list; 112, 113; 113, integer:2; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:aggfunc; 117, attribute; 117, 118; 117, 119; 118, identifier:np; 119, identifier:sum; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:fill_value; 123, conditional_expression:if; 123, 124; 123, 125; 123, 128; 124, integer:0; 125, comparison_operator:==; 125, 126; 125, 127; 126, identifier:style; 127, string:'heatmap'; 128, string:""; 129, elif_clause; 129, 130; 129, 133; 130, comparison_operator:==; 130, 131; 130, 132; 131, identifier:aggfunc; 132, string:'sum'; 133, block; 133, 134; 133, 140; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:aggfunc; 137, attribute; 137, 138; 137, 139; 138, identifier:np; 139, identifier:sum; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:fill_value; 143, conditional_expression:if; 143, 144; 143, 145; 143, 148; 144, integer:0; 145, comparison_operator:==; 145, 146; 145, 147; 146, identifier:style; 147, string:'heatmap'; 148, string:""; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:df; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:df; 155, identifier:pivot_table; 156, argument_list; 156, 157; 156, 160; 156, 163; 156, 166; 156, 169; 157, keyword_argument; 157, 158; 157, 159; 158, identifier:values; 159, identifier:values; 160, keyword_argument; 160, 161; 160, 162; 161, identifier:index; 162, identifier:index; 163, keyword_argument; 163, 164; 163, 165; 164, identifier:columns; 165, identifier:columns; 166, keyword_argument; 166, 167; 166, 168; 167, identifier:aggfunc; 168, identifier:aggfunc; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:fill_value; 171, identifier:fill_value; 172, return_statement; 172, 173; 173, identifier:df | def pivot_table(self, index, columns, values='value',
aggfunc='count', fill_value=None, style=None):
index = [index] if isstr(index) else index
columns = [columns] if isstr(columns) else columns
df = self.data
if isstr(aggfunc):
if aggfunc == 'count':
df = self.data.groupby(index + columns, as_index=False).count()
fill_value = 0
elif aggfunc == 'mean':
df = self.data.groupby(index + columns, as_index=False).mean()\
.round(2)
aggfunc = np.sum
fill_value = 0 if style == 'heatmap' else ""
elif aggfunc == 'sum':
aggfunc = np.sum
fill_value = 0 if style == 'heatmap' else ""
df = df.pivot_table(values=values, index=index, columns=columns,
aggfunc=aggfunc, fill_value=fill_value)
return df |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:check_internal_consistency; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 12; 7, 68; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:inconsistent_vars; 11, dictionary; 12, for_statement; 12, 13; 12, 14; 12, 19; 13, identifier:variable; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:variables; 18, argument_list; 19, block; 19, 20; 19, 31; 19, 44; 19, 55; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:diff_agg; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:check_aggregate; 27, argument_list; 27, 28; 27, 29; 28, identifier:variable; 29, dictionary_splat; 29, 30; 30, identifier:kwargs; 31, if_statement; 31, 32; 31, 35; 32, comparison_operator:is; 32, 33; 32, 34; 33, identifier:diff_agg; 34, None; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 43; 38, subscript; 38, 39; 38, 40; 39, identifier:inconsistent_vars; 40, binary_operator:+; 40, 41; 40, 42; 41, identifier:variable; 42, string:"-aggregate"; 43, identifier:diff_agg; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:diff_regional; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:check_aggregate_region; 51, argument_list; 51, 52; 51, 53; 52, identifier:variable; 53, dictionary_splat; 53, 54; 54, identifier:kwargs; 55, if_statement; 55, 56; 55, 59; 56, comparison_operator:is; 56, 57; 56, 58; 57, identifier:diff_regional; 58, None; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 67; 62, subscript; 62, 63; 62, 64; 63, identifier:inconsistent_vars; 64, binary_operator:+; 64, 65; 64, 66; 65, identifier:variable; 66, string:"-regional"; 67, identifier:diff_regional; 68, return_statement; 68, 69; 69, conditional_expression:if; 69, 70; 69, 71; 69, 72; 70, identifier:inconsistent_vars; 71, identifier:inconsistent_vars; 72, None | def check_internal_consistency(self, **kwargs):
inconsistent_vars = {}
for variable in self.variables():
diff_agg = self.check_aggregate(variable, **kwargs)
if diff_agg is not None:
inconsistent_vars[variable + "-aggregate"] = diff_agg
diff_regional = self.check_aggregate_region(variable, **kwargs)
if diff_regional is not None:
inconsistent_vars[variable + "-regional"] = diff_regional
return inconsistent_vars if inconsistent_vars else None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_apply_filters; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, dictionary_splat_pattern; 5, 6; 6, identifier:filters; 7, block; 7, 8; 7, 18; 7, 35; 7, 432; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:regexp; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:filters; 14, identifier:pop; 15, argument_list; 15, 16; 15, 17; 16, string:'regexp'; 17, False; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:keep; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:np; 24, identifier:array; 25, argument_list; 25, 26; 26, binary_operator:*; 26, 27; 26, 29; 27, list:[True]; 27, 28; 28, True; 29, call; 29, 30; 29, 31; 30, identifier:len; 31, argument_list; 31, 32; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:data; 35, for_statement; 35, 36; 35, 39; 35, 44; 36, pattern_list; 36, 37; 36, 38; 37, identifier:col; 38, identifier:values; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:filters; 42, identifier:items; 43, argument_list; 44, block; 44, 45; 44, 51; 44, 428; 45, if_statement; 45, 46; 45, 49; 46, comparison_operator:is; 46, 47; 46, 48; 47, identifier:values; 48, None; 49, block; 49, 50; 50, continue_statement; 51, if_statement; 51, 52; 51, 59; 51, 106; 51, 136; 51, 179; 51, 212; 51, 310; 51, 343; 51, 366; 51, 397; 51, 421; 52, comparison_operator:in; 52, 53; 52, 54; 53, identifier:col; 54, attribute; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:meta; 58, identifier:columns; 59, block; 59, 60; 59, 75; 59, 85; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:matches; 63, call; 63, 64; 63, 65; 64, identifier:pattern_match; 65, argument_list; 65, 66; 65, 71; 65, 72; 66, subscript; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:meta; 70, identifier:col; 71, identifier:values; 72, keyword_argument; 72, 73; 72, 74; 73, identifier:regexp; 74, identifier:regexp; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:cat_idx; 78, attribute; 78, 79; 78, 84; 79, subscript; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:meta; 83, identifier:matches; 84, identifier:index; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:keep_col; 88, parenthesized_expression; 88, 89; 89, call; 89, 90; 89, 104; 90, attribute; 90, 91; 90, 103; 91, attribute; 91, 92; 91, 102; 92, call; 92, 93; 92, 100; 93, attribute; 93, 94; 93, 99; 94, subscript; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:data; 98, identifier:META_IDX; 99, identifier:set_index; 100, argument_list; 100, 101; 101, identifier:META_IDX; 102, identifier:index; 103, identifier:isin; 104, argument_list; 104, 105; 105, identifier:cat_idx; 106, elif_clause; 106, 107; 106, 110; 107, comparison_operator:==; 107, 108; 107, 109; 108, identifier:col; 109, string:'variable'; 110, block; 110, 111; 110, 122; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:level; 114, conditional_expression:if; 114, 115; 114, 118; 114, 121; 115, subscript; 115, 116; 115, 117; 116, identifier:filters; 117, string:'level'; 118, comparison_operator:in; 118, 119; 118, 120; 119, string:'level'; 120, identifier:filters; 121, None; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:keep_col; 125, call; 125, 126; 125, 127; 126, identifier:pattern_match; 127, argument_list; 127, 128; 127, 133; 127, 134; 127, 135; 128, subscript; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:data; 132, identifier:col; 133, identifier:values; 134, identifier:level; 135, identifier:regexp; 136, elif_clause; 136, 137; 136, 140; 137, comparison_operator:==; 137, 138; 137, 139; 138, identifier:col; 139, string:'year'; 140, block; 140, 141; 140, 171; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:_data; 144, conditional_expression:if; 144, 145; 144, 150; 144, 155; 144, 156; 145, subscript; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:self; 148, identifier:data; 149, identifier:col; 150, comparison_operator:is; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:time_col; 154, string:'time'; 155, line_continuation:\; 156, call; 156, 157; 156, 164; 157, attribute; 157, 158; 157, 163; 158, subscript; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:data; 162, string:'time'; 163, identifier:apply; 164, argument_list; 164, 165; 165, lambda; 165, 166; 165, 168; 166, lambda_parameters; 166, 167; 167, identifier:x; 168, attribute; 168, 169; 168, 170; 169, identifier:x; 170, identifier:year; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:keep_col; 174, call; 174, 175; 174, 176; 175, identifier:years_match; 176, argument_list; 176, 177; 176, 178; 177, identifier:_data; 178, identifier:values; 179, elif_clause; 179, 180; 179, 189; 180, boolean_operator:and; 180, 181; 180, 184; 181, comparison_operator:==; 181, 182; 181, 183; 182, identifier:col; 183, string:'month'; 184, comparison_operator:is; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:self; 187, identifier:time_col; 188, string:'time'; 189, block; 189, 190; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:keep_col; 193, call; 193, 194; 193, 195; 194, identifier:month_match; 195, argument_list; 195, 196; 195, 211; 196, call; 196, 197; 196, 204; 197, attribute; 197, 198; 197, 203; 198, subscript; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:self; 201, identifier:data; 202, string:'time'; 203, identifier:apply; 204, argument_list; 204, 205; 205, lambda; 205, 206; 205, 208; 206, lambda_parameters; 206, 207; 207, identifier:x; 208, attribute; 208, 209; 208, 210; 209, identifier:x; 210, identifier:month; 211, identifier:values; 212, elif_clause; 212, 213; 212, 222; 213, boolean_operator:and; 213, 214; 213, 217; 214, comparison_operator:==; 214, 215; 214, 216; 215, identifier:col; 216, string:'day'; 217, comparison_operator:is; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:self; 220, identifier:time_col; 221, string:'time'; 222, block; 222, 223; 222, 259; 222, 302; 223, if_statement; 223, 224; 223, 229; 223, 234; 223, 253; 224, call; 224, 225; 224, 226; 225, identifier:isinstance; 226, argument_list; 226, 227; 226, 228; 227, identifier:values; 228, identifier:str; 229, block; 229, 230; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:wday; 233, True; 234, elif_clause; 234, 235; 234, 248; 235, boolean_operator:and; 235, 236; 235, 241; 236, call; 236, 237; 236, 238; 237, identifier:isinstance; 238, argument_list; 238, 239; 238, 240; 239, identifier:values; 240, identifier:list; 241, call; 241, 242; 241, 243; 242, identifier:isinstance; 243, argument_list; 243, 244; 243, 247; 244, subscript; 244, 245; 244, 246; 245, identifier:values; 246, integer:0; 247, identifier:str; 248, block; 248, 249; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:wday; 252, True; 253, else_clause; 253, 254; 254, block; 254, 255; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:wday; 258, False; 259, if_statement; 259, 260; 259, 261; 259, 282; 260, identifier:wday; 261, block; 261, 262; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 265; 264, identifier:days; 265, call; 265, 266; 265, 273; 266, attribute; 266, 267; 266, 272; 267, subscript; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, identifier:self; 270, identifier:data; 271, string:'time'; 272, identifier:apply; 273, argument_list; 273, 274; 274, lambda; 274, 275; 274, 277; 275, lambda_parameters; 275, 276; 276, identifier:x; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:x; 280, identifier:weekday; 281, argument_list; 282, else_clause; 282, 283; 283, block; 283, 284; 284, expression_statement; 284, 285; 285, assignment; 285, 286; 285, 287; 286, identifier:days; 287, call; 287, 288; 287, 295; 288, attribute; 288, 289; 288, 294; 289, subscript; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:self; 292, identifier:data; 293, string:'time'; 294, identifier:apply; 295, argument_list; 295, 296; 296, lambda; 296, 297; 296, 299; 297, lambda_parameters; 297, 298; 298, identifier:x; 299, attribute; 299, 300; 299, 301; 300, identifier:x; 301, identifier:day; 302, expression_statement; 302, 303; 303, assignment; 303, 304; 303, 305; 304, identifier:keep_col; 305, call; 305, 306; 305, 307; 306, identifier:day_match; 307, argument_list; 307, 308; 307, 309; 308, identifier:days; 309, identifier:values; 310, elif_clause; 310, 311; 310, 320; 311, boolean_operator:and; 311, 312; 311, 315; 312, comparison_operator:==; 312, 313; 312, 314; 313, identifier:col; 314, string:'hour'; 315, comparison_operator:is; 315, 316; 315, 319; 316, attribute; 316, 317; 316, 318; 317, identifier:self; 318, identifier:time_col; 319, string:'time'; 320, block; 320, 321; 321, expression_statement; 321, 322; 322, assignment; 322, 323; 322, 324; 323, identifier:keep_col; 324, call; 324, 325; 324, 326; 325, identifier:hour_match; 326, argument_list; 326, 327; 326, 342; 327, call; 327, 328; 327, 335; 328, attribute; 328, 329; 328, 334; 329, subscript; 329, 330; 329, 333; 330, attribute; 330, 331; 330, 332; 331, identifier:self; 332, identifier:data; 333, string:'time'; 334, identifier:apply; 335, argument_list; 335, 336; 336, lambda; 336, 337; 336, 339; 337, lambda_parameters; 337, 338; 338, identifier:x; 339, attribute; 339, 340; 339, 341; 340, identifier:x; 341, identifier:hour; 342, identifier:values; 343, elif_clause; 343, 344; 343, 353; 344, boolean_operator:and; 344, 345; 344, 348; 345, comparison_operator:==; 345, 346; 345, 347; 346, identifier:col; 347, string:'time'; 348, comparison_operator:is; 348, 349; 348, 352; 349, attribute; 349, 350; 349, 351; 350, identifier:self; 351, identifier:time_col; 352, string:'time'; 353, block; 353, 354; 354, expression_statement; 354, 355; 355, assignment; 355, 356; 355, 357; 356, identifier:keep_col; 357, call; 357, 358; 357, 359; 358, identifier:datetime_match; 359, argument_list; 359, 360; 359, 365; 360, subscript; 360, 361; 360, 364; 361, attribute; 361, 362; 361, 363; 362, identifier:self; 363, identifier:data; 364, identifier:col; 365, identifier:values; 366, elif_clause; 366, 367; 366, 370; 367, comparison_operator:==; 367, 368; 367, 369; 368, identifier:col; 369, string:'level'; 370, block; 370, 371; 371, if_statement; 371, 372; 371, 379; 371, 394; 372, comparison_operator:not; 372, 373; 372, 374; 373, string:'variable'; 374, call; 374, 375; 374, 378; 375, attribute; 375, 376; 375, 377; 376, identifier:filters; 377, identifier:keys; 378, argument_list; 379, block; 379, 380; 380, expression_statement; 380, 381; 381, assignment; 381, 382; 381, 383; 382, identifier:keep_col; 383, call; 383, 384; 383, 385; 384, identifier:find_depth; 385, argument_list; 385, 386; 385, 391; 386, subscript; 386, 387; 386, 390; 387, attribute; 387, 388; 387, 389; 388, identifier:self; 389, identifier:data; 390, string:'variable'; 391, keyword_argument; 391, 392; 391, 393; 392, identifier:level; 393, identifier:values; 394, else_clause; 394, 395; 395, block; 395, 396; 396, continue_statement; 397, elif_clause; 397, 398; 397, 405; 398, comparison_operator:in; 398, 399; 398, 400; 399, identifier:col; 400, attribute; 400, 401; 400, 404; 401, attribute; 401, 402; 401, 403; 402, identifier:self; 403, identifier:data; 404, identifier:columns; 405, block; 405, 406; 406, expression_statement; 406, 407; 407, assignment; 407, 408; 407, 409; 408, identifier:keep_col; 409, call; 409, 410; 409, 411; 410, identifier:pattern_match; 411, argument_list; 411, 412; 411, 417; 411, 418; 412, subscript; 412, 413; 412, 416; 413, attribute; 413, 414; 413, 415; 414, identifier:self; 415, identifier:data; 416, identifier:col; 417, identifier:values; 418, keyword_argument; 418, 419; 418, 420; 419, identifier:regexp; 420, identifier:regexp; 421, else_clause; 421, 422; 422, block; 422, 423; 423, expression_statement; 423, 424; 424, call; 424, 425; 424, 426; 425, identifier:_raise_filter_error; 426, argument_list; 426, 427; 427, identifier:col; 428, expression_statement; 428, 429; 429, augmented_assignment:&=; 429, 430; 429, 431; 430, identifier:keep; 431, identifier:keep_col; 432, return_statement; 432, 433; 433, identifier:keep | def _apply_filters(self, **filters):
regexp = filters.pop('regexp', False)
keep = np.array([True] * len(self.data))
for col, values in filters.items():
if values is None:
continue
if col in self.meta.columns:
matches = pattern_match(self.meta[col], values, regexp=regexp)
cat_idx = self.meta[matches].index
keep_col = (self.data[META_IDX].set_index(META_IDX)
.index.isin(cat_idx))
elif col == 'variable':
level = filters['level'] if 'level' in filters else None
keep_col = pattern_match(self.data[col], values, level, regexp)
elif col == 'year':
_data = self.data[col] if self.time_col is not 'time' \
else self.data['time'].apply(lambda x: x.year)
keep_col = years_match(_data, values)
elif col == 'month' and self.time_col is 'time':
keep_col = month_match(self.data['time']
.apply(lambda x: x.month),
values)
elif col == 'day' and self.time_col is 'time':
if isinstance(values, str):
wday = True
elif isinstance(values, list) and isinstance(values[0], str):
wday = True
else:
wday = False
if wday:
days = self.data['time'].apply(lambda x: x.weekday())
else:
days = self.data['time'].apply(lambda x: x.day)
keep_col = day_match(days, values)
elif col == 'hour' and self.time_col is 'time':
keep_col = hour_match(self.data['time']
.apply(lambda x: x.hour),
values)
elif col == 'time' and self.time_col is 'time':
keep_col = datetime_match(self.data[col], values)
elif col == 'level':
if 'variable' not in filters.keys():
keep_col = find_depth(self.data['variable'], level=values)
else:
continue
elif col in self.data.columns:
keep_col = pattern_match(self.data[col], values, regexp=regexp)
else:
_raise_filter_error(col)
keep &= keep_col
return keep |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:load_metadata; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 8; 4, identifier:self; 5, identifier:path; 6, list_splat_pattern; 6, 7; 7, identifier:args; 8, dictionary_splat_pattern; 8, 9; 9, identifier:kwargs; 10, block; 10, 11; 10, 31; 10, 96; 10, 103; 10, 135; 10, 145; 10, 160; 10, 172; 10, 201; 10, 211; 10, 219; 10, 223; 10, 255; 10, 287; 11, if_statement; 11, 12; 11, 21; 12, not_operator; 12, 13; 13, call; 13, 14; 13, 19; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:os; 17, identifier:path; 18, identifier:exists; 19, argument_list; 19, 20; 20, identifier:path; 21, block; 21, 22; 22, raise_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:ValueError; 25, argument_list; 25, 26; 26, binary_operator:+; 26, 27; 26, 30; 27, binary_operator:+; 27, 28; 27, 29; 28, string:"no metadata file '"; 29, identifier:path; 30, string:"' found!"; 31, if_statement; 31, 32; 31, 38; 31, 52; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:path; 35, identifier:endswith; 36, argument_list; 36, 37; 37, string:'csv'; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:df; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:pd; 45, identifier:read_csv; 46, argument_list; 46, 47; 46, 48; 46, 50; 47, identifier:path; 48, list_splat; 48, 49; 49, identifier:args; 50, dictionary_splat; 50, 51; 51, identifier:kwargs; 52, else_clause; 52, 53; 53, block; 53, 54; 53, 63; 53, 83; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:xl; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:pd; 60, identifier:ExcelFile; 61, argument_list; 61, 62; 62, identifier:path; 63, if_statement; 63, 64; 63, 76; 64, boolean_operator:and; 64, 65; 64, 73; 65, comparison_operator:>; 65, 66; 65, 72; 66, call; 66, 67; 66, 68; 67, identifier:len; 68, argument_list; 68, 69; 69, attribute; 69, 70; 69, 71; 70, identifier:xl; 71, identifier:sheet_names; 72, integer:1; 73, comparison_operator:not; 73, 74; 73, 75; 74, string:'sheet_name'; 75, identifier:kwargs; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 82; 79, subscript; 79, 80; 79, 81; 80, identifier:kwargs; 81, string:'sheet_name'; 82, string:'meta'; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:df; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:pd; 89, identifier:read_excel; 90, argument_list; 90, 91; 90, 92; 90, 94; 91, identifier:path; 92, list_splat; 92, 93; 93, identifier:args; 94, dictionary_splat; 94, 95; 95, identifier:kwargs; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:req_cols; 99, list:['model', 'scenario', 'exclude']; 99, 100; 99, 101; 99, 102; 100, string:'model'; 101, string:'scenario'; 102, string:'exclude'; 103, if_statement; 103, 104; 103, 119; 104, not_operator; 104, 105; 105, call; 105, 106; 105, 112; 106, attribute; 106, 107; 106, 111; 107, call; 107, 108; 107, 109; 108, identifier:set; 109, argument_list; 109, 110; 110, identifier:req_cols; 111, identifier:issubset; 112, argument_list; 112, 113; 113, call; 113, 114; 113, 115; 114, identifier:set; 115, argument_list; 115, 116; 116, attribute; 116, 117; 116, 118; 117, identifier:df; 118, identifier:columns; 119, block; 119, 120; 119, 124; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:e; 123, string:'File `{}` does not have required columns ({})!'; 124, raise_statement; 124, 125; 125, call; 125, 126; 125, 127; 126, identifier:ValueError; 127, argument_list; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:e; 131, identifier:format; 132, argument_list; 132, 133; 132, 134; 133, identifier:path; 134, identifier:req_cols; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:df; 139, identifier:set_index; 140, argument_list; 140, 141; 140, 142; 141, identifier:META_IDX; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:inplace; 144, True; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:idx; 148, call; 148, 149; 148, 156; 149, attribute; 149, 150; 149, 155; 150, attribute; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:meta; 154, identifier:index; 155, identifier:intersection; 156, argument_list; 156, 157; 157, attribute; 157, 158; 157, 159; 158, identifier:df; 159, identifier:index; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:n_invalid; 163, binary_operator:-; 163, 164; 163, 168; 164, call; 164, 165; 164, 166; 165, identifier:len; 166, argument_list; 166, 167; 167, identifier:df; 168, call; 168, 169; 168, 170; 169, identifier:len; 170, argument_list; 170, 171; 171, identifier:idx; 172, if_statement; 172, 173; 172, 176; 173, comparison_operator:>; 173, 174; 173, 175; 174, identifier:n_invalid; 175, integer:0; 176, block; 176, 177; 176, 181; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:msg; 180, string:'Ignoring {} scenario{} from imported metadata'; 181, expression_statement; 181, 182; 182, call; 182, 183; 182, 188; 183, attribute; 183, 184; 183, 187; 184, call; 184, 185; 184, 186; 185, identifier:logger; 186, argument_list; 187, identifier:info; 188, argument_list; 188, 189; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:msg; 192, identifier:format; 193, argument_list; 193, 194; 193, 195; 194, identifier:n_invalid; 195, conditional_expression:if; 195, 196; 195, 197; 195, 200; 196, string:'s'; 197, comparison_operator:>; 197, 198; 197, 199; 198, identifier:n_invalid; 199, integer:1; 200, string:''; 201, if_statement; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:idx; 204, identifier:empty; 205, block; 205, 206; 206, raise_statement; 206, 207; 207, call; 207, 208; 207, 209; 208, identifier:ValueError; 209, argument_list; 209, 210; 210, string:'No valid scenarios in imported metadata file!'; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:df; 214, subscript; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:df; 217, identifier:loc; 218, identifier:idx; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:msg; 222, string:'Importing metadata for {} scenario{} (for total of {})'; 223, expression_statement; 223, 224; 224, call; 224, 225; 224, 230; 225, attribute; 225, 226; 225, 229; 226, call; 226, 227; 226, 228; 227, identifier:logger; 228, argument_list; 229, identifier:info; 230, argument_list; 230, 231; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:msg; 234, identifier:format; 235, argument_list; 235, 236; 235, 240; 235, 249; 236, call; 236, 237; 236, 238; 237, identifier:len; 238, argument_list; 238, 239; 239, identifier:df; 240, conditional_expression:if; 240, 241; 240, 242; 240, 248; 241, string:'s'; 242, comparison_operator:>; 242, 243; 242, 247; 243, call; 243, 244; 243, 245; 244, identifier:len; 245, argument_list; 245, 246; 246, identifier:df; 247, integer:1; 248, string:''; 249, call; 249, 250; 249, 251; 250, identifier:len; 251, argument_list; 251, 252; 252, attribute; 252, 253; 252, 254; 253, identifier:self; 254, identifier:meta; 255, for_statement; 255, 256; 255, 257; 255, 260; 256, identifier:col; 257, attribute; 257, 258; 257, 259; 258, identifier:df; 259, identifier:columns; 260, block; 260, 261; 260, 268; 261, expression_statement; 261, 262; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:self; 265, identifier:_new_meta_column; 266, argument_list; 266, 267; 267, identifier:col; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 275; 270, subscript; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:self; 273, identifier:meta; 274, identifier:col; 275, call; 275, 276; 275, 281; 276, attribute; 276, 277; 276, 280; 277, subscript; 277, 278; 277, 279; 278, identifier:df; 279, identifier:col; 280, identifier:combine_first; 281, argument_list; 281, 282; 282, subscript; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:self; 285, identifier:meta; 286, identifier:col; 287, expression_statement; 287, 288; 288, assignment; 288, 289; 288, 294; 289, attribute; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:self; 292, identifier:meta; 293, identifier:exclude; 294, call; 294, 295; 294, 302; 295, attribute; 295, 296; 295, 301; 296, attribute; 296, 297; 296, 300; 297, attribute; 297, 298; 297, 299; 298, identifier:self; 299, identifier:meta; 300, identifier:exclude; 301, identifier:astype; 302, argument_list; 302, 303; 303, string:'bool' | def load_metadata(self, path, *args, **kwargs):
if not os.path.exists(path):
raise ValueError("no metadata file '" + path + "' found!")
if path.endswith('csv'):
df = pd.read_csv(path, *args, **kwargs)
else:
xl = pd.ExcelFile(path)
if len(xl.sheet_names) > 1 and 'sheet_name' not in kwargs:
kwargs['sheet_name'] = 'meta'
df = pd.read_excel(path, *args, **kwargs)
req_cols = ['model', 'scenario', 'exclude']
if not set(req_cols).issubset(set(df.columns)):
e = 'File `{}` does not have required columns ({})!'
raise ValueError(e.format(path, req_cols))
df.set_index(META_IDX, inplace=True)
idx = self.meta.index.intersection(df.index)
n_invalid = len(df) - len(idx)
if n_invalid > 0:
msg = 'Ignoring {} scenario{} from imported metadata'
logger().info(msg.format(n_invalid, 's' if n_invalid > 1 else ''))
if idx.empty:
raise ValueError('No valid scenarios in imported metadata file!')
df = df.loc[idx]
msg = 'Importing metadata for {} scenario{} (for total of {})'
logger().info(msg.format(len(df), 's' if len(df) > 1 else '',
len(self.meta)))
for col in df.columns:
self._new_meta_column(col)
self.meta[col] = df[col].combine_first(self.meta[col])
self.meta.exclude = self.meta.exclude.astype('bool') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:assign_style_props; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:df; 5, default_parameter; 5, 6; 5, 7; 6, identifier:color; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:marker; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:linestyle; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:cmap; 16, None; 17, block; 17, 18; 17, 32; 17, 75; 17, 90; 17, 94; 17, 100; 17, 113; 17, 205; 17, 304; 18, if_statement; 18, 19; 18, 26; 19, boolean_operator:and; 19, 20; 19, 23; 20, comparison_operator:is; 20, 21; 20, 22; 21, identifier:color; 22, None; 23, comparison_operator:is; 23, 24; 23, 25; 24, identifier:cmap; 25, None; 26, block; 26, 27; 27, raise_statement; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:ValueError; 30, argument_list; 30, 31; 31, string:'`cmap` must be provided with the `color` argument'; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:n; 35, conditional_expression:if; 35, 36; 35, 46; 35, 51; 35, 52; 36, call; 36, 37; 36, 38; 37, identifier:len; 38, argument_list; 38, 39; 39, call; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, subscript; 41, 42; 41, 43; 42, identifier:df; 43, identifier:color; 44, identifier:unique; 45, argument_list; 46, comparison_operator:in; 46, 47; 46, 48; 47, identifier:color; 48, attribute; 48, 49; 48, 50; 49, identifier:df; 50, identifier:columns; 51, line_continuation:\; 52, call; 52, 53; 52, 54; 53, identifier:len; 54, argument_list; 54, 55; 55, call; 55, 56; 55, 74; 56, attribute; 56, 57; 56, 73; 57, subscript; 57, 58; 57, 59; 58, identifier:df; 59, call; 59, 60; 59, 61; 60, identifier:list; 61, argument_list; 61, 62; 62, binary_operator:&; 62, 63; 62, 69; 63, call; 63, 64; 63, 65; 64, identifier:set; 65, argument_list; 65, 66; 66, attribute; 66, 67; 66, 68; 67, identifier:df; 68, identifier:columns; 69, call; 69, 70; 69, 71; 70, identifier:set; 71, argument_list; 71, 72; 72, identifier:IAMC_IDX; 73, identifier:drop_duplicates; 74, argument_list; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:defaults; 78, call; 78, 79; 78, 80; 79, identifier:default_props; 80, argument_list; 80, 81; 80, 84; 80, 87; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:reset; 83, True; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:num_colors; 86, identifier:n; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:colormap; 89, identifier:cmap; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:props; 93, dictionary; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:rc; 97, call; 97, 98; 97, 99; 98, identifier:run_control; 99, argument_list; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:kinds; 103, list:[('color', color), ('marker', marker), ('linestyle', linestyle)]; 103, 104; 103, 107; 103, 110; 104, tuple; 104, 105; 104, 106; 105, string:'color'; 106, identifier:color; 107, tuple; 107, 108; 107, 109; 108, string:'marker'; 109, identifier:marker; 110, tuple; 110, 111; 110, 112; 111, string:'linestyle'; 112, identifier:linestyle; 113, for_statement; 113, 114; 113, 117; 113, 118; 114, pattern_list; 114, 115; 114, 116; 115, identifier:kind; 116, identifier:var; 117, identifier:kinds; 118, block; 118, 119; 118, 125; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:rc_has_kind; 122, comparison_operator:in; 122, 123; 122, 124; 123, identifier:kind; 124, identifier:rc; 125, if_statement; 125, 126; 125, 131; 126, comparison_operator:in; 126, 127; 126, 128; 127, identifier:var; 128, attribute; 128, 129; 128, 130; 129, identifier:df; 130, identifier:columns; 131, block; 131, 132; 131, 142; 131, 146; 131, 199; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:rc_has_var; 135, boolean_operator:and; 135, 136; 135, 137; 136, identifier:rc_has_kind; 137, comparison_operator:in; 137, 138; 137, 139; 138, identifier:var; 139, subscript; 139, 140; 139, 141; 140, identifier:rc; 141, identifier:kind; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:props_for_kind; 145, dictionary; 146, for_statement; 146, 147; 146, 148; 146, 155; 147, identifier:val; 148, call; 148, 149; 148, 154; 149, attribute; 149, 150; 149, 153; 150, subscript; 150, 151; 150, 152; 151, identifier:df; 152, identifier:var; 153, identifier:unique; 154, argument_list; 155, block; 155, 156; 156, if_statement; 156, 157; 156, 166; 156, 186; 157, boolean_operator:and; 157, 158; 157, 159; 158, identifier:rc_has_var; 159, comparison_operator:in; 159, 160; 159, 161; 160, identifier:val; 161, subscript; 161, 162; 161, 165; 162, subscript; 162, 163; 162, 164; 163, identifier:rc; 164, identifier:kind; 165, identifier:var; 166, block; 166, 167; 166, 179; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 172; 169, subscript; 169, 170; 169, 171; 170, identifier:props_for_kind; 171, identifier:val; 172, subscript; 172, 173; 172, 178; 173, subscript; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:rc; 176, identifier:kind; 177, identifier:var; 178, identifier:val; 179, expression_statement; 179, 180; 180, call; 180, 181; 180, 182; 181, identifier:next; 182, argument_list; 182, 183; 183, subscript; 183, 184; 183, 185; 184, identifier:defaults; 185, identifier:kind; 186, else_clause; 186, 187; 187, block; 187, 188; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 193; 190, subscript; 190, 191; 190, 192; 191, identifier:props_for_kind; 192, identifier:val; 193, call; 193, 194; 193, 195; 194, identifier:next; 195, argument_list; 195, 196; 196, subscript; 196, 197; 196, 198; 197, identifier:defaults; 198, identifier:kind; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 204; 201, subscript; 201, 202; 201, 203; 202, identifier:props; 203, identifier:kind; 204, identifier:props_for_kind; 205, if_statement; 205, 206; 205, 209; 206, comparison_operator:in; 206, 207; 206, 208; 207, string:'color'; 208, identifier:props; 209, block; 209, 210; 209, 216; 209, 227; 209, 244; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:d; 213, subscript; 213, 214; 213, 215; 214, identifier:props; 215, string:'color'; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:values; 219, call; 219, 220; 219, 221; 220, identifier:list; 221, argument_list; 221, 222; 222, call; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:d; 225, identifier:values; 226, argument_list; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:overlap_idx; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:np; 233, identifier:in1d; 234, argument_list; 234, 235; 234, 236; 235, identifier:values; 236, call; 236, 237; 236, 238; 237, identifier:list; 238, argument_list; 238, 239; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:PYAM_COLORS; 242, identifier:keys; 243, argument_list; 244, if_statement; 244, 245; 244, 250; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:overlap_idx; 248, identifier:any; 249, argument_list; 250, block; 250, 251; 250, 269; 250, 280; 250, 298; 251, expression_statement; 251, 252; 252, assignment; 252, 253; 252, 254; 253, identifier:keys; 254, subscript; 254, 255; 254, 268; 255, call; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:np; 258, identifier:array; 259, argument_list; 259, 260; 260, call; 260, 261; 260, 262; 261, identifier:list; 262, argument_list; 262, 263; 263, call; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:d; 266, identifier:keys; 267, argument_list; 268, identifier:overlap_idx; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:values; 272, subscript; 272, 273; 272, 279; 273, call; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:np; 276, identifier:array; 277, argument_list; 277, 278; 278, identifier:values; 279, identifier:overlap_idx; 280, for_statement; 280, 281; 280, 284; 280, 289; 281, pattern_list; 281, 282; 281, 283; 282, identifier:k; 283, identifier:v; 284, call; 284, 285; 284, 286; 285, identifier:zip; 286, argument_list; 286, 287; 286, 288; 287, identifier:keys; 288, identifier:values; 289, block; 289, 290; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 295; 292, subscript; 292, 293; 292, 294; 293, identifier:d; 294, identifier:k; 295, subscript; 295, 296; 295, 297; 296, identifier:PYAM_COLORS; 297, identifier:v; 298, expression_statement; 298, 299; 299, assignment; 299, 300; 299, 303; 300, subscript; 300, 301; 300, 302; 301, identifier:props; 302, string:'color'; 303, identifier:d; 304, return_statement; 304, 305; 305, identifier:props | def assign_style_props(df, color=None, marker=None, linestyle=None,
cmap=None):
if color is None and cmap is not None:
raise ValueError('`cmap` must be provided with the `color` argument')
n = len(df[color].unique()) if color in df.columns else \
len(df[list(set(df.columns) & set(IAMC_IDX))].drop_duplicates())
defaults = default_props(reset=True, num_colors=n, colormap=cmap)
props = {}
rc = run_control()
kinds = [('color', color), ('marker', marker), ('linestyle', linestyle)]
for kind, var in kinds:
rc_has_kind = kind in rc
if var in df.columns:
rc_has_var = rc_has_kind and var in rc[kind]
props_for_kind = {}
for val in df[var].unique():
if rc_has_var and val in rc[kind][var]:
props_for_kind[val] = rc[kind][var][val]
next(defaults[kind])
else:
props_for_kind[val] = next(defaults[kind])
props[kind] = props_for_kind
if 'color' in props:
d = props['color']
values = list(d.values())
overlap_idx = np.in1d(values, list(PYAM_COLORS.keys()))
if overlap_idx.any():
keys = np.array(list(d.keys()))[overlap_idx]
values = np.array(values)[overlap_idx]
for k, v in zip(keys, values):
d[k] = PYAM_COLORS[v]
props['color'] = d
return props |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 38; 2, function_name:scatter; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 3, 25; 3, 28; 3, 33; 3, 36; 4, identifier:df; 5, identifier:x; 6, identifier:y; 7, default_parameter; 7, 8; 7, 9; 8, identifier:ax; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:legend; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:title; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:color; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:marker; 21, string:'o'; 22, default_parameter; 22, 23; 22, 24; 23, identifier:linestyle; 24, None; 25, default_parameter; 25, 26; 25, 27; 26, identifier:cmap; 27, None; 28, default_parameter; 28, 29; 28, 30; 29, identifier:groupby; 30, list:['model', 'scenario']; 30, 31; 30, 32; 31, string:'model'; 32, string:'scenario'; 33, default_parameter; 33, 34; 33, 35; 34, identifier:with_lines; 35, False; 36, dictionary_splat_pattern; 36, 37; 37, identifier:kwargs; 38, block; 38, 39; 38, 54; 38, 73; 38, 82; 38, 86; 38, 259; 38, 269; 38, 319; 38, 343; 38, 350; 38, 357; 38, 367; 39, if_statement; 39, 40; 39, 43; 40, comparison_operator:is; 40, 41; 40, 42; 41, identifier:ax; 42, None; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 49; 46, pattern_list; 46, 47; 46, 48; 47, identifier:fig; 48, identifier:ax; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:plt; 52, identifier:subplots; 53, argument_list; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:props; 57, call; 57, 58; 57, 59; 58, identifier:assign_style_props; 59, argument_list; 59, 60; 59, 61; 59, 64; 59, 67; 59, 70; 60, identifier:df; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:color; 63, identifier:color; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:marker; 66, identifier:marker; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:linestyle; 69, identifier:linestyle; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:cmap; 72, identifier:cmap; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:groups; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:df; 79, identifier:groupby; 80, argument_list; 80, 81; 81, identifier:groupby; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:legend_data; 85, list:[]; 86, for_statement; 86, 87; 86, 90; 86, 91; 87, pattern_list; 87, 88; 87, 89; 88, identifier:name; 89, identifier:group; 90, identifier:groups; 91, block; 91, 92; 91, 96; 91, 100; 91, 178; 91, 212; 91, 219; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:pargs; 95, dictionary; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:labels; 99, list:[]; 100, for_statement; 100, 101; 100, 105; 100, 118; 101, pattern_list; 101, 102; 101, 103; 101, 104; 102, identifier:key; 103, identifier:kind; 104, identifier:var; 105, list:[('c', 'color', color),
('marker', 'marker', marker),
('linestyle', 'linestyle', linestyle)]; 105, 106; 105, 110; 105, 114; 106, tuple; 106, 107; 106, 108; 106, 109; 107, string:'c'; 108, string:'color'; 109, identifier:color; 110, tuple; 110, 111; 110, 112; 110, 113; 111, string:'marker'; 112, string:'marker'; 113, identifier:marker; 114, tuple; 114, 115; 114, 116; 114, 117; 115, string:'linestyle'; 116, string:'linestyle'; 117, identifier:linestyle; 118, block; 118, 119; 119, if_statement; 119, 120; 119, 123; 119, 170; 120, comparison_operator:in; 120, 121; 120, 122; 121, identifier:kind; 122, identifier:props; 123, block; 123, 124; 123, 134; 123, 150; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:label; 127, subscript; 127, 128; 127, 133; 128, attribute; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:group; 131, identifier:var; 132, identifier:values; 133, integer:0; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 139; 136, subscript; 136, 137; 136, 138; 137, identifier:pargs; 138, identifier:key; 139, subscript; 139, 140; 139, 143; 140, subscript; 140, 141; 140, 142; 141, identifier:props; 142, identifier:kind; 143, subscript; 143, 144; 143, 149; 144, attribute; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:group; 147, identifier:var; 148, identifier:values; 149, integer:0; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:labels; 154, identifier:append; 155, argument_list; 155, 156; 156, call; 156, 157; 156, 168; 157, attribute; 157, 158; 157, 167; 158, call; 158, 159; 158, 165; 159, attribute; 159, 160; 159, 164; 160, call; 160, 161; 160, 162; 161, identifier:repr; 162, argument_list; 162, 163; 163, identifier:label; 164, identifier:lstrip; 165, argument_list; 165, 166; 166, string:"u'"; 167, identifier:strip; 168, argument_list; 168, 169; 169, string:"'"; 170, else_clause; 170, 171; 171, block; 171, 172; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:pargs; 176, identifier:key; 177, identifier:var; 178, if_statement; 178, 179; 178, 185; 178, 198; 179, comparison_operator:>; 179, 180; 179, 184; 180, call; 180, 181; 180, 182; 181, identifier:len; 182, argument_list; 182, 183; 183, identifier:labels; 184, integer:0; 185, block; 185, 186; 186, expression_statement; 186, 187; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:legend_data; 190, identifier:append; 191, argument_list; 191, 192; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, string:' '; 195, identifier:join; 196, argument_list; 196, 197; 197, identifier:labels; 198, else_clause; 198, 199; 199, block; 199, 200; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:legend_data; 204, identifier:append; 205, argument_list; 205, 206; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, string:' '; 209, identifier:join; 210, argument_list; 210, 211; 211, identifier:name; 212, expression_statement; 212, 213; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:kwargs; 216, identifier:update; 217, argument_list; 217, 218; 218, identifier:pargs; 219, if_statement; 219, 220; 219, 221; 219, 236; 220, identifier:with_lines; 221, block; 221, 222; 222, expression_statement; 222, 223; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:ax; 226, identifier:plot; 227, argument_list; 227, 228; 227, 231; 227, 234; 228, subscript; 228, 229; 228, 230; 229, identifier:group; 230, identifier:x; 231, subscript; 231, 232; 231, 233; 232, identifier:group; 233, identifier:y; 234, dictionary_splat; 234, 235; 235, identifier:kwargs; 236, else_clause; 236, 237; 237, block; 237, 238; 237, 245; 238, expression_statement; 238, 239; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:kwargs; 242, identifier:pop; 243, argument_list; 243, 244; 244, string:'linestyle'; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:ax; 249, identifier:scatter; 250, argument_list; 250, 251; 250, 254; 250, 257; 251, subscript; 251, 252; 251, 253; 252, identifier:group; 253, identifier:x; 254, subscript; 254, 255; 254, 256; 255, identifier:group; 256, identifier:y; 257, dictionary_splat; 257, 258; 258, identifier:kwargs; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 264; 261, pattern_list; 261, 262; 261, 263; 262, identifier:handles; 263, identifier:labels; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:ax; 267, identifier:get_legend_handles_labels; 268, argument_list; 269, if_statement; 269, 270; 269, 279; 270, comparison_operator:!=; 270, 271; 270, 272; 271, identifier:legend_data; 272, binary_operator:*; 272, 273; 272, 275; 273, list:['']; 273, 274; 274, string:''; 275, call; 275, 276; 275, 277; 276, identifier:len; 277, argument_list; 277, 278; 278, identifier:legend_data; 279, block; 279, 280; 279, 296; 279, 309; 280, expression_statement; 280, 281; 281, assignment; 281, 282; 281, 283; 282, identifier:labels; 283, call; 283, 284; 283, 285; 284, identifier:sorted; 285, argument_list; 285, 286; 286, call; 286, 287; 286, 288; 287, identifier:list; 288, argument_list; 288, 289; 289, call; 289, 290; 289, 291; 290, identifier:set; 291, argument_list; 291, 292; 292, call; 292, 293; 292, 294; 293, identifier:tuple; 294, argument_list; 294, 295; 295, identifier:legend_data; 296, expression_statement; 296, 297; 297, assignment; 297, 298; 297, 299; 298, identifier:idxs; 299, list_comprehension; 299, 300; 299, 306; 300, call; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:legend_data; 303, identifier:index; 304, argument_list; 304, 305; 305, identifier:d; 306, for_in_clause; 306, 307; 306, 308; 307, identifier:d; 308, identifier:labels; 309, expression_statement; 309, 310; 310, assignment; 310, 311; 310, 312; 311, identifier:handles; 312, list_comprehension; 312, 313; 312, 316; 313, subscript; 313, 314; 313, 315; 314, identifier:handles; 315, identifier:i; 316, for_in_clause; 316, 317; 316, 318; 317, identifier:i; 318, identifier:idxs; 319, if_statement; 319, 320; 319, 334; 320, boolean_operator:or; 320, 321; 320, 331; 321, boolean_operator:and; 321, 322; 321, 325; 322, comparison_operator:is; 322, 323; 322, 324; 323, identifier:legend; 324, None; 325, comparison_operator:<; 325, 326; 325, 330; 326, call; 326, 327; 326, 328; 327, identifier:len; 328, argument_list; 328, 329; 329, identifier:labels; 330, integer:13; 331, comparison_operator:is; 331, 332; 331, 333; 332, identifier:legend; 333, False; 334, block; 334, 335; 335, expression_statement; 335, 336; 336, call; 336, 337; 336, 338; 337, identifier:_add_legend; 338, argument_list; 338, 339; 338, 340; 338, 341; 338, 342; 339, identifier:ax; 340, identifier:handles; 341, identifier:labels; 342, identifier:legend; 343, expression_statement; 343, 344; 344, call; 344, 345; 344, 348; 345, attribute; 345, 346; 345, 347; 346, identifier:ax; 347, identifier:set_xlabel; 348, argument_list; 348, 349; 349, identifier:x; 350, expression_statement; 350, 351; 351, call; 351, 352; 351, 355; 352, attribute; 352, 353; 352, 354; 353, identifier:ax; 354, identifier:set_ylabel; 355, argument_list; 355, 356; 356, identifier:y; 357, if_statement; 357, 358; 357, 359; 358, identifier:title; 359, block; 359, 360; 360, expression_statement; 360, 361; 361, call; 361, 362; 361, 365; 362, attribute; 362, 363; 362, 364; 363, identifier:ax; 364, identifier:set_title; 365, argument_list; 365, 366; 366, identifier:title; 367, return_statement; 367, 368; 368, identifier:ax | def scatter(df, x, y, ax=None, legend=None, title=None,
color=None, marker='o', linestyle=None, cmap=None,
groupby=['model', 'scenario'], with_lines=False, **kwargs):
if ax is None:
fig, ax = plt.subplots()
props = assign_style_props(df, color=color, marker=marker,
linestyle=linestyle, cmap=cmap)
groups = df.groupby(groupby)
legend_data = []
for name, group in groups:
pargs = {}
labels = []
for key, kind, var in [('c', 'color', color),
('marker', 'marker', marker),
('linestyle', 'linestyle', linestyle)]:
if kind in props:
label = group[var].values[0]
pargs[key] = props[kind][group[var].values[0]]
labels.append(repr(label).lstrip("u'").strip("'"))
else:
pargs[key] = var
if len(labels) > 0:
legend_data.append(' '.join(labels))
else:
legend_data.append(' '.join(name))
kwargs.update(pargs)
if with_lines:
ax.plot(group[x], group[y], **kwargs)
else:
kwargs.pop('linestyle')
ax.scatter(group[x], group[y], **kwargs)
handles, labels = ax.get_legend_handles_labels()
if legend_data != [''] * len(legend_data):
labels = sorted(list(set(tuple(legend_data))))
idxs = [legend_data.index(d) for d in labels]
handles = [handles[i] for i in idxs]
if legend is None and len(labels) < 13 or legend is not False:
_add_legend(ax, handles, labels, legend)
ax.set_xlabel(x)
ax.set_ylabel(y)
if title:
ax.set_title(title)
return ax |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 22; 2, function_name:config_create; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:kernel; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:label; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:devices; 13, list:[]; 14, default_parameter; 14, 15; 14, 16; 15, identifier:disks; 16, list:[]; 17, default_parameter; 17, 18; 17, 19; 18, identifier:volumes; 19, list:[]; 20, dictionary_splat_pattern; 20, 21; 21, identifier:kwargs; 22, block; 22, 23; 22, 30; 22, 41; 22, 59; 22, 78; 22, 93; 22, 226; 22, 235; 22, 297; 22, 338; 22, 345; 22, 369; 22, 375; 22, 389; 22, 405; 23, import_from_statement; 23, 24; 23, 28; 24, relative_import; 24, 25; 24, 26; 25, import_prefix; 26, dotted_name; 26, 27; 27, identifier:volume; 28, dotted_name; 28, 29; 29, identifier:Volume; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:hypervisor_prefix; 33, conditional_expression:if; 33, 34; 33, 35; 33, 40; 34, string:'sd'; 35, comparison_operator:==; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:hypervisor; 39, string:'kvm'; 40, string:'xvd'; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:device_names; 44, list_comprehension; 44, 45; 44, 52; 45, binary_operator:+; 45, 46; 45, 47; 46, identifier:hypervisor_prefix; 47, subscript; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:string; 50, identifier:ascii_lowercase; 51, identifier:i; 52, for_in_clause; 52, 53; 52, 54; 53, identifier:i; 54, call; 54, 55; 54, 56; 55, identifier:range; 56, argument_list; 56, 57; 56, 58; 57, integer:0; 58, integer:8; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:device_map; 62, dictionary_comprehension; 62, 63; 62, 68; 63, pair; 63, 64; 63, 67; 64, subscript; 64, 65; 64, 66; 65, identifier:device_names; 66, identifier:i; 67, None; 68, for_in_clause; 68, 69; 68, 70; 69, identifier:i; 70, call; 70, 71; 70, 72; 71, identifier:range; 72, argument_list; 72, 73; 72, 74; 73, integer:0; 74, call; 74, 75; 74, 76; 75, identifier:len; 76, argument_list; 76, 77; 77, identifier:device_names; 78, if_statement; 78, 79; 78, 85; 79, boolean_operator:and; 79, 80; 79, 81; 80, identifier:devices; 81, parenthesized_expression; 81, 82; 82, boolean_operator:or; 82, 83; 82, 84; 83, identifier:disks; 84, identifier:volumes; 85, block; 85, 86; 86, raise_statement; 86, 87; 87, call; 87, 88; 87, 89; 88, identifier:ValueError; 89, argument_list; 89, 90; 90, concatenated_string; 90, 91; 90, 92; 91, string:'You may not call config_create with "devices" and '; 92, string:'either of "disks" or "volumes" specified!'; 93, if_statement; 93, 94; 93, 96; 94, not_operator; 94, 95; 95, identifier:devices; 96, block; 96, 97; 96, 110; 96, 123; 96, 127; 96, 178; 97, if_statement; 97, 98; 97, 104; 98, not_operator; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:isinstance; 101, argument_list; 101, 102; 101, 103; 102, identifier:disks; 103, identifier:list; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:disks; 108, list:[disks]; 108, 109; 109, identifier:disks; 110, if_statement; 110, 111; 110, 117; 111, not_operator; 111, 112; 112, call; 112, 113; 112, 114; 113, identifier:isinstance; 114, argument_list; 114, 115; 114, 116; 115, identifier:volumes; 116, identifier:list; 117, block; 117, 118; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:volumes; 121, list:[volumes]; 121, 122; 122, identifier:volumes; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:devices; 126, list:[]; 127, for_statement; 127, 128; 127, 129; 127, 130; 128, identifier:d; 129, identifier:disks; 130, block; 130, 131; 131, if_statement; 131, 132; 131, 135; 131, 143; 131, 157; 132, comparison_operator:is; 132, 133; 132, 134; 133, identifier:d; 134, None; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:devices; 140, identifier:append; 141, argument_list; 141, 142; 142, None; 143, elif_clause; 143, 144; 143, 149; 144, call; 144, 145; 144, 146; 145, identifier:isinstance; 146, argument_list; 146, 147; 146, 148; 147, identifier:d; 148, identifier:Disk; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:devices; 154, identifier:append; 155, argument_list; 155, 156; 156, identifier:d; 157, else_clause; 157, 158; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:devices; 163, identifier:append; 164, argument_list; 164, 165; 165, call; 165, 166; 165, 167; 166, identifier:Disk; 167, argument_list; 167, 168; 167, 171; 167, 175; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:_client; 171, call; 171, 172; 171, 173; 172, identifier:int; 173, argument_list; 173, 174; 174, identifier:d; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:id; 178, for_statement; 178, 179; 178, 180; 178, 181; 179, identifier:v; 180, identifier:volumes; 181, block; 181, 182; 182, if_statement; 182, 183; 182, 186; 182, 194; 182, 208; 183, comparison_operator:is; 183, 184; 183, 185; 184, identifier:v; 185, None; 186, block; 186, 187; 187, expression_statement; 187, 188; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:devices; 191, identifier:append; 192, argument_list; 192, 193; 193, None; 194, elif_clause; 194, 195; 194, 200; 195, call; 195, 196; 195, 197; 196, identifier:isinstance; 197, argument_list; 197, 198; 197, 199; 198, identifier:v; 199, identifier:Volume; 200, block; 200, 201; 201, expression_statement; 201, 202; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:devices; 205, identifier:append; 206, argument_list; 206, 207; 207, identifier:v; 208, else_clause; 208, 209; 209, block; 209, 210; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:devices; 214, identifier:append; 215, argument_list; 215, 216; 216, call; 216, 217; 216, 218; 217, identifier:Volume; 218, argument_list; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:self; 221, identifier:_client; 222, call; 222, 223; 222, 224; 223, identifier:int; 224, argument_list; 224, 225; 225, identifier:v; 226, if_statement; 226, 227; 226, 229; 227, not_operator; 227, 228; 228, identifier:devices; 229, block; 229, 230; 230, raise_statement; 230, 231; 231, call; 231, 232; 231, 233; 232, identifier:ValueError; 233, argument_list; 233, 234; 234, string:'Must include at least one disk or volume!'; 235, for_statement; 235, 236; 235, 239; 235, 243; 236, pattern_list; 236, 237; 236, 238; 237, identifier:i; 238, identifier:d; 239, call; 239, 240; 239, 241; 240, identifier:enumerate; 241, argument_list; 241, 242; 242, identifier:devices; 243, block; 243, 244; 244, if_statement; 244, 245; 244, 248; 244, 250; 244, 270; 244, 290; 245, comparison_operator:is; 245, 246; 245, 247; 246, identifier:d; 247, None; 248, block; 248, 249; 249, pass_statement; 250, elif_clause; 250, 251; 250, 256; 251, call; 251, 252; 251, 253; 252, identifier:isinstance; 253, argument_list; 253, 254; 253, 255; 254, identifier:d; 255, identifier:Disk; 256, block; 256, 257; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 264; 259, subscript; 259, 260; 259, 261; 260, identifier:device_map; 261, subscript; 261, 262; 261, 263; 262, identifier:device_names; 263, identifier:i; 264, dictionary; 264, 265; 265, pair; 265, 266; 265, 267; 266, string:'disk_id'; 267, attribute; 267, 268; 267, 269; 268, identifier:d; 269, identifier:id; 270, elif_clause; 270, 271; 270, 276; 271, call; 271, 272; 271, 273; 272, identifier:isinstance; 273, argument_list; 273, 274; 273, 275; 274, identifier:d; 275, identifier:Volume; 276, block; 276, 277; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 284; 279, subscript; 279, 280; 279, 281; 280, identifier:device_map; 281, subscript; 281, 282; 281, 283; 282, identifier:device_names; 283, identifier:i; 284, dictionary; 284, 285; 285, pair; 285, 286; 285, 287; 286, string:'volume_id'; 287, attribute; 287, 288; 287, 289; 288, identifier:d; 289, identifier:id; 290, else_clause; 290, 291; 291, block; 291, 292; 292, raise_statement; 292, 293; 293, call; 293, 294; 293, 295; 294, identifier:TypeError; 295, argument_list; 295, 296; 296, string:'Disk or Volume expected!'; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 300; 299, identifier:params; 300, dictionary; 300, 301; 300, 316; 300, 335; 301, pair; 301, 302; 301, 303; 302, string:'kernel'; 303, conditional_expression:if; 303, 304; 303, 307; 303, 315; 304, attribute; 304, 305; 304, 306; 305, identifier:kernel; 306, identifier:id; 307, call; 307, 308; 307, 309; 308, identifier:issubclass; 309, argument_list; 309, 310; 309, 314; 310, call; 310, 311; 310, 312; 311, identifier:type; 312, argument_list; 312, 313; 313, identifier:kernel; 314, identifier:Base; 315, identifier:kernel; 316, pair; 316, 317; 316, 318; 317, string:'label'; 318, conditional_expression:if; 318, 319; 318, 320; 318, 321; 319, identifier:label; 320, identifier:label; 321, call; 321, 322; 321, 325; 322, attribute; 322, 323; 322, 324; 323, string:"{}_config_{}"; 324, identifier:format; 325, argument_list; 325, 326; 325, 329; 326, attribute; 326, 327; 326, 328; 327, identifier:self; 328, identifier:label; 329, call; 329, 330; 329, 331; 330, identifier:len; 331, argument_list; 331, 332; 332, attribute; 332, 333; 332, 334; 333, identifier:self; 334, identifier:configs; 335, pair; 335, 336; 335, 337; 336, string:'devices'; 337, identifier:device_map; 338, expression_statement; 338, 339; 339, call; 339, 340; 339, 343; 340, attribute; 340, 341; 340, 342; 341, identifier:params; 342, identifier:update; 343, argument_list; 343, 344; 344, identifier:kwargs; 345, expression_statement; 345, 346; 346, assignment; 346, 347; 346, 348; 347, identifier:result; 348, call; 348, 349; 348, 354; 349, attribute; 349, 350; 349, 353; 350, attribute; 350, 351; 350, 352; 351, identifier:self; 352, identifier:_client; 353, identifier:post; 354, argument_list; 354, 355; 354, 363; 354, 366; 355, call; 355, 356; 355, 359; 356, attribute; 356, 357; 356, 358; 357, string:"{}/configs"; 358, identifier:format; 359, argument_list; 359, 360; 360, attribute; 360, 361; 360, 362; 361, identifier:Instance; 362, identifier:api_endpoint; 363, keyword_argument; 363, 364; 363, 365; 364, identifier:model; 365, identifier:self; 366, keyword_argument; 366, 367; 366, 368; 367, identifier:data; 368, identifier:params; 369, expression_statement; 369, 370; 370, call; 370, 371; 370, 374; 371, attribute; 371, 372; 371, 373; 372, identifier:self; 373, identifier:invalidate; 374, argument_list; 375, if_statement; 375, 376; 375, 380; 376, not_operator; 376, 377; 377, comparison_operator:in; 377, 378; 377, 379; 378, string:'id'; 379, identifier:result; 380, block; 380, 381; 381, raise_statement; 381, 382; 382, call; 382, 383; 382, 384; 383, identifier:UnexpectedResponseError; 384, argument_list; 384, 385; 384, 386; 385, string:'Unexpected response creating config!'; 386, keyword_argument; 386, 387; 386, 388; 387, identifier:json; 388, identifier:result; 389, expression_statement; 389, 390; 390, assignment; 390, 391; 390, 392; 391, identifier:c; 392, call; 392, 393; 392, 394; 393, identifier:Config; 394, argument_list; 394, 395; 394, 398; 394, 401; 394, 404; 395, attribute; 395, 396; 395, 397; 396, identifier:self; 397, identifier:_client; 398, subscript; 398, 399; 398, 400; 399, identifier:result; 400, string:'id'; 401, attribute; 401, 402; 401, 403; 402, identifier:self; 403, identifier:id; 404, identifier:result; 405, return_statement; 405, 406; 406, identifier:c | def config_create(self, kernel=None, label=None, devices=[], disks=[],
volumes=[], **kwargs):
from .volume import Volume
hypervisor_prefix = 'sd' if self.hypervisor == 'kvm' else 'xvd'
device_names = [hypervisor_prefix + string.ascii_lowercase[i] for i in range(0, 8)]
device_map = {device_names[i]: None for i in range(0, len(device_names))}
if devices and (disks or volumes):
raise ValueError('You may not call config_create with "devices" and '
'either of "disks" or "volumes" specified!')
if not devices:
if not isinstance(disks, list):
disks = [disks]
if not isinstance(volumes, list):
volumes = [volumes]
devices = []
for d in disks:
if d is None:
devices.append(None)
elif isinstance(d, Disk):
devices.append(d)
else:
devices.append(Disk(self._client, int(d), self.id))
for v in volumes:
if v is None:
devices.append(None)
elif isinstance(v, Volume):
devices.append(v)
else:
devices.append(Volume(self._client, int(v)))
if not devices:
raise ValueError('Must include at least one disk or volume!')
for i, d in enumerate(devices):
if d is None:
pass
elif isinstance(d, Disk):
device_map[device_names[i]] = {'disk_id': d.id }
elif isinstance(d, Volume):
device_map[device_names[i]] = {'volume_id': d.id }
else:
raise TypeError('Disk or Volume expected!')
params = {
'kernel': kernel.id if issubclass(type(kernel), Base) else kernel,
'label': label if label else "{}_config_{}".format(self.label, len(self.configs)),
'devices': device_map,
}
params.update(kwargs)
result = self._client.post("{}/configs".format(Instance.api_endpoint), model=self, data=params)
self.invalidate()
if not 'id' in result:
raise UnexpectedResponseError('Unexpected response creating config!', json=result)
c = Config(self._client, result['id'], self.id, result)
return c |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 29; 2, function_name:clone; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:to_linode; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:region; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:service; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:configs; 16, list:[]; 17, default_parameter; 17, 18; 17, 19; 18, identifier:disks; 19, list:[]; 20, default_parameter; 20, 21; 20, 22; 21, identifier:label; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:group; 25, None; 26, default_parameter; 26, 27; 26, 28; 27, identifier:with_backups; 28, None; 29, block; 29, 30; 29, 40; 29, 51; 29, 71; 29, 91; 29, 111; 29, 131; 29, 201; 29, 225; 29, 239; 29, 252; 30, if_statement; 30, 31; 30, 34; 31, boolean_operator:and; 31, 32; 31, 33; 32, identifier:to_linode; 33, identifier:region; 34, block; 34, 35; 35, raise_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:ValueError; 38, argument_list; 38, 39; 39, string:'You may only specify one of "to_linode" and "region"'; 40, if_statement; 40, 41; 40, 45; 41, boolean_operator:and; 41, 42; 41, 43; 42, identifier:region; 43, not_operator; 43, 44; 44, identifier:service; 45, block; 45, 46; 46, raise_statement; 46, 47; 47, call; 47, 48; 47, 49; 48, identifier:ValueError; 49, argument_list; 49, 50; 50, string:'Specifying a region requires a "service" as well'; 51, if_statement; 51, 52; 51, 65; 52, boolean_operator:and; 52, 53; 52, 59; 53, not_operator; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:isinstance; 56, argument_list; 56, 57; 56, 58; 57, identifier:configs; 58, identifier:list; 59, not_operator; 59, 60; 60, call; 60, 61; 60, 62; 61, identifier:isinstance; 62, argument_list; 62, 63; 62, 64; 63, identifier:configs; 64, identifier:PaginatedList; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:configs; 69, list:[configs]; 69, 70; 70, identifier:configs; 71, if_statement; 71, 72; 71, 85; 72, boolean_operator:and; 72, 73; 72, 79; 73, not_operator; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:isinstance; 76, argument_list; 76, 77; 76, 78; 77, identifier:disks; 78, identifier:list; 79, not_operator; 79, 80; 80, call; 80, 81; 80, 82; 81, identifier:isinstance; 82, argument_list; 82, 83; 82, 84; 83, identifier:disks; 84, identifier:PaginatedList; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:disks; 89, list:[disks]; 89, 90; 90, identifier:disks; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:cids; 94, list_comprehension; 94, 95; 94, 108; 95, conditional_expression:if; 95, 96; 95, 99; 95, 107; 96, attribute; 96, 97; 96, 98; 97, identifier:c; 98, identifier:id; 99, call; 99, 100; 99, 101; 100, identifier:issubclass; 101, argument_list; 101, 102; 101, 106; 102, call; 102, 103; 102, 104; 103, identifier:type; 104, argument_list; 104, 105; 105, identifier:c; 106, identifier:Base; 107, identifier:c; 108, for_in_clause; 108, 109; 108, 110; 109, identifier:c; 110, identifier:configs; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:dids; 114, list_comprehension; 114, 115; 114, 128; 115, conditional_expression:if; 115, 116; 115, 119; 115, 127; 116, attribute; 116, 117; 116, 118; 117, identifier:d; 118, identifier:id; 119, call; 119, 120; 119, 121; 120, identifier:issubclass; 121, argument_list; 121, 122; 121, 126; 122, call; 122, 123; 122, 124; 123, identifier:type; 124, argument_list; 124, 125; 125, identifier:d; 126, identifier:Base; 127, identifier:d; 128, for_in_clause; 128, 129; 128, 130; 129, identifier:d; 130, identifier:disks; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:params; 134, dictionary; 134, 135; 134, 150; 134, 165; 134, 180; 134, 186; 134, 192; 134, 195; 134, 198; 135, pair; 135, 136; 135, 137; 136, string:"linode_id"; 137, conditional_expression:if; 137, 138; 137, 141; 137, 149; 138, attribute; 138, 139; 138, 140; 139, identifier:to_linode; 140, identifier:id; 141, call; 141, 142; 141, 143; 142, identifier:issubclass; 143, argument_list; 143, 144; 143, 148; 144, call; 144, 145; 144, 146; 145, identifier:type; 146, argument_list; 146, 147; 147, identifier:to_linode; 148, identifier:Base; 149, identifier:to_linode; 150, pair; 150, 151; 150, 152; 151, string:"region"; 152, conditional_expression:if; 152, 153; 152, 156; 152, 164; 153, attribute; 153, 154; 153, 155; 154, identifier:region; 155, identifier:id; 156, call; 156, 157; 156, 158; 157, identifier:issubclass; 158, argument_list; 158, 159; 158, 163; 159, call; 159, 160; 159, 161; 160, identifier:type; 161, argument_list; 161, 162; 162, identifier:region; 163, identifier:Base; 164, identifier:region; 165, pair; 165, 166; 165, 167; 166, string:"type"; 167, conditional_expression:if; 167, 168; 167, 171; 167, 179; 168, attribute; 168, 169; 168, 170; 169, identifier:service; 170, identifier:id; 171, call; 171, 172; 171, 173; 172, identifier:issubclass; 173, argument_list; 173, 174; 173, 178; 174, call; 174, 175; 174, 176; 175, identifier:type; 176, argument_list; 176, 177; 177, identifier:service; 178, identifier:Base; 179, identifier:service; 180, pair; 180, 181; 180, 182; 181, string:"configs"; 182, conditional_expression:if; 182, 183; 182, 184; 182, 185; 183, identifier:cids; 184, identifier:cids; 185, None; 186, pair; 186, 187; 186, 188; 187, string:"disks"; 188, conditional_expression:if; 188, 189; 188, 190; 188, 191; 189, identifier:dids; 190, identifier:dids; 191, None; 192, pair; 192, 193; 192, 194; 193, string:"label"; 194, identifier:label; 195, pair; 195, 196; 195, 197; 196, string:"group"; 197, identifier:group; 198, pair; 198, 199; 198, 200; 199, string:"with_backups"; 200, identifier:with_backups; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:result; 204, call; 204, 205; 204, 210; 205, attribute; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:self; 208, identifier:_client; 209, identifier:post; 210, argument_list; 210, 211; 210, 219; 210, 222; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, string:'{}/clone'; 214, identifier:format; 215, argument_list; 215, 216; 216, attribute; 216, 217; 216, 218; 217, identifier:Instance; 218, identifier:api_endpoint; 219, keyword_argument; 219, 220; 219, 221; 220, identifier:model; 221, identifier:self; 222, keyword_argument; 222, 223; 222, 224; 223, identifier:data; 224, identifier:params; 225, if_statement; 225, 226; 225, 230; 226, not_operator; 226, 227; 227, comparison_operator:in; 227, 228; 227, 229; 228, string:'id'; 229, identifier:result; 230, block; 230, 231; 231, raise_statement; 231, 232; 232, call; 232, 233; 232, 234; 233, identifier:UnexpectedResponseError; 234, argument_list; 234, 235; 234, 236; 235, string:'Unexpected response cloning Instance!'; 236, keyword_argument; 236, 237; 236, 238; 237, identifier:json; 238, identifier:result; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 242; 241, identifier:l; 242, call; 242, 243; 242, 244; 243, identifier:Instance; 244, argument_list; 244, 245; 244, 248; 244, 251; 245, attribute; 245, 246; 245, 247; 246, identifier:self; 247, identifier:_client; 248, subscript; 248, 249; 248, 250; 249, identifier:result; 250, string:'id'; 251, identifier:result; 252, return_statement; 252, 253; 253, identifier:l | def clone(self, to_linode=None, region=None, service=None, configs=[], disks=[],
label=None, group=None, with_backups=None):
if to_linode and region:
raise ValueError('You may only specify one of "to_linode" and "region"')
if region and not service:
raise ValueError('Specifying a region requires a "service" as well')
if not isinstance(configs, list) and not isinstance(configs, PaginatedList):
configs = [configs]
if not isinstance(disks, list) and not isinstance(disks, PaginatedList):
disks = [disks]
cids = [ c.id if issubclass(type(c), Base) else c for c in configs ]
dids = [ d.id if issubclass(type(d), Base) else d for d in disks ]
params = {
"linode_id": to_linode.id if issubclass(type(to_linode), Base) else to_linode,
"region": region.id if issubclass(type(region), Base) else region,
"type": service.id if issubclass(type(service), Base) else service,
"configs": cids if cids else None,
"disks": dids if dids else None,
"label": label,
"group": group,
"with_backups": with_backups,
}
result = self._client.post('{}/clone'.format(Instance.api_endpoint), model=self, data=params)
if not 'id' in result:
raise UnexpectedResponseError('Unexpected response cloning Instance!', json=result)
l = Instance(self._client, result['id'], result)
return l |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_populate; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:json; 6, block; 6, 7; 6, 12; 6, 20; 6, 404; 6, 412; 7, if_statement; 7, 8; 7, 10; 8, not_operator; 8, 9; 9, identifier:json; 10, block; 10, 11; 11, return_statement; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_set; 17, argument_list; 17, 18; 17, 19; 18, string:'_raw_json'; 19, identifier:json; 20, for_statement; 20, 21; 20, 22; 20, 23; 21, identifier:key; 22, identifier:json; 23, block; 23, 24; 24, if_statement; 24, 25; 24, 53; 25, comparison_operator:in; 25, 26; 25, 27; 26, identifier:key; 27, generator_expression; 27, 28; 27, 29; 27, 41; 28, identifier:k; 29, for_in_clause; 29, 30; 29, 31; 30, identifier:k; 31, call; 31, 32; 31, 40; 32, attribute; 32, 33; 32, 39; 33, attribute; 33, 34; 33, 38; 34, call; 34, 35; 34, 36; 35, identifier:type; 36, argument_list; 36, 37; 37, identifier:self; 38, identifier:properties; 39, identifier:keys; 40, argument_list; 41, if_clause; 41, 42; 42, not_operator; 42, 43; 43, attribute; 43, 44; 43, 52; 44, subscript; 44, 45; 44, 51; 45, attribute; 45, 46; 45, 50; 46, call; 46, 47; 46, 48; 47, identifier:type; 48, argument_list; 48, 49; 49, identifier:self; 50, identifier:properties; 51, identifier:k; 52, identifier:identifier; 53, block; 53, 54; 54, if_statement; 54, 55; 54, 73; 54, 236; 54, 281; 54, 305; 54, 336; 54, 392; 55, boolean_operator:and; 55, 56; 55, 66; 55, 67; 56, attribute; 56, 57; 56, 65; 57, subscript; 57, 58; 57, 64; 58, attribute; 58, 59; 58, 63; 59, call; 59, 60; 59, 61; 60, identifier:type; 61, argument_list; 61, 62; 62, identifier:self; 63, identifier:properties; 64, identifier:key; 65, identifier:relationship; 66, line_continuation:\; 67, not_operator; 67, 68; 68, comparison_operator:is; 68, 69; 68, 72; 69, subscript; 69, 70; 69, 71; 70, identifier:json; 71, identifier:key; 72, None; 73, block; 73, 74; 74, if_statement; 74, 75; 74, 82; 74, 154; 75, call; 75, 76; 75, 77; 76, identifier:isinstance; 77, argument_list; 77, 78; 77, 81; 78, subscript; 78, 79; 78, 80; 79, identifier:json; 80, identifier:key; 81, identifier:list; 82, block; 82, 83; 82, 87; 82, 146; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:objs; 86, list:[]; 87, for_statement; 87, 88; 87, 89; 87, 92; 88, identifier:d; 89, subscript; 89, 90; 89, 91; 90, identifier:json; 91, identifier:key; 92, block; 92, 93; 92, 100; 92, 113; 92, 129; 92, 139; 93, if_statement; 93, 94; 93, 98; 94, not_operator; 94, 95; 95, comparison_operator:in; 95, 96; 95, 97; 96, string:'id'; 97, identifier:d; 98, block; 98, 99; 99, continue_statement; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:new_class; 103, attribute; 103, 104; 103, 112; 104, subscript; 104, 105; 104, 111; 105, attribute; 105, 106; 105, 110; 106, call; 106, 107; 106, 108; 107, identifier:type; 108, argument_list; 108, 109; 109, identifier:self; 110, identifier:properties; 111, identifier:key; 112, identifier:relationship; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:obj; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:new_class; 119, identifier:make_instance; 120, argument_list; 120, 121; 120, 124; 121, subscript; 121, 122; 121, 123; 122, identifier:d; 123, string:'id'; 124, call; 124, 125; 124, 126; 125, identifier:getattr; 126, argument_list; 126, 127; 126, 128; 127, identifier:self; 128, string:'_client'; 129, if_statement; 129, 130; 129, 131; 130, identifier:obj; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:obj; 136, identifier:_populate; 137, argument_list; 137, 138; 138, identifier:d; 139, expression_statement; 139, 140; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:objs; 143, identifier:append; 144, argument_list; 144, 145; 145, identifier:obj; 146, expression_statement; 146, 147; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:self; 150, identifier:_set; 151, argument_list; 151, 152; 151, 153; 152, identifier:key; 153, identifier:objs; 154, else_clause; 154, 155; 155, block; 155, 156; 155, 181; 155, 194; 155, 208; 155, 228; 156, if_statement; 156, 157; 156, 164; 156, 173; 157, call; 157, 158; 157, 159; 158, identifier:isinstance; 159, argument_list; 159, 160; 159, 163; 160, subscript; 160, 161; 160, 162; 161, identifier:json; 162, identifier:key; 163, identifier:dict; 164, block; 164, 165; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:related_id; 168, subscript; 168, 169; 168, 172; 169, subscript; 169, 170; 169, 171; 170, identifier:json; 171, identifier:key; 172, string:'id'; 173, else_clause; 173, 174; 174, block; 174, 175; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:related_id; 178, subscript; 178, 179; 178, 180; 179, identifier:json; 180, identifier:key; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:new_class; 184, attribute; 184, 185; 184, 193; 185, subscript; 185, 186; 185, 192; 186, attribute; 186, 187; 186, 191; 187, call; 187, 188; 187, 189; 188, identifier:type; 189, argument_list; 189, 190; 190, identifier:self; 191, identifier:properties; 192, identifier:key; 193, identifier:relationship; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:obj; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:new_class; 200, identifier:make_instance; 201, argument_list; 201, 202; 201, 203; 202, identifier:related_id; 203, call; 203, 204; 203, 205; 204, identifier:getattr; 205, argument_list; 205, 206; 205, 207; 206, identifier:self; 207, string:'_client'; 208, if_statement; 208, 209; 208, 218; 209, boolean_operator:and; 209, 210; 209, 211; 210, identifier:obj; 211, call; 211, 212; 211, 213; 212, identifier:isinstance; 213, argument_list; 213, 214; 213, 217; 214, subscript; 214, 215; 214, 216; 215, identifier:json; 216, identifier:key; 217, identifier:dict; 218, block; 218, 219; 219, expression_statement; 219, 220; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:obj; 223, identifier:_populate; 224, argument_list; 224, 225; 225, subscript; 225, 226; 225, 227; 226, identifier:json; 227, identifier:key; 228, expression_statement; 228, 229; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:self; 232, identifier:_set; 233, argument_list; 233, 234; 233, 235; 234, identifier:key; 235, identifier:obj; 236, elif_clause; 236, 237; 236, 255; 237, boolean_operator:and; 237, 238; 237, 248; 237, 249; 238, attribute; 238, 239; 238, 247; 239, subscript; 239, 240; 239, 246; 240, attribute; 240, 241; 240, 245; 241, call; 241, 242; 241, 243; 242, identifier:type; 243, argument_list; 243, 244; 244, identifier:self; 245, identifier:properties; 246, identifier:key; 247, identifier:slug_relationship; 248, line_continuation:\; 249, not_operator; 249, 250; 250, comparison_operator:is; 250, 251; 250, 254; 251, subscript; 251, 252; 251, 253; 252, identifier:json; 253, identifier:key; 254, None; 255, block; 255, 256; 256, expression_statement; 256, 257; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:self; 260, identifier:_set; 261, argument_list; 261, 262; 261, 263; 262, identifier:key; 263, call; 263, 264; 263, 274; 264, attribute; 264, 265; 264, 273; 265, subscript; 265, 266; 265, 272; 266, attribute; 266, 267; 266, 271; 267, call; 267, 268; 267, 269; 268, identifier:type; 269, argument_list; 269, 270; 270, identifier:self; 271, identifier:properties; 272, identifier:key; 273, identifier:slug_relationship; 274, argument_list; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:self; 277, identifier:_client; 278, subscript; 278, 279; 278, 280; 279, identifier:json; 280, identifier:key; 281, elif_clause; 281, 282; 281, 290; 282, comparison_operator:is; 282, 283; 282, 289; 283, call; 283, 284; 283, 285; 284, identifier:type; 285, argument_list; 285, 286; 286, subscript; 286, 287; 286, 288; 287, identifier:json; 288, identifier:key; 289, identifier:dict; 290, block; 290, 291; 291, expression_statement; 291, 292; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:self; 295, identifier:_set; 296, argument_list; 296, 297; 296, 298; 297, identifier:key; 298, call; 298, 299; 298, 300; 299, identifier:MappedObject; 300, argument_list; 300, 301; 301, dictionary_splat; 301, 302; 302, subscript; 302, 303; 302, 304; 303, identifier:json; 304, identifier:key; 305, elif_clause; 305, 306; 305, 314; 306, comparison_operator:is; 306, 307; 306, 313; 307, call; 307, 308; 307, 309; 308, identifier:type; 309, argument_list; 309, 310; 310, subscript; 310, 311; 310, 312; 311, identifier:json; 312, identifier:key; 313, identifier:list; 314, block; 314, 315; 314, 326; 315, expression_statement; 315, 316; 316, assignment; 316, 317; 316, 318; 317, identifier:mapping; 318, call; 318, 319; 318, 320; 319, identifier:MappedObject; 320, argument_list; 320, 321; 321, keyword_argument; 321, 322; 321, 323; 322, identifier:_list; 323, subscript; 323, 324; 323, 325; 324, identifier:json; 325, identifier:key; 326, expression_statement; 326, 327; 327, call; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:self; 330, identifier:_set; 331, argument_list; 331, 332; 331, 333; 332, identifier:key; 333, attribute; 333, 334; 333, 335; 334, identifier:mapping; 335, identifier:_list; 336, elif_clause; 336, 337; 336, 347; 337, attribute; 337, 338; 337, 346; 338, subscript; 338, 339; 338, 345; 339, attribute; 339, 340; 339, 344; 340, call; 340, 341; 340, 342; 341, identifier:type; 342, argument_list; 342, 343; 343, identifier:self; 344, identifier:properties; 345, identifier:key; 346, identifier:is_datetime; 347, block; 347, 348; 348, try_statement; 348, 349; 348, 380; 349, block; 349, 350; 349, 362; 350, expression_statement; 350, 351; 351, assignment; 351, 352; 351, 353; 352, identifier:t; 353, call; 353, 354; 353, 357; 354, attribute; 354, 355; 354, 356; 355, identifier:time; 356, identifier:strptime; 357, argument_list; 357, 358; 357, 361; 358, subscript; 358, 359; 358, 360; 359, identifier:json; 360, identifier:key; 361, identifier:DATE_FORMAT; 362, expression_statement; 362, 363; 363, call; 363, 364; 363, 367; 364, attribute; 364, 365; 364, 366; 365, identifier:self; 366, identifier:_set; 367, argument_list; 367, 368; 367, 369; 368, identifier:key; 369, call; 369, 370; 369, 373; 370, attribute; 370, 371; 370, 372; 371, identifier:datetime; 372, identifier:fromtimestamp; 373, argument_list; 373, 374; 374, call; 374, 375; 374, 378; 375, attribute; 375, 376; 375, 377; 376, identifier:time; 377, identifier:mktime; 378, argument_list; 378, 379; 379, identifier:t; 380, except_clause; 380, 381; 381, block; 381, 382; 382, expression_statement; 382, 383; 383, call; 383, 384; 383, 387; 384, attribute; 384, 385; 384, 386; 385, identifier:self; 386, identifier:_set; 387, argument_list; 387, 388; 387, 389; 388, identifier:key; 389, subscript; 389, 390; 389, 391; 390, identifier:json; 391, identifier:key; 392, else_clause; 392, 393; 393, block; 393, 394; 394, expression_statement; 394, 395; 395, call; 395, 396; 395, 399; 396, attribute; 396, 397; 396, 398; 397, identifier:self; 398, identifier:_set; 399, argument_list; 399, 400; 399, 401; 400, identifier:key; 401, subscript; 401, 402; 401, 403; 402, identifier:json; 403, identifier:key; 404, expression_statement; 404, 405; 405, call; 405, 406; 405, 409; 406, attribute; 406, 407; 406, 408; 407, identifier:self; 408, identifier:_set; 409, argument_list; 409, 410; 409, 411; 410, string:'_populated'; 411, True; 412, expression_statement; 412, 413; 413, call; 413, 414; 413, 417; 414, attribute; 414, 415; 414, 416; 415, identifier:self; 416, identifier:_set; 417, argument_list; 417, 418; 417, 419; 418, string:'_last_updated'; 419, call; 419, 420; 419, 423; 420, attribute; 420, 421; 420, 422; 421, identifier:datetime; 422, identifier:now; 423, argument_list | def _populate(self, json):
if not json:
return
self._set('_raw_json', json)
for key in json:
if key in (k for k in type(self).properties.keys()
if not type(self).properties[k].identifier):
if type(self).properties[key].relationship \
and not json[key] is None:
if isinstance(json[key], list):
objs = []
for d in json[key]:
if not 'id' in d:
continue
new_class = type(self).properties[key].relationship
obj = new_class.make_instance(d['id'],
getattr(self,'_client'))
if obj:
obj._populate(d)
objs.append(obj)
self._set(key, objs)
else:
if isinstance(json[key], dict):
related_id = json[key]['id']
else:
related_id = json[key]
new_class = type(self).properties[key].relationship
obj = new_class.make_instance(related_id, getattr(self,'_client'))
if obj and isinstance(json[key], dict):
obj._populate(json[key])
self._set(key, obj)
elif type(self).properties[key].slug_relationship \
and not json[key] is None:
self._set(key, type(self).properties[key].slug_relationship(self._client, json[key]))
elif type(json[key]) is dict:
self._set(key, MappedObject(**json[key]))
elif type(json[key]) is list:
mapping = MappedObject(_list=json[key])
self._set(key, mapping._list)
elif type(self).properties[key].is_datetime:
try:
t = time.strptime(json[key], DATE_FORMAT)
self._set(key, datetime.fromtimestamp(time.mktime(t)))
except:
self._set(key, json[key])
else:
self._set(key, json[key])
self._set('_populated', True)
self._set('_last_updated', datetime.now()) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:_api_call; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:self; 5, identifier:endpoint; 6, default_parameter; 6, 7; 6, 8; 7, identifier:model; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:method; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:data; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:filters; 17, None; 18, block; 18, 19; 18, 30; 18, 39; 18, 55; 18, 67; 18, 89; 18, 103; 18, 107; 18, 121; 18, 134; 18, 146; 18, 161; 18, 246; 18, 267; 19, if_statement; 19, 20; 19, 24; 20, not_operator; 20, 21; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:token; 24, block; 24, 25; 25, raise_statement; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:RuntimeError; 28, argument_list; 28, 29; 29, string:"You do not have an API token!"; 30, if_statement; 30, 31; 30, 33; 31, not_operator; 31, 32; 32, identifier:method; 33, block; 33, 34; 34, raise_statement; 34, 35; 35, call; 35, 36; 35, 37; 36, identifier:ValueError; 37, argument_list; 37, 38; 38, string:"Method is required for API calls!"; 39, if_statement; 39, 40; 39, 41; 40, identifier:model; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:endpoint; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:endpoint; 48, identifier:format; 49, argument_list; 49, 50; 50, dictionary_splat; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:vars; 53, argument_list; 53, 54; 54, identifier:model; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:url; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, string:'{}{}'; 61, identifier:format; 62, argument_list; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:base_url; 66, identifier:endpoint; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:headers; 70, dictionary; 70, 71; 70, 81; 70, 84; 71, pair; 71, 72; 71, 73; 72, string:'Authorization'; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, string:"Bearer {}"; 76, identifier:format; 77, argument_list; 77, 78; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:token; 81, pair; 81, 82; 81, 83; 82, string:'Content-Type'; 83, string:'application/json'; 84, pair; 84, 85; 84, 86; 85, string:'User-Agent'; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:_user_agent; 89, if_statement; 89, 90; 89, 91; 90, identifier:filters; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 97; 94, subscript; 94, 95; 94, 96; 95, identifier:headers; 96, string:'X-Filter'; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:json; 100, identifier:dumps; 101, argument_list; 101, 102; 102, identifier:filters; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:body; 106, None; 107, if_statement; 107, 108; 107, 111; 108, comparison_operator:is; 108, 109; 108, 110; 109, identifier:data; 110, None; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:body; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:json; 118, identifier:dumps; 119, argument_list; 119, 120; 120, identifier:data; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:response; 124, call; 124, 125; 124, 126; 125, identifier:method; 126, argument_list; 126, 127; 126, 128; 126, 131; 127, identifier:url; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:headers; 130, identifier:headers; 131, keyword_argument; 131, 132; 131, 133; 132, identifier:data; 133, identifier:body; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:warning; 137, call; 137, 138; 137, 143; 138, attribute; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:response; 141, identifier:headers; 142, identifier:get; 143, argument_list; 143, 144; 143, 145; 144, string:'Warning'; 145, None; 146, if_statement; 146, 147; 146, 148; 147, identifier:warning; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:logger; 153, identifier:warning; 154, argument_list; 154, 155; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, string:'Received warning from server: {}'; 158, identifier:format; 159, argument_list; 159, 160; 160, identifier:warning; 161, if_statement; 161, 162; 161, 168; 162, comparison_operator:<; 162, 163; 162, 164; 162, 167; 163, integer:399; 164, attribute; 164, 165; 164, 166; 165, identifier:response; 166, identifier:status_code; 167, integer:600; 168, block; 168, 169; 168, 173; 168, 184; 168, 233; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:j; 172, None; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:error_msg; 176, call; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, string:'{}: '; 179, identifier:format; 180, argument_list; 180, 181; 181, attribute; 181, 182; 181, 183; 182, identifier:response; 183, identifier:status_code; 184, try_statement; 184, 185; 184, 230; 185, block; 185, 186; 185, 194; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:j; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:response; 192, identifier:json; 193, argument_list; 194, if_statement; 194, 195; 194, 202; 195, comparison_operator:in; 195, 196; 195, 197; 196, string:'errors'; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:j; 200, identifier:keys; 201, argument_list; 202, block; 202, 203; 203, for_statement; 203, 204; 203, 205; 203, 208; 204, identifier:e; 205, subscript; 205, 206; 205, 207; 206, identifier:j; 207, string:'errors'; 208, block; 208, 209; 209, expression_statement; 209, 210; 210, augmented_assignment:+=; 210, 211; 210, 212; 211, identifier:error_msg; 212, conditional_expression:if; 212, 213; 212, 221; 212, 222; 212, 229; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, string:'{}; '; 216, identifier:format; 217, argument_list; 217, 218; 218, subscript; 218, 219; 218, 220; 219, identifier:e; 220, string:'reason'; 221, line_continuation:\; 222, comparison_operator:in; 222, 223; 222, 224; 223, string:'reason'; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:e; 227, identifier:keys; 228, argument_list; 229, string:''; 230, except_clause; 230, 231; 231, block; 231, 232; 232, pass_statement; 233, raise_statement; 233, 234; 234, call; 234, 235; 234, 236; 235, identifier:ApiError; 236, argument_list; 236, 237; 236, 238; 236, 243; 237, identifier:error_msg; 238, keyword_argument; 238, 239; 238, 240; 239, identifier:status; 240, attribute; 240, 241; 240, 242; 241, identifier:response; 242, identifier:status_code; 243, keyword_argument; 243, 244; 243, 245; 244, identifier:json; 245, identifier:j; 246, if_statement; 246, 247; 246, 252; 246, 261; 247, comparison_operator:!=; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:response; 250, identifier:status_code; 251, integer:204; 252, block; 252, 253; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:j; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:response; 259, identifier:json; 260, argument_list; 261, else_clause; 261, 262; 262, block; 262, 263; 263, expression_statement; 263, 264; 264, assignment; 264, 265; 264, 266; 265, identifier:j; 266, None; 267, return_statement; 267, 268; 268, identifier:j | def _api_call(self, endpoint, model=None, method=None, data=None, filters=None):
if not self.token:
raise RuntimeError("You do not have an API token!")
if not method:
raise ValueError("Method is required for API calls!")
if model:
endpoint = endpoint.format(**vars(model))
url = '{}{}'.format(self.base_url, endpoint)
headers = {
'Authorization': "Bearer {}".format(self.token),
'Content-Type': 'application/json',
'User-Agent': self._user_agent,
}
if filters:
headers['X-Filter'] = json.dumps(filters)
body = None
if data is not None:
body = json.dumps(data)
response = method(url, headers=headers, data=body)
warning = response.headers.get('Warning', None)
if warning:
logger.warning('Received warning from server: {}'.format(warning))
if 399 < response.status_code < 600:
j = None
error_msg = '{}: '.format(response.status_code)
try:
j = response.json()
if 'errors' in j.keys():
for e in j['errors']:
error_msg += '{}; '.format(e['reason']) \
if 'reason' in e.keys() else ''
except:
pass
raise ApiError(error_msg, status=response.status_code, json=j)
if response.status_code != 204:
j = response.json()
else:
j = None
return j |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:tag_create; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:self; 5, identifier:label; 6, default_parameter; 6, 7; 6, 8; 7, identifier:instances; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:domains; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:nodebalancers; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:volumes; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:entities; 20, list:[]; 21, block; 21, 22; 21, 34; 21, 50; 21, 90; 21, 106; 21, 147; 21, 174; 21, 186; 21, 200; 21, 211; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 29; 24, pattern_list; 24, 25; 24, 26; 24, 27; 24, 28; 25, identifier:linode_ids; 26, identifier:nodebalancer_ids; 27, identifier:domain_ids; 28, identifier:volume_ids; 29, expression_list; 29, 30; 29, 31; 29, 32; 29, 33; 30, list:[]; 31, list:[]; 32, list:[]; 33, list:[]; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:sorter; 37, call; 37, 38; 37, 39; 38, identifier:zip; 39, argument_list; 39, 40; 39, 45; 40, tuple; 40, 41; 40, 42; 40, 43; 40, 44; 41, identifier:linode_ids; 42, identifier:nodebalancer_ids; 43, identifier:domain_ids; 44, identifier:volume_ids; 45, tuple; 45, 46; 45, 47; 45, 48; 45, 49; 46, identifier:instances; 47, identifier:nodebalancers; 48, identifier:domains; 49, identifier:volumes; 50, for_statement; 50, 51; 50, 54; 50, 55; 51, pattern_list; 51, 52; 51, 53; 52, identifier:id_list; 53, identifier:input_list; 54, identifier:sorter; 55, block; 55, 56; 56, if_statement; 56, 57; 56, 60; 57, comparison_operator:is; 57, 58; 57, 59; 58, identifier:input_list; 59, None; 60, block; 60, 61; 61, for_statement; 61, 62; 61, 63; 61, 64; 62, identifier:cur; 63, identifier:input_list; 64, block; 64, 65; 65, if_statement; 65, 66; 65, 71; 65, 79; 66, call; 66, 67; 66, 68; 67, identifier:isinstance; 68, argument_list; 68, 69; 68, 70; 69, identifier:cur; 70, identifier:int; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:id_list; 76, identifier:append; 77, argument_list; 77, 78; 78, identifier:cur; 79, else_clause; 79, 80; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:id_list; 85, identifier:append; 86, argument_list; 86, 87; 87, attribute; 87, 88; 87, 89; 88, identifier:cur; 89, identifier:id; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:type_map; 93, dictionary; 93, 94; 93, 97; 93, 100; 93, 103; 94, pair; 94, 95; 94, 96; 95, identifier:Instance; 96, identifier:linode_ids; 97, pair; 97, 98; 97, 99; 98, identifier:NodeBalancer; 99, identifier:nodebalancer_ids; 100, pair; 100, 101; 100, 102; 101, identifier:Domain; 102, identifier:domain_ids; 103, pair; 103, 104; 103, 105; 104, identifier:Volume; 105, identifier:volume_ids; 106, for_statement; 106, 107; 106, 108; 106, 109; 107, identifier:e; 108, identifier:entities; 109, block; 109, 110; 110, if_statement; 110, 111; 110, 117; 110, 132; 111, comparison_operator:in; 111, 112; 111, 116; 112, call; 112, 113; 112, 114; 113, identifier:type; 114, argument_list; 114, 115; 115, identifier:e; 116, identifier:type_map; 117, block; 117, 118; 118, expression_statement; 118, 119; 119, call; 119, 120; 119, 128; 120, attribute; 120, 121; 120, 127; 121, subscript; 121, 122; 121, 123; 122, identifier:type_map; 123, call; 123, 124; 123, 125; 124, identifier:type; 125, argument_list; 125, 126; 126, identifier:e; 127, identifier:append; 128, argument_list; 128, 129; 129, attribute; 129, 130; 129, 131; 130, identifier:e; 131, identifier:id; 132, else_clause; 132, 133; 133, block; 133, 134; 134, raise_statement; 134, 135; 135, call; 135, 136; 135, 137; 136, identifier:ValueError; 137, argument_list; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, string:'Unsupported entity type {}'; 141, identifier:format; 142, argument_list; 142, 143; 143, call; 143, 144; 143, 145; 144, identifier:type; 145, argument_list; 145, 146; 146, identifier:e; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:params; 150, dictionary; 150, 151; 150, 154; 150, 159; 150, 164; 150, 169; 151, pair; 151, 152; 151, 153; 152, string:'label'; 153, identifier:label; 154, pair; 154, 155; 154, 156; 155, string:'linodes'; 156, boolean_operator:or; 156, 157; 156, 158; 157, identifier:linode_ids; 158, None; 159, pair; 159, 160; 159, 161; 160, string:'nodebalancers'; 161, boolean_operator:or; 161, 162; 161, 163; 162, identifier:nodebalancer_ids; 163, None; 164, pair; 164, 165; 164, 166; 165, string:'domains'; 166, boolean_operator:or; 166, 167; 166, 168; 167, identifier:domain_ids; 168, None; 169, pair; 169, 170; 169, 171; 170, string:'volumes'; 171, boolean_operator:or; 171, 172; 171, 173; 172, identifier:volume_ids; 173, None; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:result; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:self; 180, identifier:post; 181, argument_list; 181, 182; 181, 183; 182, string:'/tags'; 183, keyword_argument; 183, 184; 183, 185; 184, identifier:data; 185, identifier:params; 186, if_statement; 186, 187; 186, 191; 187, not_operator; 187, 188; 188, comparison_operator:in; 188, 189; 188, 190; 189, string:'label'; 190, identifier:result; 191, block; 191, 192; 192, raise_statement; 192, 193; 193, call; 193, 194; 193, 195; 194, identifier:UnexpectedResponseError; 195, argument_list; 195, 196; 195, 197; 196, string:'Unexpected response when creating Tag!'; 197, keyword_argument; 197, 198; 197, 199; 198, identifier:json; 199, identifier:result; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 203; 202, identifier:t; 203, call; 203, 204; 203, 205; 204, identifier:Tag; 205, argument_list; 205, 206; 205, 207; 205, 210; 206, identifier:self; 207, subscript; 207, 208; 207, 209; 208, identifier:result; 209, string:'label'; 210, identifier:result; 211, return_statement; 211, 212; 212, identifier:t | def tag_create(self, label, instances=None, domains=None, nodebalancers=None,
volumes=None, entities=[]):
linode_ids, nodebalancer_ids, domain_ids, volume_ids = [], [], [], []
sorter = zip((linode_ids, nodebalancer_ids, domain_ids, volume_ids),
(instances, nodebalancers, domains, volumes))
for id_list, input_list in sorter:
if input_list is not None:
for cur in input_list:
if isinstance(cur, int):
id_list.append(cur)
else:
id_list.append(cur.id)
type_map = {
Instance: linode_ids,
NodeBalancer: nodebalancer_ids,
Domain: domain_ids,
Volume: volume_ids,
}
for e in entities:
if type(e) in type_map:
type_map[type(e)].append(e.id)
else:
raise ValueError('Unsupported entity type {}'.format(type(e)))
params = {
'label': label,
'linodes': linode_ids or None,
'nodebalancers': nodebalancer_ids or None,
'domains': domain_ids or None,
'volumes': volume_ids or None,
}
result = self.post('/tags', data=params)
if not 'label' in result:
raise UnexpectedResponseError('Unexpected response when creating Tag!', json=result)
t = Tag(self, result['label'], result)
return t |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:validate_anneal_schedule; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:anneal_schedule; 6, block; 6, 7; 6, 19; 6, 25; 6, 49; 6, 96; 6, 116; 6, 143; 6, 161; 6, 174; 6, 184; 6, 236; 6, 242; 7, if_statement; 7, 8; 7, 13; 8, comparison_operator:not; 8, 9; 8, 10; 9, string:'anneal_schedule'; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:parameters; 13, block; 13, 14; 14, raise_statement; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:RuntimeError; 17, argument_list; 17, 18; 18, string:"anneal_schedule is not an accepted parameter for this sampler"; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:properties; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:properties; 25, try_statement; 25, 26; 25, 41; 26, block; 26, 27; 26, 35; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 32; 29, pattern_list; 29, 30; 29, 31; 30, identifier:min_anneal_time; 31, identifier:max_anneal_time; 32, subscript; 32, 33; 32, 34; 33, identifier:properties; 34, string:'annealing_time_range'; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:max_anneal_schedule_points; 38, subscript; 38, 39; 38, 40; 39, identifier:properties; 40, string:'max_anneal_schedule_points'; 41, except_clause; 41, 42; 41, 43; 42, identifier:KeyError; 43, block; 43, 44; 44, raise_statement; 44, 45; 45, call; 45, 46; 45, 47; 46, identifier:RuntimeError; 47, argument_list; 47, 48; 48, string:"annealing_time_range and max_anneal_schedule_points are not properties of this solver"; 49, if_statement; 49, 50; 49, 56; 49, 62; 50, not_operator; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:isinstance; 53, argument_list; 53, 54; 53, 55; 54, identifier:anneal_schedule; 55, identifier:list; 56, block; 56, 57; 57, raise_statement; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:TypeError; 60, argument_list; 60, 61; 61, string:"anneal_schedule should be a list"; 62, elif_clause; 62, 63; 62, 76; 63, boolean_operator:or; 63, 64; 63, 70; 64, comparison_operator:<; 64, 65; 64, 69; 65, call; 65, 66; 65, 67; 66, identifier:len; 67, argument_list; 67, 68; 68, identifier:anneal_schedule; 69, integer:2; 70, comparison_operator:>; 70, 71; 70, 75; 71, call; 71, 72; 71, 73; 72, identifier:len; 73, argument_list; 73, 74; 74, identifier:anneal_schedule; 75, identifier:max_anneal_schedule_points; 76, block; 76, 77; 76, 91; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:msg; 80, call; 80, 81; 80, 85; 81, attribute; 81, 82; 81, 84; 82, parenthesized_expression; 82, 83; 83, string:"anneal_schedule must contain between 2 and {} points (contains {})"; 84, identifier:format; 85, argument_list; 85, 86; 85, 87; 86, identifier:max_anneal_schedule_points; 87, call; 87, 88; 87, 89; 88, identifier:len; 89, argument_list; 89, 90; 90, identifier:anneal_schedule; 91, raise_statement; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:ValueError; 94, argument_list; 94, 95; 95, identifier:msg; 96, try_statement; 96, 97; 96, 108; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 103; 100, pattern_list; 100, 101; 100, 102; 101, identifier:t_list; 102, identifier:s_list; 103, call; 103, 104; 103, 105; 104, identifier:zip; 105, argument_list; 105, 106; 106, list_splat; 106, 107; 107, identifier:anneal_schedule; 108, except_clause; 108, 109; 108, 110; 109, identifier:ValueError; 110, block; 110, 111; 111, raise_statement; 111, 112; 112, call; 112, 113; 112, 114; 113, identifier:ValueError; 114, argument_list; 114, 115; 115, string:"anneal_schedule should be a list of 2-tuples"; 116, if_statement; 116, 117; 116, 137; 117, not_operator; 117, 118; 118, call; 118, 119; 118, 120; 119, identifier:all; 120, generator_expression; 120, 121; 120, 124; 121, comparison_operator:<; 121, 122; 121, 123; 122, identifier:tail_t; 123, identifier:lead_t; 124, for_in_clause; 124, 125; 124, 128; 125, pattern_list; 125, 126; 125, 127; 126, identifier:tail_t; 127, identifier:lead_t; 128, call; 128, 129; 128, 130; 129, identifier:zip; 130, argument_list; 130, 131; 130, 132; 131, identifier:t_list; 132, subscript; 132, 133; 132, 134; 133, identifier:t_list; 134, slice; 134, 135; 134, 136; 135, integer:1; 136, colon; 137, block; 137, 138; 138, raise_statement; 138, 139; 139, call; 139, 140; 139, 141; 140, identifier:ValueError; 141, argument_list; 141, 142; 142, string:"Time t must increase for all points in the schedule"; 143, if_statement; 143, 144; 143, 150; 144, comparison_operator:>; 144, 145; 144, 149; 145, subscript; 145, 146; 145, 147; 146, identifier:t_list; 147, unary_operator:-; 147, 148; 148, integer:1; 149, identifier:max_anneal_time; 150, block; 150, 151; 151, raise_statement; 151, 152; 152, call; 152, 153; 152, 154; 153, identifier:ValueError; 154, argument_list; 154, 155; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, string:"schedule cannot be longer than the maximum anneal time of {}"; 158, identifier:format; 159, argument_list; 159, 160; 160, identifier:max_anneal_time; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 166; 163, pattern_list; 163, 164; 163, 165; 164, identifier:start_s; 165, identifier:end_s; 166, expression_list; 166, 167; 166, 170; 167, subscript; 167, 168; 167, 169; 168, identifier:s_list; 169, integer:0; 170, subscript; 170, 171; 170, 172; 171, identifier:s_list; 172, unary_operator:-; 172, 173; 173, integer:1; 174, if_statement; 174, 175; 174, 178; 175, comparison_operator:!=; 175, 176; 175, 177; 176, identifier:end_s; 177, integer:1; 178, block; 178, 179; 179, raise_statement; 179, 180; 180, call; 180, 181; 180, 182; 181, identifier:ValueError; 182, argument_list; 182, 183; 183, string:"In the final point, anneal fraction s must equal 1."; 184, if_statement; 184, 185; 184, 188; 184, 190; 184, 222; 185, comparison_operator:==; 185, 186; 185, 187; 186, identifier:start_s; 187, integer:1; 188, block; 188, 189; 189, pass_statement; 190, elif_clause; 190, 191; 190, 194; 191, comparison_operator:==; 191, 192; 191, 193; 192, identifier:start_s; 193, integer:0; 194, block; 194, 195; 195, if_statement; 195, 196; 195, 216; 196, not_operator; 196, 197; 197, call; 197, 198; 197, 199; 198, identifier:all; 199, generator_expression; 199, 200; 199, 203; 200, comparison_operator:<=; 200, 201; 200, 202; 201, identifier:tail_s; 202, identifier:lead_s; 203, for_in_clause; 203, 204; 203, 207; 204, pattern_list; 204, 205; 204, 206; 205, identifier:tail_s; 206, identifier:lead_s; 207, call; 207, 208; 207, 209; 208, identifier:zip; 209, argument_list; 209, 210; 209, 211; 210, identifier:s_list; 211, subscript; 211, 212; 211, 213; 212, identifier:s_list; 213, slice; 213, 214; 213, 215; 214, integer:1; 215, colon; 216, block; 216, 217; 217, raise_statement; 217, 218; 218, call; 218, 219; 218, 220; 219, identifier:ValueError; 220, argument_list; 220, 221; 221, string:"For forward anneals, anneal fraction s must monotonically increase"; 222, else_clause; 222, 223; 223, block; 223, 224; 223, 231; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:msg; 227, parenthesized_expression; 227, 228; 228, concatenated_string; 228, 229; 228, 230; 229, string:"In the first point, anneal fraction s must equal 0 for forward annealing or "; 230, string:"1 for reverse annealing"; 231, raise_statement; 231, 232; 232, call; 232, 233; 232, 234; 233, identifier:ValueError; 234, argument_list; 234, 235; 235, identifier:msg; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:max_slope; 239, binary_operator:/; 239, 240; 239, 241; 240, float:1.0; 241, identifier:min_anneal_time; 242, for_statement; 242, 243; 242, 250; 242, 259; 243, pattern_list; 243, 244; 243, 247; 244, tuple_pattern; 244, 245; 244, 246; 245, identifier:t0; 246, identifier:s0; 247, tuple_pattern; 247, 248; 247, 249; 248, identifier:t1; 249, identifier:s1; 250, call; 250, 251; 250, 252; 251, identifier:zip; 252, argument_list; 252, 253; 252, 254; 253, identifier:anneal_schedule; 254, subscript; 254, 255; 254, 256; 255, identifier:anneal_schedule; 256, slice; 256, 257; 256, 258; 257, integer:1; 258, colon; 259, block; 259, 260; 260, if_statement; 260, 261; 260, 275; 261, comparison_operator:>; 261, 262; 261, 274; 262, call; 262, 263; 262, 264; 263, identifier:abs; 264, argument_list; 264, 265; 265, binary_operator:/; 265, 266; 265, 270; 266, parenthesized_expression; 266, 267; 267, binary_operator:-; 267, 268; 267, 269; 268, identifier:s0; 269, identifier:s1; 270, parenthesized_expression; 270, 271; 271, binary_operator:-; 271, 272; 271, 273; 272, identifier:t0; 273, identifier:t1; 274, identifier:max_slope; 275, block; 275, 276; 276, raise_statement; 276, 277; 277, call; 277, 278; 277, 279; 278, identifier:ValueError; 279, argument_list; 279, 280; 280, call; 280, 281; 280, 284; 281, attribute; 281, 282; 281, 283; 282, string:"the maximum slope cannot exceed {}"; 283, identifier:format; 284, argument_list; 284, 285; 285, identifier:max_slope | def validate_anneal_schedule(self, anneal_schedule):
if 'anneal_schedule' not in self.parameters:
raise RuntimeError("anneal_schedule is not an accepted parameter for this sampler")
properties = self.properties
try:
min_anneal_time, max_anneal_time = properties['annealing_time_range']
max_anneal_schedule_points = properties['max_anneal_schedule_points']
except KeyError:
raise RuntimeError("annealing_time_range and max_anneal_schedule_points are not properties of this solver")
if not isinstance(anneal_schedule, list):
raise TypeError("anneal_schedule should be a list")
elif len(anneal_schedule) < 2 or len(anneal_schedule) > max_anneal_schedule_points:
msg = ("anneal_schedule must contain between 2 and {} points (contains {})"
).format(max_anneal_schedule_points, len(anneal_schedule))
raise ValueError(msg)
try:
t_list, s_list = zip(*anneal_schedule)
except ValueError:
raise ValueError("anneal_schedule should be a list of 2-tuples")
if not all(tail_t < lead_t for tail_t, lead_t in zip(t_list, t_list[1:])):
raise ValueError("Time t must increase for all points in the schedule")
if t_list[-1] > max_anneal_time:
raise ValueError("schedule cannot be longer than the maximum anneal time of {}".format(max_anneal_time))
start_s, end_s = s_list[0], s_list[-1]
if end_s != 1:
raise ValueError("In the final point, anneal fraction s must equal 1.")
if start_s == 1:
pass
elif start_s == 0:
if not all(tail_s <= lead_s for tail_s, lead_s in zip(s_list, s_list[1:])):
raise ValueError("For forward anneals, anneal fraction s must monotonically increase")
else:
msg = ("In the first point, anneal fraction s must equal 0 for forward annealing or "
"1 for reverse annealing")
raise ValueError(msg)
max_slope = 1.0 / min_anneal_time
for (t0, s0), (t1, s1) in zip(anneal_schedule, anneal_schedule[1:]):
if abs((s0 - s1) / (t0 - t1)) > max_slope:
raise ValueError("the maximum slope cannot exceed {}".format(max_slope)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:target_to_source; 3, parameters; 3, 4; 3, 5; 4, identifier:target_adjacency; 5, identifier:embedding; 6, block; 6, 7; 6, 19; 6, 23; 6, 57; 6, 112; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:source_adjacency; 10, dictionary_comprehension; 10, 11; 10, 16; 11, pair; 11, 12; 11, 13; 12, identifier:v; 13, call; 13, 14; 13, 15; 14, identifier:set; 15, argument_list; 16, for_in_clause; 16, 17; 16, 18; 17, identifier:v; 18, identifier:embedding; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:reverse_embedding; 22, dictionary; 23, for_statement; 23, 24; 23, 27; 23, 31; 24, pattern_list; 24, 25; 24, 26; 25, identifier:v; 26, identifier:chain; 27, call; 27, 28; 27, 29; 28, identifier:iteritems; 29, argument_list; 29, 30; 30, identifier:embedding; 31, block; 31, 32; 32, for_statement; 32, 33; 32, 34; 32, 35; 33, identifier:u; 34, identifier:chain; 35, block; 35, 36; 35, 51; 36, if_statement; 36, 37; 36, 40; 37, comparison_operator:in; 37, 38; 37, 39; 38, identifier:u; 39, identifier:reverse_embedding; 40, block; 40, 41; 41, raise_statement; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:ValueError; 44, argument_list; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, string:"target node {} assigned to more than one source node"; 48, identifier:format; 49, argument_list; 49, 50; 50, identifier:u; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 56; 53, subscript; 53, 54; 53, 55; 54, identifier:reverse_embedding; 55, identifier:u; 56, identifier:v; 57, for_statement; 57, 58; 57, 61; 57, 65; 58, pattern_list; 58, 59; 58, 60; 59, identifier:v; 60, identifier:n; 61, call; 61, 62; 61, 63; 62, identifier:iteritems; 63, argument_list; 63, 64; 64, identifier:reverse_embedding; 65, block; 65, 66; 65, 72; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:neighbors; 69, subscript; 69, 70; 69, 71; 70, identifier:target_adjacency; 71, identifier:v; 72, for_statement; 72, 73; 72, 74; 72, 75; 73, identifier:u; 74, identifier:neighbors; 75, block; 75, 76; 75, 82; 75, 88; 75, 94; 75, 103; 76, if_statement; 76, 77; 76, 80; 77, comparison_operator:not; 77, 78; 77, 79; 78, identifier:u; 79, identifier:reverse_embedding; 80, block; 80, 81; 81, continue_statement; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:m; 85, subscript; 85, 86; 85, 87; 86, identifier:reverse_embedding; 87, identifier:u; 88, if_statement; 88, 89; 88, 92; 89, comparison_operator:==; 89, 90; 89, 91; 90, identifier:m; 91, identifier:n; 92, block; 92, 93; 93, continue_statement; 94, expression_statement; 94, 95; 95, call; 95, 96; 95, 101; 96, attribute; 96, 97; 96, 100; 97, subscript; 97, 98; 97, 99; 98, identifier:source_adjacency; 99, identifier:n; 100, identifier:add; 101, argument_list; 101, 102; 102, identifier:m; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 110; 105, attribute; 105, 106; 105, 109; 106, subscript; 106, 107; 106, 108; 107, identifier:source_adjacency; 108, identifier:m; 109, identifier:add; 110, argument_list; 110, 111; 111, identifier:n; 112, return_statement; 112, 113; 113, identifier:source_adjacency | def target_to_source(target_adjacency, embedding):
source_adjacency = {v: set() for v in embedding}
reverse_embedding = {}
for v, chain in iteritems(embedding):
for u in chain:
if u in reverse_embedding:
raise ValueError("target node {} assigned to more than one source node".format(u))
reverse_embedding[u] = v
for v, n in iteritems(reverse_embedding):
neighbors = target_adjacency[v]
for u in neighbors:
if u not in reverse_embedding:
continue
m = reverse_embedding[u]
if m == n:
continue
source_adjacency[n].add(m)
source_adjacency[m].add(n)
return source_adjacency |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:insert_graph; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:cur; 5, identifier:nodelist; 6, identifier:edgelist; 7, default_parameter; 7, 8; 7, 9; 8, identifier:encoded_data; 9, None; 10, block; 10, 11; 10, 20; 10, 34; 10, 48; 10, 69; 11, if_statement; 11, 12; 11, 15; 12, comparison_operator:is; 12, 13; 12, 14; 13, identifier:encoded_data; 14, None; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:encoded_data; 19, dictionary; 20, if_statement; 20, 21; 20, 24; 21, comparison_operator:not; 21, 22; 21, 23; 22, string:'num_nodes'; 23, identifier:encoded_data; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 30; 27, subscript; 27, 28; 27, 29; 28, identifier:encoded_data; 29, string:'num_nodes'; 30, call; 30, 31; 30, 32; 31, identifier:len; 32, argument_list; 32, 33; 33, identifier:nodelist; 34, if_statement; 34, 35; 34, 38; 35, comparison_operator:not; 35, 36; 35, 37; 36, string:'num_edges'; 37, identifier:encoded_data; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 44; 41, subscript; 41, 42; 41, 43; 42, identifier:encoded_data; 43, string:'num_edges'; 44, call; 44, 45; 44, 46; 45, identifier:len; 46, argument_list; 46, 47; 47, identifier:edgelist; 48, if_statement; 48, 49; 48, 52; 49, comparison_operator:not; 49, 50; 49, 51; 50, string:'edges'; 51, identifier:encoded_data; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, subscript; 55, 56; 55, 57; 56, identifier:encoded_data; 57, string:'edges'; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:json; 61, identifier:dumps; 62, argument_list; 62, 63; 62, 64; 63, identifier:edgelist; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:separators; 66, tuple; 66, 67; 66, 68; 67, string:','; 68, string:':'; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 70, 73; 71, identifier:insert; 72, line_continuation:\; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:cur; 76, identifier:execute; 77, argument_list; 77, 78; 77, 79; 78, identifier:insert; 79, identifier:encoded_data | def insert_graph(cur, nodelist, edgelist, encoded_data=None):
if encoded_data is None:
encoded_data = {}
if 'num_nodes' not in encoded_data:
encoded_data['num_nodes'] = len(nodelist)
if 'num_edges' not in encoded_data:
encoded_data['num_edges'] = len(edgelist)
if 'edges' not in encoded_data:
encoded_data['edges'] = json.dumps(edgelist, separators=(',', ':'))
insert = \
cur.execute(insert, encoded_data) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:draw_chimera_bqm; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:bqm; 5, default_parameter; 5, 6; 5, 7; 6, identifier:width; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:height; 10, None; 11, block; 11, 12; 11, 22; 11, 32; 11, 67; 11, 79; 11, 88; 11, 97; 11, 101; 11, 105; 11, 124; 11, 143; 11, 150; 11, 159; 11, 170; 11, 183; 11, 189; 11, 195; 11, 209; 11, 218; 11, 227; 11, 239; 11, 250; 11, 254; 11, 270; 11, 291; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:linear; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:bqm; 19, identifier:linear; 20, identifier:keys; 21, argument_list; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:quadratic; 25, call; 25, 26; 25, 31; 26, attribute; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:bqm; 29, identifier:quadratic; 30, identifier:keys; 31, argument_list; 32, if_statement; 32, 33; 32, 40; 33, boolean_operator:and; 33, 34; 33, 37; 34, comparison_operator:is; 34, 35; 34, 36; 35, identifier:width; 36, None; 37, comparison_operator:is; 37, 38; 37, 39; 38, identifier:height; 39, None; 40, block; 40, 41; 40, 59; 40, 63; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:graph_size; 44, call; 44, 45; 44, 46; 45, identifier:ceil; 46, argument_list; 46, 47; 47, call; 47, 48; 47, 49; 48, identifier:sqrt; 49, argument_list; 49, 50; 50, binary_operator:/; 50, 51; 50, 58; 51, parenthesized_expression; 51, 52; 52, binary_operator:+; 52, 53; 52, 57; 53, call; 53, 54; 53, 55; 54, identifier:max; 55, argument_list; 55, 56; 56, identifier:linear; 57, integer:1; 58, float:8.0; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:width; 62, identifier:graph_size; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:height; 66, identifier:graph_size; 67, if_statement; 67, 68; 67, 73; 68, boolean_operator:or; 68, 69; 68, 71; 69, not_operator; 69, 70; 70, identifier:width; 71, not_operator; 71, 72; 72, identifier:height; 73, block; 73, 74; 74, raise_statement; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:Exception; 77, argument_list; 77, 78; 78, string:"Both dimensions must be defined, not just one."; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:G0; 82, call; 82, 83; 82, 84; 83, identifier:chimera_graph; 84, argument_list; 84, 85; 84, 86; 84, 87; 85, identifier:height; 86, identifier:width; 87, integer:4; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:G; 91, call; 91, 92; 91, 93; 92, identifier:chimera_graph; 93, argument_list; 93, 94; 93, 95; 93, 96; 94, identifier:height; 95, identifier:width; 96, integer:4; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:non_chimera_nodes; 100, list:[]; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:non_chimera_edges; 104, list:[]; 105, for_statement; 105, 106; 105, 107; 105, 108; 106, identifier:node; 107, identifier:linear; 108, block; 108, 109; 109, if_statement; 109, 110; 109, 116; 110, not_operator; 110, 111; 111, comparison_operator:in; 111, 112; 111, 113; 112, identifier:node; 113, attribute; 113, 114; 113, 115; 114, identifier:G; 115, identifier:nodes; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:non_chimera_nodes; 121, identifier:append; 122, argument_list; 122, 123; 123, identifier:node; 124, for_statement; 124, 125; 124, 126; 124, 127; 125, identifier:edge; 126, identifier:quadratic; 127, block; 127, 128; 128, if_statement; 128, 129; 128, 135; 129, not_operator; 129, 130; 130, comparison_operator:in; 130, 131; 130, 132; 131, identifier:edge; 132, attribute; 132, 133; 132, 134; 133, identifier:G; 134, identifier:edges; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:non_chimera_edges; 140, identifier:append; 141, argument_list; 141, 142; 142, identifier:edge; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:linear_set; 146, call; 146, 147; 146, 148; 147, identifier:set; 148, argument_list; 148, 149; 149, identifier:linear; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:g_node_set; 153, call; 153, 154; 153, 155; 154, identifier:set; 155, argument_list; 155, 156; 156, attribute; 156, 157; 156, 158; 157, identifier:G; 158, identifier:nodes; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:quadratic_set; 162, call; 162, 163; 162, 164; 163, identifier:set; 164, argument_list; 164, 165; 165, call; 165, 166; 165, 167; 166, identifier:map; 167, argument_list; 167, 168; 167, 169; 168, identifier:frozenset; 169, identifier:quadratic; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:g_edge_set; 173, call; 173, 174; 173, 175; 174, identifier:set; 175, argument_list; 175, 176; 176, call; 176, 177; 176, 178; 177, identifier:map; 178, argument_list; 178, 179; 178, 180; 179, identifier:frozenset; 180, attribute; 180, 181; 180, 182; 181, identifier:G; 182, identifier:edges; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:non_chimera_nodes; 186, binary_operator:-; 186, 187; 186, 188; 187, identifier:linear_set; 188, identifier:g_node_set; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:non_chimera_edges; 192, binary_operator:-; 192, 193; 192, 194; 193, identifier:quadratic_set; 194, identifier:g_edge_set; 195, if_statement; 195, 196; 195, 199; 196, boolean_operator:or; 196, 197; 196, 198; 197, identifier:non_chimera_nodes; 198, identifier:non_chimera_edges; 199, block; 199, 200; 200, raise_statement; 200, 201; 201, call; 201, 202; 201, 203; 202, identifier:Exception; 203, argument_list; 203, 204; 204, binary_operator:%; 204, 205; 204, 206; 205, string:"Input graph is not a chimera graph: Nodes: %s Edges: %s"; 206, tuple; 206, 207; 206, 208; 207, identifier:non_chimera_nodes; 208, identifier:non_chimera_edges; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:remove_nodes; 212, call; 212, 213; 212, 214; 213, identifier:list; 214, argument_list; 214, 215; 215, binary_operator:-; 215, 216; 215, 217; 216, identifier:g_node_set; 217, identifier:linear_set; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:remove_edges; 221, call; 221, 222; 221, 223; 222, identifier:list; 223, argument_list; 223, 224; 224, binary_operator:-; 224, 225; 224, 226; 225, identifier:g_edge_set; 226, identifier:quadratic_set; 227, for_statement; 227, 228; 227, 229; 227, 230; 228, identifier:edge; 229, identifier:remove_edges; 230, block; 230, 231; 231, expression_statement; 231, 232; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:G; 235, identifier:remove_edge; 236, argument_list; 236, 237; 237, list_splat; 237, 238; 238, identifier:edge; 239, for_statement; 239, 240; 239, 241; 239, 242; 240, identifier:node; 241, identifier:remove_nodes; 242, block; 242, 243; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:G; 247, identifier:remove_node; 248, argument_list; 248, 249; 249, identifier:node; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:node_size; 253, integer:100; 254, expression_statement; 254, 255; 255, call; 255, 256; 255, 257; 256, identifier:draw_chimera; 257, argument_list; 257, 258; 257, 259; 257, 264; 257, 267; 258, identifier:G0; 259, keyword_argument; 259, 260; 259, 261; 260, identifier:node_size; 261, binary_operator:*; 261, 262; 261, 263; 262, identifier:node_size; 263, float:0.5; 264, keyword_argument; 264, 265; 264, 266; 265, identifier:node_color; 266, string:'black'; 267, keyword_argument; 267, 268; 267, 269; 268, identifier:edge_color; 269, string:'black'; 270, expression_statement; 270, 271; 271, call; 271, 272; 271, 273; 272, identifier:draw_chimera; 273, argument_list; 273, 274; 273, 275; 273, 278; 273, 283; 273, 288; 274, identifier:G; 275, keyword_argument; 275, 276; 275, 277; 276, identifier:node_size; 277, identifier:node_size; 278, keyword_argument; 278, 279; 278, 280; 279, identifier:linear_biases; 280, attribute; 280, 281; 280, 282; 281, identifier:bqm; 282, identifier:linear; 283, keyword_argument; 283, 284; 283, 285; 284, identifier:quadratic_biases; 285, attribute; 285, 286; 285, 287; 286, identifier:bqm; 287, identifier:quadratic; 288, keyword_argument; 288, 289; 288, 290; 289, identifier:width; 290, integer:3; 291, return_statement | def draw_chimera_bqm(bqm, width=None, height=None):
linear = bqm.linear.keys()
quadratic = bqm.quadratic.keys()
if width is None and height is None:
graph_size = ceil(sqrt((max(linear) + 1) / 8.0))
width = graph_size
height = graph_size
if not width or not height:
raise Exception("Both dimensions must be defined, not just one.")
G0 = chimera_graph(height, width, 4)
G = chimera_graph(height, width, 4)
non_chimera_nodes = []
non_chimera_edges = []
for node in linear:
if not node in G.nodes:
non_chimera_nodes.append(node)
for edge in quadratic:
if not edge in G.edges:
non_chimera_edges.append(edge)
linear_set = set(linear)
g_node_set = set(G.nodes)
quadratic_set = set(map(frozenset, quadratic))
g_edge_set = set(map(frozenset, G.edges))
non_chimera_nodes = linear_set - g_node_set
non_chimera_edges = quadratic_set - g_edge_set
if non_chimera_nodes or non_chimera_edges:
raise Exception("Input graph is not a chimera graph: Nodes: %s Edges: %s" % (non_chimera_nodes, non_chimera_edges))
remove_nodes = list(g_node_set - linear_set)
remove_edges = list(g_edge_set - quadratic_set)
for edge in remove_edges:
G.remove_edge(*edge)
for node in remove_nodes:
G.remove_node(node)
node_size = 100
draw_chimera(G0, node_size=node_size*0.5, node_color='black', edge_color='black')
draw_chimera(G, node_size=node_size, linear_biases=bqm.linear, quadratic_biases=bqm.quadratic,
width=3)
return |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:embed_bqm; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 4, identifier:source_bqm; 5, identifier:embedding; 6, identifier:target_adjacency; 7, default_parameter; 7, 8; 7, 9; 8, identifier:chain_strength; 9, float:1.0; 10, default_parameter; 10, 11; 10, 12; 11, identifier:smear_vartype; 12, None; 13, block; 13, 14; 13, 78; 13, 89; 13, 98; 13, 174; 13, 244; 13, 312; 14, if_statement; 14, 15; 14, 28; 14, 46; 15, boolean_operator:and; 15, 16; 15, 21; 16, comparison_operator:is; 16, 17; 16, 18; 17, identifier:smear_vartype; 18, attribute; 18, 19; 18, 20; 19, identifier:dimod; 20, identifier:SPIN; 21, comparison_operator:is; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:source_bqm; 24, identifier:vartype; 25, attribute; 25, 26; 25, 27; 26, identifier:dimod; 27, identifier:BINARY; 28, block; 28, 29; 29, return_statement; 29, 30; 30, attribute; 30, 31; 30, 45; 31, call; 31, 32; 31, 33; 32, identifier:embed_bqm; 33, argument_list; 33, 34; 33, 37; 33, 38; 33, 39; 33, 42; 34, attribute; 34, 35; 34, 36; 35, identifier:source_bqm; 36, identifier:spin; 37, identifier:embedding; 38, identifier:target_adjacency; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:chain_strength; 41, identifier:chain_strength; 42, keyword_argument; 42, 43; 42, 44; 43, identifier:smear_vartype; 44, None; 45, identifier:binary; 46, elif_clause; 46, 47; 46, 60; 47, boolean_operator:and; 47, 48; 47, 53; 48, comparison_operator:is; 48, 49; 48, 50; 49, identifier:smear_vartype; 50, attribute; 50, 51; 50, 52; 51, identifier:dimod; 52, identifier:BINARY; 53, comparison_operator:is; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:source_bqm; 56, identifier:vartype; 57, attribute; 57, 58; 57, 59; 58, identifier:dimod; 59, identifier:SPIN; 60, block; 60, 61; 61, return_statement; 61, 62; 62, attribute; 62, 63; 62, 77; 63, call; 63, 64; 63, 65; 64, identifier:embed_bqm; 65, argument_list; 65, 66; 65, 69; 65, 70; 65, 71; 65, 74; 66, attribute; 66, 67; 66, 68; 67, identifier:source_bqm; 68, identifier:binary; 69, identifier:embedding; 70, identifier:target_adjacency; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:chain_strength; 73, identifier:chain_strength; 74, keyword_argument; 74, 75; 74, 76; 75, identifier:smear_vartype; 76, None; 77, identifier:spin; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:target_bqm; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:source_bqm; 84, identifier:empty; 85, argument_list; 85, 86; 86, attribute; 86, 87; 86, 88; 87, identifier:source_bqm; 88, identifier:vartype; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:target_bqm; 93, identifier:add_offset; 94, argument_list; 94, 95; 95, attribute; 95, 96; 95, 97; 96, identifier:source_bqm; 97, identifier:offset; 98, for_statement; 98, 99; 98, 102; 98, 108; 99, pattern_list; 99, 100; 99, 101; 100, identifier:v; 101, identifier:bias; 102, call; 102, 103; 102, 104; 103, identifier:iteritems; 104, argument_list; 104, 105; 105, attribute; 105, 106; 105, 107; 106, identifier:source_bqm; 107, identifier:linear; 108, block; 108, 109; 108, 127; 108, 152; 108, 161; 109, if_statement; 109, 110; 109, 113; 109, 120; 110, comparison_operator:in; 110, 111; 110, 112; 111, identifier:v; 112, identifier:embedding; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:chain; 117, subscript; 117, 118; 117, 119; 118, identifier:embedding; 119, identifier:v; 120, else_clause; 120, 121; 121, block; 121, 122; 122, raise_statement; 122, 123; 123, call; 123, 124; 123, 125; 124, identifier:MissingChainError; 125, argument_list; 125, 126; 126, identifier:v; 127, if_statement; 127, 128; 127, 137; 128, call; 128, 129; 128, 130; 129, identifier:any; 130, generator_expression; 130, 131; 130, 134; 131, comparison_operator:not; 131, 132; 131, 133; 132, identifier:u; 133, identifier:target_adjacency; 134, for_in_clause; 134, 135; 134, 136; 135, identifier:u; 136, identifier:chain; 137, block; 137, 138; 138, raise_statement; 138, 139; 139, call; 139, 140; 139, 141; 140, identifier:InvalidNodeError; 141, argument_list; 141, 142; 141, 143; 142, identifier:v; 143, call; 143, 144; 143, 145; 144, identifier:next; 145, generator_expression; 145, 146; 145, 149; 146, comparison_operator:not; 146, 147; 146, 148; 147, identifier:u; 148, identifier:target_adjacency; 149, for_in_clause; 149, 150; 149, 151; 150, identifier:u; 151, identifier:chain; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:b; 155, binary_operator:/; 155, 156; 155, 157; 156, identifier:bias; 157, call; 157, 158; 157, 159; 158, identifier:len; 159, argument_list; 159, 160; 160, identifier:chain; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:target_bqm; 165, identifier:add_variables_from; 166, argument_list; 166, 167; 167, dictionary_comprehension; 167, 168; 167, 171; 168, pair; 168, 169; 168, 170; 169, identifier:u; 170, identifier:b; 171, for_in_clause; 171, 172; 171, 173; 172, identifier:u; 173, identifier:chain; 174, for_statement; 174, 175; 174, 180; 174, 186; 175, pattern_list; 175, 176; 175, 179; 176, tuple_pattern; 176, 177; 176, 178; 177, identifier:u; 178, identifier:v; 179, identifier:bias; 180, call; 180, 181; 180, 182; 181, identifier:iteritems; 182, argument_list; 182, 183; 183, attribute; 183, 184; 183, 185; 184, identifier:source_bqm; 185, identifier:quadratic; 186, block; 186, 187; 186, 210; 186, 220; 186, 229; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:available_interactions; 190, set_comprehension; 190, 191; 190, 194; 190, 199; 190, 204; 191, tuple; 191, 192; 191, 193; 192, identifier:s; 193, identifier:t; 194, for_in_clause; 194, 195; 194, 196; 195, identifier:s; 196, subscript; 196, 197; 196, 198; 197, identifier:embedding; 198, identifier:u; 199, for_in_clause; 199, 200; 199, 201; 200, identifier:t; 201, subscript; 201, 202; 201, 203; 202, identifier:embedding; 203, identifier:v; 204, if_clause; 204, 205; 205, comparison_operator:in; 205, 206; 205, 207; 206, identifier:s; 207, subscript; 207, 208; 207, 209; 208, identifier:target_adjacency; 209, identifier:t; 210, if_statement; 210, 211; 210, 213; 211, not_operator; 211, 212; 212, identifier:available_interactions; 213, block; 213, 214; 214, raise_statement; 214, 215; 215, call; 215, 216; 215, 217; 216, identifier:MissingEdgeError; 217, argument_list; 217, 218; 217, 219; 218, identifier:u; 219, identifier:v; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:b; 223, binary_operator:/; 223, 224; 223, 225; 224, identifier:bias; 225, call; 225, 226; 225, 227; 226, identifier:len; 227, argument_list; 227, 228; 228, identifier:available_interactions; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:target_bqm; 233, identifier:add_interactions_from; 234, generator_expression; 234, 235; 234, 239; 235, tuple; 235, 236; 235, 237; 235, 238; 236, identifier:u; 237, identifier:v; 238, identifier:b; 239, for_in_clause; 239, 240; 239, 243; 240, pattern_list; 240, 241; 240, 242; 241, identifier:u; 242, identifier:v; 243, identifier:available_interactions; 244, for_statement; 244, 245; 244, 246; 244, 250; 245, identifier:chain; 246, call; 246, 247; 246, 248; 247, identifier:itervalues; 248, argument_list; 248, 249; 249, identifier:embedding; 250, block; 250, 251; 250, 273; 250, 282; 250, 294; 250, 305; 251, if_statement; 251, 252; 251, 258; 252, comparison_operator:==; 252, 253; 252, 257; 253, call; 253, 254; 253, 255; 254, identifier:len; 255, argument_list; 255, 256; 256, identifier:chain; 257, integer:1; 258, block; 258, 259; 258, 264; 258, 272; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 263; 261, pattern_list; 261, 262; 262, identifier:v; 263, identifier:chain; 264, expression_statement; 264, 265; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:target_bqm; 268, identifier:add_variable; 269, argument_list; 269, 270; 269, 271; 270, identifier:v; 271, float:0.0; 272, continue_statement; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:quadratic_chain_biases; 276, call; 276, 277; 276, 278; 277, identifier:chain_to_quadratic; 278, argument_list; 278, 279; 278, 280; 278, 281; 279, identifier:chain; 280, identifier:target_adjacency; 281, identifier:chain_strength; 282, expression_statement; 282, 283; 283, call; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:target_bqm; 286, identifier:add_interactions_from; 287, argument_list; 287, 288; 287, 289; 288, identifier:quadratic_chain_biases; 289, keyword_argument; 289, 290; 289, 291; 290, identifier:vartype; 291, attribute; 291, 292; 291, 293; 292, identifier:dimod; 293, identifier:SPIN; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 297; 296, identifier:energy_diff; 297, unary_operator:-; 297, 298; 298, call; 298, 299; 298, 300; 299, identifier:sum; 300, argument_list; 300, 301; 301, call; 301, 302; 301, 303; 302, identifier:itervalues; 303, argument_list; 303, 304; 304, identifier:quadratic_chain_biases; 305, expression_statement; 305, 306; 306, call; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:target_bqm; 309, identifier:add_offset; 310, argument_list; 310, 311; 311, identifier:energy_diff; 312, return_statement; 312, 313; 313, identifier:target_bqm | def embed_bqm(source_bqm, embedding, target_adjacency, chain_strength=1.0,
smear_vartype=None):
if smear_vartype is dimod.SPIN and source_bqm.vartype is dimod.BINARY:
return embed_bqm(source_bqm.spin, embedding, target_adjacency,
chain_strength=chain_strength, smear_vartype=None).binary
elif smear_vartype is dimod.BINARY and source_bqm.vartype is dimod.SPIN:
return embed_bqm(source_bqm.binary, embedding, target_adjacency,
chain_strength=chain_strength, smear_vartype=None).spin
target_bqm = source_bqm.empty(source_bqm.vartype)
target_bqm.add_offset(source_bqm.offset)
for v, bias in iteritems(source_bqm.linear):
if v in embedding:
chain = embedding[v]
else:
raise MissingChainError(v)
if any(u not in target_adjacency for u in chain):
raise InvalidNodeError(v, next(u not in target_adjacency for u in chain))
b = bias / len(chain)
target_bqm.add_variables_from({u: b for u in chain})
for (u, v), bias in iteritems(source_bqm.quadratic):
available_interactions = {(s, t) for s in embedding[u] for t in embedding[v] if s in target_adjacency[t]}
if not available_interactions:
raise MissingEdgeError(u, v)
b = bias / len(available_interactions)
target_bqm.add_interactions_from((u, v, b) for u, v in available_interactions)
for chain in itervalues(embedding):
if len(chain) == 1:
v, = chain
target_bqm.add_variable(v, 0.0)
continue
quadratic_chain_biases = chain_to_quadratic(chain, target_adjacency, chain_strength)
target_bqm.add_interactions_from(quadratic_chain_biases, vartype=dimod.SPIN)
energy_diff = -sum(itervalues(quadratic_chain_biases))
target_bqm.add_offset(energy_diff)
return target_bqm |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:embed_ising; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:source_h; 5, identifier:source_J; 6, identifier:embedding; 7, identifier:target_adjacency; 8, default_parameter; 8, 9; 8, 10; 9, identifier:chain_strength; 10, float:1.0; 11, block; 11, 12; 11, 24; 11, 36; 11, 47; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:source_bqm; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:dimod; 19, identifier:BinaryQuadraticModel; 20, identifier:from_ising; 21, argument_list; 21, 22; 21, 23; 22, identifier:source_h; 23, identifier:source_J; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:target_bqm; 27, call; 27, 28; 27, 29; 28, identifier:embed_bqm; 29, argument_list; 29, 30; 29, 31; 29, 32; 29, 33; 30, identifier:source_bqm; 31, identifier:embedding; 32, identifier:target_adjacency; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:chain_strength; 35, identifier:chain_strength; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 42; 38, pattern_list; 38, 39; 38, 40; 38, 41; 39, identifier:target_h; 40, identifier:target_J; 41, identifier:__; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:target_bqm; 45, identifier:to_ising; 46, argument_list; 47, return_statement; 47, 48; 48, expression_list; 48, 49; 48, 50; 49, identifier:target_h; 50, identifier:target_J | def embed_ising(source_h, source_J, embedding, target_adjacency, chain_strength=1.0):
source_bqm = dimod.BinaryQuadraticModel.from_ising(source_h, source_J)
target_bqm = embed_bqm(source_bqm, embedding, target_adjacency, chain_strength=chain_strength)
target_h, target_J, __ = target_bqm.to_ising()
return target_h, target_J |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:unembed_sampleset; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 4, identifier:target_sampleset; 5, identifier:embedding; 6, identifier:source_bqm; 7, default_parameter; 7, 8; 7, 9; 8, identifier:chain_break_method; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:chain_break_fraction; 12, False; 13, block; 13, 14; 13, 23; 13, 30; 13, 50; 13, 68; 13, 74; 13, 86; 13, 212; 13, 218; 13, 240; 13, 264; 14, if_statement; 14, 15; 14, 18; 15, comparison_operator:is; 15, 16; 15, 17; 16, identifier:chain_break_method; 17, None; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:chain_break_method; 22, identifier:majority_vote; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:variables; 26, call; 26, 27; 26, 28; 27, identifier:list; 28, argument_list; 28, 29; 29, identifier:source_bqm; 30, try_statement; 30, 31; 30, 42; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:chains; 35, list_comprehension; 35, 36; 35, 39; 36, subscript; 36, 37; 36, 38; 37, identifier:embedding; 38, identifier:v; 39, for_in_clause; 39, 40; 39, 41; 40, identifier:v; 41, identifier:variables; 42, except_clause; 42, 43; 42, 44; 43, identifier:KeyError; 44, block; 44, 45; 45, raise_statement; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:ValueError; 48, argument_list; 48, 49; 49, string:"given bqm does not match the embedding"; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:chain_idxs; 53, list_comprehension; 53, 54; 53, 65; 54, list_comprehension; 54, 55; 54, 62; 55, subscript; 55, 56; 55, 61; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:target_sampleset; 59, identifier:variables; 60, identifier:index; 61, identifier:v; 62, for_in_clause; 62, 63; 62, 64; 63, identifier:v; 64, identifier:chain; 65, for_in_clause; 65, 66; 65, 67; 66, identifier:chain; 67, identifier:chains; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:record; 71, attribute; 71, 72; 71, 73; 72, identifier:target_sampleset; 73, identifier:record; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 79; 76, pattern_list; 76, 77; 76, 78; 77, identifier:unembedded; 78, identifier:idxs; 79, call; 79, 80; 79, 81; 80, identifier:chain_break_method; 81, argument_list; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:record; 84, identifier:sample; 85, identifier:chain_idxs; 86, try_statement; 86, 87; 86, 99; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:energies; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:source_bqm; 94, identifier:energies; 95, argument_list; 95, 96; 96, tuple; 96, 97; 96, 98; 97, identifier:unembedded; 98, identifier:variables; 99, except_clause; 99, 100; 99, 101; 100, identifier:ValueError; 101, block; 101, 102; 101, 126; 101, 161; 101, 175; 101, 194; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:datatypes; 105, list:[('sample', np.dtype(np.int8), (len(variables),)), ('energy', np.float)]; 105, 106; 105, 121; 106, tuple; 106, 107; 106, 108; 106, 116; 107, string:'sample'; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:np; 111, identifier:dtype; 112, argument_list; 112, 113; 113, attribute; 113, 114; 113, 115; 114, identifier:np; 115, identifier:int8; 116, tuple; 116, 117; 117, call; 117, 118; 117, 119; 118, identifier:len; 119, argument_list; 119, 120; 120, identifier:variables; 121, tuple; 121, 122; 121, 123; 122, string:'energy'; 123, attribute; 123, 124; 123, 125; 124, identifier:np; 125, identifier:float; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:datatypes; 130, identifier:extend; 131, generator_expression; 131, 132; 131, 148; 131, 155; 132, tuple; 132, 133; 132, 134; 132, 139; 133, identifier:name; 134, attribute; 134, 135; 134, 138; 135, subscript; 135, 136; 135, 137; 136, identifier:record; 137, identifier:name; 138, identifier:dtype; 139, subscript; 139, 140; 139, 145; 140, attribute; 140, 141; 140, 144; 141, subscript; 141, 142; 141, 143; 142, identifier:record; 143, identifier:name; 144, identifier:shape; 145, slice; 145, 146; 145, 147; 146, integer:1; 147, colon; 148, for_in_clause; 148, 149; 148, 150; 149, identifier:name; 150, attribute; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:record; 153, identifier:dtype; 154, identifier:names; 155, if_clause; 155, 156; 156, comparison_operator:not; 156, 157; 156, 158; 157, identifier:name; 158, set; 158, 159; 158, 160; 159, string:'sample'; 160, string:'energy'; 161, if_statement; 161, 162; 161, 163; 162, identifier:chain_break_fraction; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:datatypes; 168, identifier:append; 169, argument_list; 169, 170; 170, tuple; 170, 171; 170, 172; 171, string:'chain_break_fraction'; 172, attribute; 172, 173; 172, 174; 173, identifier:np; 174, identifier:float64; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:data; 178, call; 178, 179; 178, 184; 179, attribute; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:np; 182, identifier:rec; 183, identifier:array; 184, argument_list; 184, 185; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:np; 188, identifier:empty; 189, argument_list; 189, 190; 189, 191; 190, integer:0; 191, keyword_argument; 191, 192; 191, 193; 192, identifier:dtype; 193, identifier:datatypes; 194, return_statement; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:dimod; 198, identifier:SampleSet; 199, argument_list; 199, 200; 199, 201; 199, 202; 199, 209; 200, identifier:data; 201, identifier:variables; 202, call; 202, 203; 202, 208; 203, attribute; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:target_sampleset; 206, identifier:info; 207, identifier:copy; 208, argument_list; 209, attribute; 209, 210; 209, 211; 210, identifier:target_sampleset; 211, identifier:vartype; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:reserved; 215, set; 215, 216; 215, 217; 216, string:'sample'; 217, string:'energy'; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:vectors; 221, dictionary_comprehension; 221, 222; 221, 229; 221, 236; 222, pair; 222, 223; 222, 224; 223, identifier:name; 224, subscript; 224, 225; 224, 228; 225, subscript; 225, 226; 225, 227; 226, identifier:record; 227, identifier:name; 228, identifier:idxs; 229, for_in_clause; 229, 230; 229, 231; 230, identifier:name; 231, attribute; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:record; 234, identifier:dtype; 235, identifier:names; 236, if_clause; 236, 237; 237, comparison_operator:not; 237, 238; 237, 239; 238, identifier:name; 239, identifier:reserved; 240, if_statement; 240, 241; 240, 242; 241, identifier:chain_break_fraction; 242, block; 242, 243; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 248; 245, subscript; 245, 246; 245, 247; 246, identifier:vectors; 247, string:'chain_break_fraction'; 248, subscript; 248, 249; 248, 263; 249, call; 249, 250; 249, 259; 250, attribute; 250, 251; 250, 258; 251, call; 251, 252; 251, 253; 252, identifier:broken_chains; 253, argument_list; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:record; 256, identifier:sample; 257, identifier:chain_idxs; 258, identifier:mean; 259, argument_list; 259, 260; 260, keyword_argument; 260, 261; 260, 262; 261, identifier:axis; 262, integer:1; 263, identifier:idxs; 264, return_statement; 264, 265; 265, call; 265, 266; 265, 271; 266, attribute; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:dimod; 269, identifier:SampleSet; 270, identifier:from_samples; 271, argument_list; 271, 272; 271, 275; 271, 278; 271, 281; 271, 290; 272, tuple; 272, 273; 272, 274; 273, identifier:unembedded; 274, identifier:variables; 275, attribute; 275, 276; 275, 277; 276, identifier:target_sampleset; 277, identifier:vartype; 278, keyword_argument; 278, 279; 278, 280; 279, identifier:energy; 280, identifier:energies; 281, keyword_argument; 281, 282; 281, 283; 282, identifier:info; 283, call; 283, 284; 283, 289; 284, attribute; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:target_sampleset; 287, identifier:info; 288, identifier:copy; 289, argument_list; 290, dictionary_splat; 290, 291; 291, identifier:vectors | def unembed_sampleset(target_sampleset, embedding, source_bqm,
chain_break_method=None, chain_break_fraction=False):
if chain_break_method is None:
chain_break_method = majority_vote
variables = list(source_bqm)
try:
chains = [embedding[v] for v in variables]
except KeyError:
raise ValueError("given bqm does not match the embedding")
chain_idxs = [[target_sampleset.variables.index[v] for v in chain] for chain in chains]
record = target_sampleset.record
unembedded, idxs = chain_break_method(record.sample, chain_idxs)
try:
energies = source_bqm.energies((unembedded, variables))
except ValueError:
datatypes = [('sample', np.dtype(np.int8), (len(variables),)), ('energy', np.float)]
datatypes.extend((name, record[name].dtype, record[name].shape[1:])
for name in record.dtype.names
if name not in {'sample', 'energy'})
if chain_break_fraction:
datatypes.append(('chain_break_fraction', np.float64))
data = np.rec.array(np.empty(0, dtype=datatypes))
return dimod.SampleSet(data, variables, target_sampleset.info.copy(), target_sampleset.vartype)
reserved = {'sample', 'energy'}
vectors = {name: record[name][idxs]
for name in record.dtype.names if name not in reserved}
if chain_break_fraction:
vectors['chain_break_fraction'] = broken_chains(record.sample, chain_idxs).mean(axis=1)[idxs]
return dimod.SampleSet.from_samples((unembedded, variables),
target_sampleset.vartype,
energy=energies,
info=target_sampleset.info.copy(),
**vectors) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:nativeCliqueEmbed; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:width; 6, block; 6, 7; 6, 11; 6, 23; 6, 27; 6, 31; 6, 35; 6, 153; 6, 157; 6, 193; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:maxCWR; 10, dictionary; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 16; 13, pattern_list; 13, 14; 13, 15; 14, identifier:M; 15, identifier:N; 16, expression_list; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:M; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:N; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:maxscore; 26, None; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:count; 30, integer:0; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:key; 34, None; 35, for_statement; 35, 36; 35, 37; 35, 43; 36, identifier:w; 37, call; 37, 38; 37, 39; 38, identifier:range; 39, argument_list; 39, 40; 40, binary_operator:+; 40, 41; 40, 42; 41, identifier:width; 42, integer:2; 43, block; 43, 44; 43, 52; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:h; 47, binary_operator:-; 47, 48; 47, 51; 48, binary_operator:-; 48, 49; 48, 50; 49, identifier:width; 50, identifier:w; 51, integer:2; 52, for_statement; 52, 53; 52, 54; 52, 60; 53, identifier:ymin; 54, call; 54, 55; 54, 56; 55, identifier:range; 56, argument_list; 56, 57; 57, binary_operator:-; 57, 58; 57, 59; 58, identifier:N; 59, identifier:h; 60, block; 60, 61; 60, 67; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:ymax; 64, binary_operator:+; 64, 65; 64, 66; 65, identifier:ymin; 66, identifier:h; 67, for_statement; 67, 68; 67, 69; 67, 75; 68, identifier:xmin; 69, call; 69, 70; 69, 71; 70, identifier:range; 71, argument_list; 71, 72; 72, binary_operator:-; 72, 73; 72, 74; 73, identifier:M; 74, identifier:w; 75, block; 75, 76; 75, 82; 75, 90; 75, 102; 75, 108; 75, 134; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:xmax; 79, binary_operator:+; 79, 80; 79, 81; 80, identifier:xmin; 81, identifier:w; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:R; 85, tuple; 85, 86; 85, 87; 85, 88; 85, 89; 86, identifier:xmin; 87, identifier:xmax; 88, identifier:ymin; 89, identifier:ymax; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 95; 92, pattern_list; 92, 93; 92, 94; 93, identifier:score; 94, identifier:best; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:maxCliqueWithRectangle; 99, argument_list; 99, 100; 99, 101; 100, identifier:R; 101, identifier:maxCWR; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:maxCWR; 106, identifier:R; 107, identifier:best; 108, if_statement; 108, 109; 108, 121; 109, boolean_operator:or; 109, 110; 109, 113; 110, comparison_operator:is; 110, 111; 110, 112; 111, identifier:maxscore; 112, None; 113, parenthesized_expression; 113, 114; 114, boolean_operator:and; 114, 115; 114, 118; 115, comparison_operator:is; 115, 116; 115, 117; 116, identifier:score; 117, None; 118, comparison_operator:<; 118, 119; 118, 120; 119, identifier:maxscore; 120, identifier:score; 121, block; 121, 122; 121, 126; 121, 130; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:maxscore; 125, identifier:score; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:key; 129, None; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:count; 133, integer:0; 134, if_statement; 134, 135; 134, 138; 135, comparison_operator:==; 135, 136; 135, 137; 136, identifier:maxscore; 137, identifier:score; 138, block; 138, 139; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 144; 141, pattern_list; 141, 142; 141, 143; 142, identifier:count; 143, identifier:key; 144, call; 144, 145; 144, 146; 145, identifier:_accumulate_random; 146, argument_list; 146, 147; 146, 148; 146, 151; 146, 152; 147, identifier:count; 148, subscript; 148, 149; 148, 150; 149, identifier:best; 150, integer:3; 151, identifier:key; 152, identifier:R; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:clique; 156, list:[]; 157, while_statement; 157, 158; 157, 161; 158, comparison_operator:in; 158, 159; 158, 160; 159, identifier:key; 160, identifier:maxCWR; 161, block; 161, 162; 161, 172; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 169; 164, pattern_list; 164, 165; 164, 166; 164, 167; 164, 168; 165, identifier:score; 166, identifier:ell; 167, identifier:key; 168, identifier:num; 169, subscript; 169, 170; 169, 171; 170, identifier:maxCWR; 171, identifier:key; 172, if_statement; 172, 173; 172, 176; 173, comparison_operator:is; 173, 174; 173, 175; 174, identifier:ell; 175, None; 176, block; 176, 177; 176, 186; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:meb; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:self; 183, identifier:maximum_ell_bundle; 184, argument_list; 184, 185; 185, identifier:ell; 186, expression_statement; 186, 187; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:clique; 190, identifier:extend; 191, argument_list; 191, 192; 192, identifier:meb; 193, return_statement; 193, 194; 194, expression_list; 194, 195; 194, 196; 195, identifier:maxscore; 196, identifier:clique | def nativeCliqueEmbed(self, width):
maxCWR = {}
M, N = self.M, self.N
maxscore = None
count = 0
key = None
for w in range(width + 2):
h = width - w - 2
for ymin in range(N - h):
ymax = ymin + h
for xmin in range(M - w):
xmax = xmin + w
R = (xmin, xmax, ymin, ymax)
score, best = self.maxCliqueWithRectangle(R, maxCWR)
maxCWR[R] = best
if maxscore is None or (score is not None and maxscore < score):
maxscore = score
key = None
count = 0
if maxscore == score:
count, key = _accumulate_random(count, best[3], key, R)
clique = []
while key in maxCWR:
score, ell, key, num = maxCWR[key]
if ell is not None:
meb = self.maximum_ell_bundle(ell)
clique.extend(meb)
return maxscore, clique |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:find_clique_embedding; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:k; 5, identifier:m; 6, default_parameter; 6, 7; 6, 8; 7, identifier:n; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:t; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:target_edges; 14, None; 15, block; 15, 16; 15, 19; 15, 25; 15, 39; 15, 152; 15, 166; 16, import_statement; 16, 17; 17, dotted_name; 17, 18; 18, identifier:random; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 24; 21, pattern_list; 21, 22; 21, 23; 22, identifier:_; 23, identifier:nodes; 24, identifier:k; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 32; 27, pattern_list; 27, 28; 27, 29; 27, 30; 27, 31; 28, identifier:m; 29, identifier:n; 30, identifier:t; 31, identifier:target_edges; 32, call; 32, 33; 32, 34; 33, identifier:_chimera_input; 34, argument_list; 34, 35; 34, 36; 34, 37; 34, 38; 35, identifier:m; 36, identifier:n; 37, identifier:t; 38, identifier:target_edges; 39, if_statement; 39, 40; 39, 46; 39, 77; 39, 126; 40, comparison_operator:==; 40, 41; 40, 45; 41, call; 41, 42; 41, 43; 42, identifier:len; 43, argument_list; 43, 44; 44, identifier:nodes; 45, integer:1; 46, block; 46, 47; 46, 59; 46, 71; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:qubits; 50, call; 50, 51; 50, 56; 51, attribute; 51, 52; 51, 55; 52, call; 52, 53; 52, 54; 53, identifier:set; 54, argument_list; 55, identifier:union; 56, argument_list; 56, 57; 57, list_splat; 57, 58; 58, identifier:target_edges; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:qubit; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:random; 65, identifier:choice; 66, argument_list; 66, 67; 67, call; 67, 68; 67, 69; 68, identifier:tuple; 69, argument_list; 69, 70; 70, identifier:qubits; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:embedding; 74, list:[[qubit]]; 74, 75; 75, list:[qubit]; 75, 76; 76, identifier:qubit; 77, elif_clause; 77, 78; 77, 84; 78, comparison_operator:==; 78, 79; 78, 83; 79, call; 79, 80; 79, 81; 80, identifier:len; 81, argument_list; 81, 82; 82, identifier:nodes; 83, integer:2; 84, block; 84, 85; 84, 100; 84, 114; 85, if_statement; 85, 86; 85, 92; 86, not_operator; 86, 87; 87, call; 87, 88; 87, 89; 88, identifier:isinstance; 89, argument_list; 89, 90; 89, 91; 90, identifier:target_edges; 91, identifier:list; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:edges; 96, call; 96, 97; 96, 98; 97, identifier:list; 98, argument_list; 98, 99; 99, identifier:target_edges; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:edge; 103, subscript; 103, 104; 103, 105; 104, identifier:edges; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:random; 108, identifier:randrange; 109, argument_list; 109, 110; 110, call; 110, 111; 110, 112; 111, identifier:len; 112, argument_list; 112, 113; 113, identifier:edges; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:embedding; 117, list:[[edge[0]], [edge[1]]]; 117, 118; 117, 122; 118, list:[edge[0]]; 118, 119; 119, subscript; 119, 120; 119, 121; 120, identifier:edge; 121, integer:0; 122, list:[edge[1]]; 122, 123; 123, subscript; 123, 124; 123, 125; 124, identifier:edge; 125, integer:1; 126, else_clause; 126, 127; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:embedding; 131, call; 131, 132; 131, 147; 132, attribute; 132, 133; 132, 146; 133, call; 133, 134; 133, 135; 134, identifier:processor; 135, argument_list; 135, 136; 135, 137; 135, 140; 135, 143; 136, identifier:target_edges; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:M; 139, identifier:m; 140, keyword_argument; 140, 141; 140, 142; 141, identifier:N; 142, identifier:n; 143, keyword_argument; 143, 144; 143, 145; 144, identifier:L; 145, identifier:t; 146, identifier:tightestNativeClique; 147, argument_list; 147, 148; 148, call; 148, 149; 148, 150; 149, identifier:len; 150, argument_list; 150, 151; 151, identifier:nodes; 152, if_statement; 152, 153; 152, 155; 153, not_operator; 153, 154; 154, identifier:embedding; 155, block; 155, 156; 156, raise_statement; 156, 157; 157, call; 157, 158; 157, 159; 158, identifier:ValueError; 159, argument_list; 159, 160; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, string:"cannot find a K{} embedding for given Chimera lattice"; 163, identifier:format; 164, argument_list; 164, 165; 165, identifier:k; 166, return_statement; 166, 167; 167, call; 167, 168; 167, 169; 168, identifier:dict; 169, argument_list; 169, 170; 170, call; 170, 171; 170, 172; 171, identifier:zip; 172, argument_list; 172, 173; 172, 174; 173, identifier:nodes; 174, identifier:embedding | def find_clique_embedding(k, m, n=None, t=None, target_edges=None):
import random
_, nodes = k
m, n, t, target_edges = _chimera_input(m, n, t, target_edges)
if len(nodes) == 1:
qubits = set().union(*target_edges)
qubit = random.choice(tuple(qubits))
embedding = [[qubit]]
elif len(nodes) == 2:
if not isinstance(target_edges, list):
edges = list(target_edges)
edge = edges[random.randrange(len(edges))]
embedding = [[edge[0]], [edge[1]]]
else:
embedding = processor(target_edges, M=m, N=n, L=t).tightestNativeClique(len(nodes))
if not embedding:
raise ValueError("cannot find a K{} embedding for given Chimera lattice".format(k))
return dict(zip(nodes, embedding)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:find_grid_embedding; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:dim; 5, identifier:m; 6, default_parameter; 6, 7; 6, 8; 7, identifier:n; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:t; 11, integer:4; 12, block; 12, 13; 12, 27; 12, 42; 12, 49; 12, 56; 12, 126; 12, 133; 12, 171; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 20; 15, pattern_list; 15, 16; 15, 17; 15, 18; 15, 19; 16, identifier:m; 17, identifier:n; 18, identifier:t; 19, identifier:target_edges; 20, call; 20, 21; 20, 22; 21, identifier:_chimera_input; 22, argument_list; 22, 23; 22, 24; 22, 25; 22, 26; 23, identifier:m; 24, identifier:n; 25, identifier:t; 26, None; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:indexer; 30, call; 30, 31; 30, 38; 31, attribute; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:dnx; 35, identifier:generators; 36, identifier:chimera; 37, identifier:chimera_coordinates; 38, argument_list; 38, 39; 38, 40; 38, 41; 39, identifier:m; 40, identifier:n; 41, identifier:t; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:dim; 45, call; 45, 46; 45, 47; 46, identifier:list; 47, argument_list; 47, 48; 48, identifier:dim; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:num_dim; 52, call; 52, 53; 52, 54; 53, identifier:len; 54, argument_list; 54, 55; 55, identifier:dim; 56, if_statement; 56, 57; 56, 60; 56, 79; 56, 102; 56, 119; 57, comparison_operator:==; 57, 58; 57, 59; 58, identifier:num_dim; 59, integer:1; 60, block; 60, 61; 60, 70; 61, function_definition; 61, 62; 61, 63; 61, 67; 62, function_name:_key; 63, parameters; 63, 64; 63, 65; 63, 66; 64, identifier:row; 65, identifier:col; 66, identifier:aisle; 67, block; 67, 68; 68, return_statement; 68, 69; 69, identifier:row; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:dim; 74, identifier:extend; 75, argument_list; 75, 76; 76, list:[1, 1]; 76, 77; 76, 78; 77, integer:1; 78, integer:1; 79, elif_clause; 79, 80; 79, 83; 80, comparison_operator:==; 80, 81; 80, 82; 81, identifier:num_dim; 82, integer:2; 83, block; 83, 84; 83, 95; 84, function_definition; 84, 85; 84, 86; 84, 90; 85, function_name:_key; 86, parameters; 86, 87; 86, 88; 86, 89; 87, identifier:row; 88, identifier:col; 89, identifier:aisle; 90, block; 90, 91; 91, return_statement; 91, 92; 92, expression_list; 92, 93; 92, 94; 93, identifier:row; 94, identifier:col; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:dim; 99, identifier:append; 100, argument_list; 100, 101; 101, integer:1; 102, elif_clause; 102, 103; 102, 106; 103, comparison_operator:==; 103, 104; 103, 105; 104, identifier:num_dim; 105, integer:3; 106, block; 106, 107; 107, function_definition; 107, 108; 107, 109; 107, 113; 108, function_name:_key; 109, parameters; 109, 110; 109, 111; 109, 112; 110, identifier:row; 111, identifier:col; 112, identifier:aisle; 113, block; 113, 114; 114, return_statement; 114, 115; 115, expression_list; 115, 116; 115, 117; 115, 118; 116, identifier:row; 117, identifier:col; 118, identifier:aisle; 119, else_clause; 119, 120; 120, block; 120, 121; 121, raise_statement; 121, 122; 122, call; 122, 123; 122, 124; 123, identifier:ValueError; 124, argument_list; 124, 125; 125, string:"find_grid_embedding supports between one and three dimensions"; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 132; 128, pattern_list; 128, 129; 128, 130; 128, 131; 129, identifier:rows; 130, identifier:cols; 131, identifier:aisles; 132, identifier:dim; 133, if_statement; 133, 134; 133, 145; 134, boolean_operator:or; 134, 135; 134, 142; 135, boolean_operator:or; 135, 136; 135, 139; 136, comparison_operator:>; 136, 137; 136, 138; 137, identifier:rows; 138, identifier:m; 139, comparison_operator:>; 139, 140; 139, 141; 140, identifier:cols; 141, identifier:n; 142, comparison_operator:>; 142, 143; 142, 144; 143, identifier:aisles; 144, identifier:t; 145, block; 145, 146; 145, 166; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:msg; 149, call; 149, 150; 149, 156; 150, attribute; 150, 151; 150, 155; 151, parenthesized_expression; 151, 152; 152, concatenated_string; 152, 153; 152, 154; 153, string:"the largest grid that find_grid_embedding can fit in a ({}, {}, {}) Chimera-lattice "; 154, string:"is {}x{}x{}; given grid is {}x{}x{}"; 155, identifier:format; 156, argument_list; 156, 157; 156, 158; 156, 159; 156, 160; 156, 161; 156, 162; 156, 163; 156, 164; 156, 165; 157, identifier:m; 158, identifier:n; 159, identifier:t; 160, identifier:m; 161, identifier:n; 162, identifier:t; 163, identifier:rows; 164, identifier:cols; 165, identifier:aisles; 166, raise_statement; 166, 167; 167, call; 167, 168; 167, 169; 168, identifier:ValueError; 169, argument_list; 169, 170; 170, identifier:msg; 171, return_statement; 171, 172; 172, dictionary_comprehension; 172, 173; 172, 201; 172, 209; 172, 217; 173, pair; 173, 174; 173, 180; 174, call; 174, 175; 174, 176; 175, identifier:_key; 176, argument_list; 176, 177; 176, 178; 176, 179; 177, identifier:row; 178, identifier:col; 179, identifier:aisle; 180, list:[indexer.int((row, col, 0, aisle)), indexer.int((row, col, 1, aisle))]; 180, 181; 180, 191; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:indexer; 184, identifier:int; 185, argument_list; 185, 186; 186, tuple; 186, 187; 186, 188; 186, 189; 186, 190; 187, identifier:row; 188, identifier:col; 189, integer:0; 190, identifier:aisle; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:indexer; 194, identifier:int; 195, argument_list; 195, 196; 196, tuple; 196, 197; 196, 198; 196, 199; 196, 200; 197, identifier:row; 198, identifier:col; 199, integer:1; 200, identifier:aisle; 201, for_in_clause; 201, 202; 201, 203; 202, identifier:row; 203, call; 203, 204; 203, 205; 204, identifier:range; 205, argument_list; 205, 206; 206, subscript; 206, 207; 206, 208; 207, identifier:dim; 208, integer:0; 209, for_in_clause; 209, 210; 209, 211; 210, identifier:col; 211, call; 211, 212; 211, 213; 212, identifier:range; 213, argument_list; 213, 214; 214, subscript; 214, 215; 214, 216; 215, identifier:dim; 216, integer:1; 217, for_in_clause; 217, 218; 217, 219; 218, identifier:aisle; 219, call; 219, 220; 219, 221; 220, identifier:range; 221, argument_list; 221, 222; 222, subscript; 222, 223; 222, 224; 223, identifier:dim; 224, integer:2 | def find_grid_embedding(dim, m, n=None, t=4):
m, n, t, target_edges = _chimera_input(m, n, t, None)
indexer = dnx.generators.chimera.chimera_coordinates(m, n, t)
dim = list(dim)
num_dim = len(dim)
if num_dim == 1:
def _key(row, col, aisle): return row
dim.extend([1, 1])
elif num_dim == 2:
def _key(row, col, aisle): return row, col
dim.append(1)
elif num_dim == 3:
def _key(row, col, aisle): return row, col, aisle
else:
raise ValueError("find_grid_embedding supports between one and three dimensions")
rows, cols, aisles = dim
if rows > m or cols > n or aisles > t:
msg = ("the largest grid that find_grid_embedding can fit in a ({}, {}, {}) Chimera-lattice "
"is {}x{}x{}; given grid is {}x{}x{}").format(m, n, t, m, n, t, rows, cols, aisles)
raise ValueError(msg)
return {_key(row, col, aisle): [indexer.int((row, col, 0, aisle)), indexer.int((row, col, 1, aisle))]
for row in range(dim[0]) for col in range(dim[1]) for aisle in range(dim[2])} |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sample; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:bqm; 6, dictionary_splat_pattern; 6, 7; 7, identifier:parameters; 8, block; 8, 9; 8, 15; 8, 21; 8, 27; 8, 33; 8, 54; 8, 100; 8, 115; 8, 122; 8, 152; 8, 173; 8, 203; 8, 209; 8, 216; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:child; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:child; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:cutoff; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_cutoff; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:cutoff_vartype; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_cutoff_vartype; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:comp; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_comparison; 33, if_statement; 33, 34; 33, 39; 33, 46; 34, comparison_operator:is; 34, 35; 34, 36; 35, identifier:cutoff_vartype; 36, attribute; 36, 37; 36, 38; 37, identifier:dimod; 38, identifier:SPIN; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:original; 43, attribute; 43, 44; 43, 45; 44, identifier:bqm; 45, identifier:spin; 46, else_clause; 46, 47; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:original; 51, attribute; 51, 52; 51, 53; 52, identifier:bqm; 53, identifier:binary; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:new; 57, call; 57, 58; 57, 62; 58, call; 58, 59; 58, 60; 59, identifier:type; 60, argument_list; 60, 61; 61, identifier:bqm; 62, argument_list; 62, 63; 62, 66; 62, 94; 62, 97; 63, attribute; 63, 64; 63, 65; 64, identifier:original; 65, identifier:linear; 66, generator_expression; 66, 67; 66, 71; 66, 84; 67, tuple; 67, 68; 67, 69; 67, 70; 68, identifier:u; 69, identifier:v; 70, identifier:bias; 71, for_in_clause; 71, 72; 71, 77; 72, pattern_list; 72, 73; 72, 76; 73, tuple_pattern; 73, 74; 73, 75; 74, identifier:u; 75, identifier:v; 76, identifier:bias; 77, call; 77, 78; 77, 83; 78, attribute; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:original; 81, identifier:quadratic; 82, identifier:items; 83, argument_list; 84, if_clause; 84, 85; 85, not_operator; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:comp; 88, argument_list; 88, 89; 88, 93; 89, call; 89, 90; 89, 91; 90, identifier:abs; 91, argument_list; 91, 92; 92, identifier:bias; 93, identifier:cutoff; 94, attribute; 94, 95; 94, 96; 95, identifier:original; 96, identifier:offset; 97, attribute; 97, 98; 97, 99; 98, identifier:original; 99, identifier:vartype; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:isolated; 103, list_comprehension; 103, 104; 103, 105; 103, 108; 104, identifier:v; 105, for_in_clause; 105, 106; 105, 107; 106, identifier:v; 107, identifier:new; 108, if_clause; 108, 109; 109, not_operator; 109, 110; 110, subscript; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:new; 113, identifier:adj; 114, identifier:v; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:new; 119, identifier:remove_variables_from; 120, argument_list; 120, 121; 121, identifier:isolated; 122, if_statement; 122, 123; 122, 131; 123, boolean_operator:and; 123, 124; 123, 125; 124, identifier:isolated; 125, comparison_operator:==; 125, 126; 125, 130; 126, call; 126, 127; 126, 128; 127, identifier:len; 128, argument_list; 128, 129; 129, identifier:new; 130, integer:0; 131, block; 131, 132; 131, 140; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:v; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:isolated; 138, identifier:pop; 139, argument_list; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 147; 142, subscript; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:new; 145, identifier:linear; 146, identifier:v; 147, subscript; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:original; 150, identifier:linear; 151, identifier:v; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:sampleset; 155, call; 155, 156; 155, 166; 156, attribute; 156, 157; 156, 165; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:child; 160, identifier:sample; 161, argument_list; 161, 162; 161, 163; 162, identifier:new; 163, dictionary_splat; 163, 164; 164, identifier:parameters; 165, identifier:change_vartype; 166, argument_list; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:bqm; 169, identifier:vartype; 170, keyword_argument; 170, 171; 170, 172; 171, identifier:inplace; 172, True; 173, if_statement; 173, 174; 173, 175; 173, 187; 174, identifier:isolated; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 181; 178, pattern_list; 178, 179; 178, 180; 179, identifier:samples; 180, identifier:variables; 181, call; 181, 182; 181, 183; 182, identifier:_restore_isolated; 183, argument_list; 183, 184; 183, 185; 183, 186; 184, identifier:sampleset; 185, identifier:bqm; 186, identifier:isolated; 187, else_clause; 187, 188; 188, block; 188, 189; 188, 197; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:samples; 192, attribute; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:sampleset; 195, identifier:record; 196, identifier:sample; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 200; 199, identifier:variables; 200, attribute; 200, 201; 200, 202; 201, identifier:sampleset; 202, identifier:variables; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:vectors; 206, attribute; 206, 207; 206, 208; 207, identifier:sampleset; 208, identifier:data_vectors; 209, expression_statement; 209, 210; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:vectors; 213, identifier:pop; 214, argument_list; 214, 215; 215, string:'energy'; 216, return_statement; 216, 217; 217, call; 217, 218; 217, 223; 218, attribute; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:dimod; 221, identifier:SampleSet; 222, identifier:from_samples_bqm; 223, argument_list; 223, 224; 223, 227; 223, 228; 224, tuple; 224, 225; 224, 226; 225, identifier:samples; 226, identifier:variables; 227, identifier:bqm; 228, dictionary_splat; 228, 229; 229, identifier:vectors | def sample(self, bqm, **parameters):
child = self.child
cutoff = self._cutoff
cutoff_vartype = self._cutoff_vartype
comp = self._comparison
if cutoff_vartype is dimod.SPIN:
original = bqm.spin
else:
original = bqm.binary
new = type(bqm)(original.linear,
((u, v, bias)
for (u, v), bias in original.quadratic.items()
if not comp(abs(bias), cutoff)),
original.offset,
original.vartype)
isolated = [v for v in new if not new.adj[v]]
new.remove_variables_from(isolated)
if isolated and len(new) == 0:
v = isolated.pop()
new.linear[v] = original.linear[v]
sampleset = child.sample(new, **parameters).change_vartype(bqm.vartype, inplace=True)
if isolated:
samples, variables = _restore_isolated(sampleset, bqm, isolated)
else:
samples = sampleset.record.sample
variables = sampleset.variables
vectors = sampleset.data_vectors
vectors.pop('energy')
return dimod.SampleSet.from_samples_bqm((samples, variables), bqm, **vectors) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sample_poly; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:poly; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 15; 8, 21; 8, 27; 8, 33; 8, 64; 8, 104; 8, 128; 8, 144; 8, 171; 8, 192; 8, 222; 8, 228; 8, 235; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:child; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:child; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:cutoff; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_cutoff; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:cutoff_vartype; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_cutoff_vartype; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:comp; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_comparison; 33, if_statement; 33, 34; 33, 39; 33, 51; 34, comparison_operator:is; 34, 35; 34, 36; 35, identifier:cutoff_vartype; 36, attribute; 36, 37; 36, 38; 37, identifier:dimod; 38, identifier:SPIN; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:original; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:poly; 46, identifier:to_spin; 47, argument_list; 47, 48; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:copy; 50, False; 51, else_clause; 51, 52; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:original; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:poly; 59, identifier:to_binary; 60, argument_list; 60, 61; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:copy; 63, False; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:new; 67, call; 67, 68; 67, 72; 68, call; 68, 69; 68, 70; 69, identifier:type; 70, argument_list; 70, 71; 71, identifier:poly; 72, argument_list; 72, 73; 72, 103; 73, generator_expression; 73, 74; 73, 77; 73, 86; 74, tuple; 74, 75; 74, 76; 75, identifier:term; 76, identifier:bias; 77, for_in_clause; 77, 78; 77, 81; 78, pattern_list; 78, 79; 78, 80; 79, identifier:term; 80, identifier:bias; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:original; 84, identifier:items; 85, argument_list; 86, if_clause; 86, 87; 87, boolean_operator:and; 87, 88; 87, 94; 88, comparison_operator:>; 88, 89; 88, 93; 89, call; 89, 90; 89, 91; 90, identifier:len; 91, argument_list; 91, 92; 92, identifier:term; 93, integer:1; 94, not_operator; 94, 95; 95, call; 95, 96; 95, 97; 96, identifier:comp; 97, argument_list; 97, 98; 97, 102; 98, call; 98, 99; 98, 100; 99, identifier:abs; 100, argument_list; 100, 101; 101, identifier:bias; 102, identifier:cutoff; 103, identifier:cutoff_vartype; 104, for_statement; 104, 105; 104, 106; 104, 109; 105, identifier:v; 106, attribute; 106, 107; 106, 108; 107, identifier:new; 108, identifier:variables; 109, block; 109, 110; 109, 115; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:term; 113, expression_list; 113, 114; 114, identifier:v; 115, if_statement; 115, 116; 115, 119; 116, comparison_operator:in; 116, 117; 116, 118; 117, identifier:term; 118, identifier:original; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 125; 122, subscript; 122, 123; 122, 124; 123, identifier:new; 124, identifier:term; 125, subscript; 125, 126; 125, 127; 126, identifier:original; 127, identifier:term; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:isolated; 131, call; 131, 132; 131, 133; 132, identifier:list; 133, argument_list; 133, 134; 134, call; 134, 135; 134, 140; 135, attribute; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:original; 138, identifier:variables; 139, identifier:difference; 140, argument_list; 140, 141; 141, attribute; 141, 142; 141, 143; 142, identifier:new; 143, identifier:variables; 144, if_statement; 144, 145; 144, 153; 145, boolean_operator:and; 145, 146; 145, 147; 146, identifier:isolated; 147, comparison_operator:==; 147, 148; 147, 152; 148, call; 148, 149; 148, 150; 149, identifier:len; 150, argument_list; 150, 151; 151, identifier:new; 152, integer:0; 153, block; 153, 154; 153, 163; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:term; 157, expression_list; 157, 158; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:isolated; 161, identifier:pop; 162, argument_list; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 168; 165, subscript; 165, 166; 165, 167; 166, identifier:new; 167, identifier:term; 168, subscript; 168, 169; 168, 170; 169, identifier:original; 170, identifier:term; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:sampleset; 174, call; 174, 175; 174, 185; 175, attribute; 175, 176; 175, 184; 176, call; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:child; 179, identifier:sample_poly; 180, argument_list; 180, 181; 180, 182; 181, identifier:new; 182, dictionary_splat; 182, 183; 183, identifier:kwargs; 184, identifier:change_vartype; 185, argument_list; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:poly; 188, identifier:vartype; 189, keyword_argument; 189, 190; 189, 191; 190, identifier:inplace; 191, True; 192, if_statement; 192, 193; 192, 194; 192, 206; 193, identifier:isolated; 194, block; 194, 195; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 200; 197, pattern_list; 197, 198; 197, 199; 198, identifier:samples; 199, identifier:variables; 200, call; 200, 201; 200, 202; 201, identifier:_restore_isolated_higherorder; 202, argument_list; 202, 203; 202, 204; 202, 205; 203, identifier:sampleset; 204, identifier:poly; 205, identifier:isolated; 206, else_clause; 206, 207; 207, block; 207, 208; 207, 216; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:samples; 211, attribute; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:sampleset; 214, identifier:record; 215, identifier:sample; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:variables; 219, attribute; 219, 220; 219, 221; 220, identifier:sampleset; 221, identifier:variables; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:vectors; 225, attribute; 225, 226; 225, 227; 226, identifier:sampleset; 227, identifier:data_vectors; 228, expression_statement; 228, 229; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:vectors; 232, identifier:pop; 233, argument_list; 233, 234; 234, string:'energy'; 235, return_statement; 235, 236; 236, call; 236, 237; 236, 242; 237, attribute; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:dimod; 240, identifier:SampleSet; 241, identifier:from_samples_bqm; 242, argument_list; 242, 243; 242, 246; 242, 247; 243, tuple; 243, 244; 243, 245; 244, identifier:samples; 245, identifier:variables; 246, identifier:poly; 247, dictionary_splat; 247, 248; 248, identifier:vectors | def sample_poly(self, poly, **kwargs):
child = self.child
cutoff = self._cutoff
cutoff_vartype = self._cutoff_vartype
comp = self._comparison
if cutoff_vartype is dimod.SPIN:
original = poly.to_spin(copy=False)
else:
original = poly.to_binary(copy=False)
new = type(poly)(((term, bias) for term, bias in original.items()
if len(term) > 1 and not comp(abs(bias), cutoff)),
cutoff_vartype)
for v in new.variables:
term = v,
if term in original:
new[term] = original[term]
isolated = list(original.variables.difference(new.variables))
if isolated and len(new) == 0:
term = isolated.pop(),
new[term] = original[term]
sampleset = child.sample_poly(new, **kwargs).change_vartype(poly.vartype, inplace=True)
if isolated:
samples, variables = _restore_isolated_higherorder(sampleset, poly, isolated)
else:
samples = sampleset.record.sample
variables = sampleset.variables
vectors = sampleset.data_vectors
vectors.pop('energy')
return dimod.SampleSet.from_samples_bqm((samples, variables), poly, **vectors) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:diagnose_embedding; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:emb; 5, identifier:source; 6, identifier:target; 7, block; 7, 8; 7, 25; 7, 42; 7, 46; 7, 52; 7, 169; 7, 177; 7, 204; 8, if_statement; 8, 9; 8, 15; 9, not_operator; 9, 10; 10, call; 10, 11; 10, 12; 11, identifier:hasattr; 12, argument_list; 12, 13; 12, 14; 13, identifier:source; 14, string:'edges'; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:source; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:nx; 22, identifier:Graph; 23, argument_list; 23, 24; 24, identifier:source; 25, if_statement; 25, 26; 25, 32; 26, not_operator; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:hasattr; 29, argument_list; 29, 30; 29, 31; 30, identifier:target; 31, string:'edges'; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:target; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:nx; 39, identifier:Graph; 40, argument_list; 40, 41; 41, identifier:target; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:label; 45, dictionary; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:embedded; 49, call; 49, 50; 49, 51; 50, identifier:set; 51, argument_list; 52, for_statement; 52, 53; 52, 54; 52, 55; 53, identifier:x; 54, identifier:source; 55, block; 55, 56; 55, 80; 55, 89; 55, 93; 55, 140; 56, try_statement; 56, 57; 56, 73; 57, block; 57, 58; 57, 64; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:embx; 61, subscript; 61, 62; 61, 63; 62, identifier:emb; 63, identifier:x; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:missing_chain; 67, comparison_operator:==; 67, 68; 67, 72; 68, call; 68, 69; 68, 70; 69, identifier:len; 70, argument_list; 70, 71; 71, identifier:embx; 72, integer:0; 73, except_clause; 73, 74; 73, 75; 74, identifier:KeyError; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:missing_chain; 79, True; 80, if_statement; 80, 81; 80, 82; 81, identifier:missing_chain; 82, block; 82, 83; 82, 88; 83, expression_statement; 83, 84; 84, yield; 84, 85; 85, expression_list; 85, 86; 85, 87; 86, identifier:MissingChainError; 87, identifier:x; 88, continue_statement; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:all_present; 92, True; 93, for_statement; 93, 94; 93, 95; 93, 96; 94, identifier:q; 95, identifier:embx; 96, block; 96, 97; 97, if_statement; 97, 98; 97, 107; 97, 117; 97, 132; 98, comparison_operator:!=; 98, 99; 98, 106; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:label; 102, identifier:get; 103, argument_list; 103, 104; 103, 105; 104, identifier:q; 105, identifier:x; 106, identifier:x; 107, block; 107, 108; 108, expression_statement; 108, 109; 109, yield; 109, 110; 110, expression_list; 110, 111; 110, 112; 110, 113; 110, 114; 111, identifier:ChainOverlapError; 112, identifier:q; 113, identifier:x; 114, subscript; 114, 115; 114, 116; 115, identifier:label; 116, identifier:q; 117, elif_clause; 117, 118; 117, 121; 118, comparison_operator:not; 118, 119; 118, 120; 119, identifier:q; 120, identifier:target; 121, block; 121, 122; 121, 126; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:all_present; 125, False; 126, expression_statement; 126, 127; 127, yield; 127, 128; 128, expression_list; 128, 129; 128, 130; 128, 131; 129, identifier:InvalidNodeError; 130, identifier:x; 131, identifier:q; 132, else_clause; 132, 133; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 139; 136, subscript; 136, 137; 136, 138; 137, identifier:label; 138, identifier:q; 139, identifier:x; 140, if_statement; 140, 141; 140, 142; 141, identifier:all_present; 142, block; 142, 143; 142, 150; 143, expression_statement; 143, 144; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:embedded; 147, identifier:add; 148, argument_list; 148, 149; 149, identifier:x; 150, if_statement; 150, 151; 150, 163; 151, not_operator; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:nx; 155, identifier:is_connected; 156, argument_list; 156, 157; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:target; 160, identifier:subgraph; 161, argument_list; 161, 162; 162, identifier:embx; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, yield; 165, 166; 166, expression_list; 166, 167; 166, 168; 167, identifier:DisconnectedChainError; 168, identifier:x; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:yielded; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:nx; 175, identifier:Graph; 176, argument_list; 177, for_statement; 177, 178; 177, 181; 177, 191; 178, pattern_list; 178, 179; 178, 180; 179, identifier:p; 180, identifier:q; 181, call; 181, 182; 181, 190; 182, attribute; 182, 183; 182, 189; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:target; 186, identifier:subgraph; 187, argument_list; 187, 188; 188, identifier:label; 189, identifier:edges; 190, argument_list; 191, block; 191, 192; 192, expression_statement; 192, 193; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:yielded; 196, identifier:add_edge; 197, argument_list; 197, 198; 197, 201; 198, subscript; 198, 199; 198, 200; 199, identifier:label; 200, identifier:p; 201, subscript; 201, 202; 201, 203; 202, identifier:label; 203, identifier:q; 204, for_statement; 204, 205; 204, 208; 204, 213; 205, pattern_list; 205, 206; 205, 207; 206, identifier:x; 207, identifier:y; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:source; 211, identifier:edges; 212, argument_list; 213, block; 213, 214; 213, 220; 214, if_statement; 214, 215; 214, 218; 215, comparison_operator:==; 215, 216; 215, 217; 216, identifier:x; 217, identifier:y; 218, block; 218, 219; 219, continue_statement; 220, if_statement; 220, 221; 220, 237; 221, boolean_operator:and; 221, 222; 221, 229; 222, boolean_operator:and; 222, 223; 222, 226; 223, comparison_operator:in; 223, 224; 223, 225; 224, identifier:x; 225, identifier:embedded; 226, comparison_operator:in; 226, 227; 226, 228; 227, identifier:y; 228, identifier:embedded; 229, not_operator; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:yielded; 233, identifier:has_edge; 234, argument_list; 234, 235; 234, 236; 235, identifier:x; 236, identifier:y; 237, block; 237, 238; 238, expression_statement; 238, 239; 239, yield; 239, 240; 240, expression_list; 240, 241; 240, 242; 240, 243; 241, identifier:MissingEdgeError; 242, identifier:x; 243, identifier:y | def diagnose_embedding(emb, source, target):
if not hasattr(source, 'edges'):
source = nx.Graph(source)
if not hasattr(target, 'edges'):
target = nx.Graph(target)
label = {}
embedded = set()
for x in source:
try:
embx = emb[x]
missing_chain = len(embx) == 0
except KeyError:
missing_chain = True
if missing_chain:
yield MissingChainError, x
continue
all_present = True
for q in embx:
if label.get(q, x) != x:
yield ChainOverlapError, q, x, label[q]
elif q not in target:
all_present = False
yield InvalidNodeError, x, q
else:
label[q] = x
if all_present:
embedded.add(x)
if not nx.is_connected(target.subgraph(embx)):
yield DisconnectedChainError, x
yielded = nx.Graph()
for p, q in target.subgraph(label).edges():
yielded.add_edge(label[p], label[q])
for x, y in source.edges():
if x == y:
continue
if x in embedded and y in embedded and not yielded.has_edge(x, y):
yield MissingEdgeError, x, y |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:response; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 13; 3, 16; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:model; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:code; 10, attribute; 10, 11; 10, 12; 11, identifier:HTTPStatus; 12, identifier:OK; 13, default_parameter; 13, 14; 13, 15; 14, identifier:description; 15, None; 16, dictionary_splat_pattern; 16, 17; 17, identifier:kwargs; 18, block; 18, 19; 18, 26; 18, 37; 18, 89; 18, 100; 18, 217; 18, 339; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:code; 22, call; 22, 23; 22, 24; 23, identifier:HTTPStatus; 24, argument_list; 24, 25; 25, identifier:code; 26, if_statement; 26, 27; 26, 32; 27, comparison_operator:is; 27, 28; 27, 29; 28, identifier:code; 29, attribute; 29, 30; 29, 31; 30, identifier:HTTPStatus; 31, identifier:NO_CONTENT; 32, block; 32, 33; 33, assert_statement; 33, 34; 34, comparison_operator:is; 34, 35; 34, 36; 35, identifier:model; 36, None; 37, if_statement; 37, 38; 37, 51; 38, boolean_operator:and; 38, 39; 38, 42; 39, comparison_operator:is; 39, 40; 39, 41; 40, identifier:model; 41, None; 42, comparison_operator:not; 42, 43; 42, 44; 43, identifier:code; 44, set; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:HTTPStatus; 47, identifier:ACCEPTED; 48, attribute; 48, 49; 48, 50; 49, identifier:HTTPStatus; 50, identifier:NO_CONTENT; 51, block; 51, 52; 51, 68; 52, if_statement; 52, 53; 52, 60; 53, comparison_operator:not; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:code; 56, identifier:value; 57, attribute; 57, 58; 57, 59; 58, identifier:http_exceptions; 59, identifier:default_exceptions; 60, block; 60, 61; 61, raise_statement; 61, 62; 62, call; 62, 63; 62, 64; 63, identifier:ValueError; 64, argument_list; 64, 65; 65, binary_operator:%; 65, 66; 65, 67; 66, string:"`model` parameter is required for code %d"; 67, identifier:code; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:model; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:model; 75, argument_list; 75, 76; 75, 81; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:name; 78, binary_operator:%; 78, 79; 78, 80; 79, string:'HTTPError%d'; 80, identifier:code; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:model; 83, call; 83, 84; 83, 85; 84, identifier:DefaultHTTPErrorSchema; 85, argument_list; 85, 86; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:http_code; 88, identifier:code; 89, if_statement; 89, 90; 89, 93; 90, comparison_operator:is; 90, 91; 90, 92; 91, identifier:description; 92, None; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:description; 97, attribute; 97, 98; 97, 99; 98, identifier:code; 99, identifier:description; 100, function_definition; 100, 101; 100, 102; 100, 104; 101, function_name:response_serializer_decorator; 102, parameters; 102, 103; 103, identifier:func; 104, block; 104, 105; 104, 215; 105, function_definition; 105, 106; 105, 107; 105, 112; 106, function_name:dump_wrapper; 107, parameters; 107, 108; 107, 110; 108, list_splat_pattern; 108, 109; 109, identifier:args; 110, dictionary_splat_pattern; 110, 111; 111, identifier:kwargs; 112, block; 112, 113; 112, 123; 112, 127; 112, 191; 112, 210; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:response; 116, call; 116, 117; 116, 118; 117, identifier:func; 118, argument_list; 118, 119; 118, 121; 119, list_splat; 119, 120; 120, identifier:args; 121, dictionary_splat; 121, 122; 122, identifier:kwargs; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:extra_headers; 126, None; 127, if_statement; 127, 128; 127, 131; 127, 153; 127, 168; 127, 185; 128, comparison_operator:is; 128, 129; 128, 130; 129, identifier:response; 130, None; 131, block; 131, 132; 131, 144; 132, if_statement; 132, 133; 132, 136; 133, comparison_operator:is; 133, 134; 133, 135; 134, identifier:model; 135, None; 136, block; 136, 137; 137, raise_statement; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:ValueError; 140, argument_list; 140, 141; 141, binary_operator:%; 141, 142; 141, 143; 142, string:"Response cannot not be None with HTTP status %d"; 143, identifier:code; 144, return_statement; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:flask; 148, identifier:Response; 149, argument_list; 149, 150; 150, keyword_argument; 150, 151; 150, 152; 151, identifier:status; 152, identifier:code; 153, elif_clause; 153, 154; 153, 165; 154, boolean_operator:or; 154, 155; 154, 162; 155, call; 155, 156; 155, 157; 156, identifier:isinstance; 157, argument_list; 157, 158; 157, 159; 158, identifier:response; 159, attribute; 159, 160; 159, 161; 160, identifier:flask; 161, identifier:Response; 162, comparison_operator:is; 162, 163; 162, 164; 163, identifier:model; 164, None; 165, block; 165, 166; 166, return_statement; 166, 167; 167, identifier:response; 168, elif_clause; 168, 169; 168, 174; 169, call; 169, 170; 169, 171; 170, identifier:isinstance; 171, argument_list; 171, 172; 171, 173; 172, identifier:response; 173, identifier:tuple; 174, block; 174, 175; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 181; 177, pattern_list; 177, 178; 177, 179; 177, 180; 178, identifier:response; 179, identifier:_code; 180, identifier:extra_headers; 181, call; 181, 182; 181, 183; 182, identifier:unpack; 183, argument_list; 183, 184; 184, identifier:response; 185, else_clause; 185, 186; 186, block; 186, 187; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:_code; 190, identifier:code; 191, if_statement; 191, 192; 191, 198; 192, comparison_operator:is; 192, 193; 192, 197; 193, call; 193, 194; 193, 195; 194, identifier:HTTPStatus; 195, argument_list; 195, 196; 196, identifier:_code; 197, identifier:code; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:response; 202, attribute; 202, 203; 202, 209; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:model; 206, identifier:dump; 207, argument_list; 207, 208; 208, identifier:response; 209, identifier:data; 210, return_statement; 210, 211; 211, expression_list; 211, 212; 211, 213; 211, 214; 212, identifier:response; 213, identifier:_code; 214, identifier:extra_headers; 215, return_statement; 215, 216; 216, identifier:dump_wrapper; 217, function_definition; 217, 218; 217, 219; 217, 221; 218, function_name:decorator; 219, parameters; 219, 220; 220, identifier:func_or_class; 221, block; 221, 222; 221, 268; 221, 316; 221, 334; 222, if_statement; 222, 223; 222, 230; 222, 235; 222, 253; 223, comparison_operator:in; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:code; 226, identifier:value; 227, attribute; 227, 228; 227, 229; 228, identifier:http_exceptions; 229, identifier:default_exceptions; 230, block; 230, 231; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 234; 233, identifier:decorated_func_or_class; 234, identifier:func_or_class; 235, elif_clause; 235, 236; 235, 241; 236, call; 236, 237; 236, 238; 237, identifier:isinstance; 238, argument_list; 238, 239; 238, 240; 239, identifier:func_or_class; 240, identifier:type; 241, block; 241, 242; 241, 249; 242, expression_statement; 242, 243; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:func_or_class; 246, identifier:_apply_decorator_to_methods; 247, argument_list; 247, 248; 248, identifier:response_serializer_decorator; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:decorated_func_or_class; 252, identifier:func_or_class; 253, else_clause; 253, 254; 254, block; 254, 255; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:decorated_func_or_class; 258, call; 258, 259; 258, 263; 259, call; 259, 260; 259, 261; 260, identifier:wraps; 261, argument_list; 261, 262; 262, identifier:func_or_class; 263, argument_list; 263, 264; 264, call; 264, 265; 264, 266; 265, identifier:response_serializer_decorator; 266, argument_list; 266, 267; 267, identifier:func_or_class; 268, if_statement; 268, 269; 268, 272; 268, 277; 269, comparison_operator:is; 269, 270; 269, 271; 270, identifier:model; 271, None; 272, block; 272, 273; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:api_model; 276, None; 277, else_clause; 277, 278; 278, block; 278, 279; 278, 303; 279, if_statement; 279, 280; 279, 285; 279, 290; 280, call; 280, 281; 280, 282; 281, identifier:isinstance; 282, argument_list; 282, 283; 282, 284; 283, identifier:model; 284, identifier:Model; 285, block; 285, 286; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 288, identifier:api_model; 289, identifier:model; 290, else_clause; 290, 291; 291, block; 291, 292; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 295; 294, identifier:api_model; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:self; 298, identifier:model; 299, argument_list; 299, 300; 300, keyword_argument; 300, 301; 300, 302; 301, identifier:model; 302, identifier:model; 303, if_statement; 303, 304; 303, 310; 304, call; 304, 305; 304, 306; 305, identifier:getattr; 306, argument_list; 306, 307; 306, 308; 306, 309; 307, identifier:model; 308, string:'many'; 309, False; 310, block; 310, 311; 311, expression_statement; 311, 312; 312, assignment; 312, 313; 312, 314; 313, identifier:api_model; 314, list:[api_model]; 314, 315; 315, identifier:api_model; 316, expression_statement; 316, 317; 317, assignment; 317, 318; 317, 319; 318, identifier:doc_decorator; 319, call; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:self; 322, identifier:doc; 323, argument_list; 323, 324; 324, keyword_argument; 324, 325; 324, 326; 325, identifier:responses; 326, dictionary; 326, 327; 327, pair; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:code; 330, identifier:value; 331, tuple; 331, 332; 331, 333; 332, identifier:description; 333, identifier:api_model; 334, return_statement; 334, 335; 335, call; 335, 336; 335, 337; 336, identifier:doc_decorator; 337, argument_list; 337, 338; 338, identifier:decorated_func_or_class; 339, return_statement; 339, 340; 340, identifier:decorator | def response(self, model=None, code=HTTPStatus.OK, description=None, **kwargs):
code = HTTPStatus(code)
if code is HTTPStatus.NO_CONTENT:
assert model is None
if model is None and code not in {HTTPStatus.ACCEPTED, HTTPStatus.NO_CONTENT}:
if code.value not in http_exceptions.default_exceptions:
raise ValueError("`model` parameter is required for code %d" % code)
model = self.model(
name='HTTPError%d' % code,
model=DefaultHTTPErrorSchema(http_code=code)
)
if description is None:
description = code.description
def response_serializer_decorator(func):
def dump_wrapper(*args, **kwargs):
response = func(*args, **kwargs)
extra_headers = None
if response is None:
if model is not None:
raise ValueError("Response cannot not be None with HTTP status %d" % code)
return flask.Response(status=code)
elif isinstance(response, flask.Response) or model is None:
return response
elif isinstance(response, tuple):
response, _code, extra_headers = unpack(response)
else:
_code = code
if HTTPStatus(_code) is code:
response = model.dump(response).data
return response, _code, extra_headers
return dump_wrapper
def decorator(func_or_class):
if code.value in http_exceptions.default_exceptions:
decorated_func_or_class = func_or_class
elif isinstance(func_or_class, type):
func_or_class._apply_decorator_to_methods(response_serializer_decorator)
decorated_func_or_class = func_or_class
else:
decorated_func_or_class = wraps(func_or_class)(
response_serializer_decorator(func_or_class)
)
if model is None:
api_model = None
else:
if isinstance(model, Model):
api_model = model
else:
api_model = self.model(model=model)
if getattr(model, 'many', False):
api_model = [api_model]
doc_decorator = self.doc(
responses={
code.value: (description, api_model)
}
)
return doc_decorator(decorated_func_or_class)
return decorator |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:enrich_items; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:ocean_backend; 6, default_parameter; 6, 7; 6, 8; 7, identifier:events; 8, False; 9, block; 9, 10; 9, 18; 9, 22; 9, 26; 9, 30; 9, 38; 9, 42; 9, 52; 9, 68; 9, 236; 9, 253; 9, 260; 9, 297; 9, 309; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:max_items; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:elastic; 17, identifier:max_items_bulk; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:current; 21, integer:0; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:total; 25, integer:0; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:bulk_json; 29, string:""; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:items; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:ocean_backend; 36, identifier:fetch; 37, argument_list; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:images_items; 41, dictionary; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:url; 45, binary_operator:+; 45, 46; 45, 51; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:elastic; 50, identifier:index_url; 51, string:'/items/_bulk'; 52, expression_statement; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:logger; 56, identifier:debug; 57, argument_list; 57, 58; 57, 59; 57, 67; 58, string:"Adding items to %s (in %i packs)"; 59, call; 59, 60; 59, 65; 60, attribute; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:elastic; 64, identifier:anonymize_url; 65, argument_list; 65, 66; 66, identifier:url; 67, identifier:max_items; 68, for_statement; 68, 69; 68, 70; 68, 71; 69, identifier:item; 70, identifier:items; 71, block; 71, 72; 71, 128; 71, 137; 71, 146; 71, 160; 71, 166; 71, 170; 72, if_statement; 72, 73; 72, 76; 73, comparison_operator:>=; 73, 74; 73, 75; 74, identifier:current; 75, identifier:max_items; 76, block; 76, 77; 76, 89; 76, 103; 76, 120; 76, 124; 77, expression_statement; 77, 78; 78, augmented_assignment:+=; 78, 79; 78, 80; 79, identifier:total; 80, call; 80, 81; 80, 86; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:elastic; 85, identifier:safe_put_bulk; 86, argument_list; 86, 87; 86, 88; 87, identifier:url; 88, identifier:bulk_json; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:json_size; 92, binary_operator:/; 92, 93; 92, 99; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:sys; 96, identifier:getsizeof; 97, argument_list; 97, 98; 98, identifier:bulk_json; 99, parenthesized_expression; 99, 100; 100, binary_operator:*; 100, 101; 100, 102; 101, integer:1024; 102, integer:1024; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:logger; 107, identifier:debug; 108, argument_list; 108, 109; 108, 110; 108, 111; 108, 119; 109, string:"Added %i items to %s (%0.2f MB)"; 110, identifier:total; 111, call; 111, 112; 111, 117; 112, attribute; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:elastic; 116, identifier:anonymize_url; 117, argument_list; 117, 118; 118, identifier:url; 119, identifier:json_size; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:bulk_json; 123, string:""; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:current; 127, integer:0; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:rich_item; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:get_rich_item; 135, argument_list; 135, 136; 136, identifier:item; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:data_json; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:json; 143, identifier:dumps; 144, argument_list; 144, 145; 145, identifier:rich_item; 146, expression_statement; 146, 147; 147, augmented_assignment:+=; 147, 148; 147, 149; 148, identifier:bulk_json; 149, binary_operator:%; 149, 150; 149, 151; 149, 152; 150, string:'{"index" : {"_id" : "%s" } }\n'; 151, line_continuation:\; 152, parenthesized_expression; 152, 153; 153, subscript; 153, 154; 153, 155; 154, identifier:item; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:self; 158, identifier:get_field_unique_id; 159, argument_list; 160, expression_statement; 160, 161; 161, augmented_assignment:+=; 161, 162; 161, 163; 162, identifier:bulk_json; 163, binary_operator:+; 163, 164; 163, 165; 164, identifier:data_json; 165, string:"\n"; 166, expression_statement; 166, 167; 167, augmented_assignment:+=; 167, 168; 167, 169; 168, identifier:current; 169, integer:1; 170, if_statement; 170, 171; 170, 176; 170, 197; 171, comparison_operator:not; 171, 172; 171, 175; 172, subscript; 172, 173; 172, 174; 173, identifier:rich_item; 174, string:'id'; 175, identifier:images_items; 176, block; 176, 177; 176, 183; 176, 189; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 182; 179, subscript; 179, 180; 179, 181; 180, identifier:rich_item; 181, string:'is_docker_image'; 182, integer:1; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 188; 185, subscript; 185, 186; 185, 187; 186, identifier:rich_item; 187, string:'is_event'; 188, integer:0; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 196; 191, subscript; 191, 192; 191, 193; 192, identifier:images_items; 193, subscript; 193, 194; 193, 195; 194, identifier:rich_item; 195, string:'id'; 196, identifier:rich_item; 197, else_clause; 197, 198; 198, block; 198, 199; 198, 209; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:image_date; 202, subscript; 202, 203; 202, 208; 203, subscript; 203, 204; 203, 205; 204, identifier:images_items; 205, subscript; 205, 206; 205, 207; 206, identifier:rich_item; 207, string:'id'; 208, string:'last_updated'; 209, if_statement; 209, 210; 209, 215; 210, comparison_operator:<=; 210, 211; 210, 212; 211, identifier:image_date; 212, subscript; 212, 213; 212, 214; 213, identifier:rich_item; 214, string:'last_updated'; 215, block; 215, 216; 215, 222; 215, 228; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 221; 218, subscript; 218, 219; 218, 220; 219, identifier:rich_item; 220, string:'is_docker_image'; 221, integer:1; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 227; 224, subscript; 224, 225; 224, 226; 225, identifier:rich_item; 226, string:'is_event'; 227, integer:0; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 235; 230, subscript; 230, 231; 230, 232; 231, identifier:images_items; 232, subscript; 232, 233; 232, 234; 233, identifier:rich_item; 234, string:'id'; 235, identifier:rich_item; 236, if_statement; 236, 237; 236, 240; 237, comparison_operator:>; 237, 238; 237, 239; 238, identifier:current; 239, integer:0; 240, block; 240, 241; 241, expression_statement; 241, 242; 242, augmented_assignment:+=; 242, 243; 242, 244; 243, identifier:total; 244, call; 244, 245; 244, 250; 245, attribute; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:self; 248, identifier:elastic; 249, identifier:safe_put_bulk; 250, argument_list; 250, 251; 250, 252; 251, identifier:url; 252, identifier:bulk_json; 253, if_statement; 253, 254; 253, 257; 254, comparison_operator:==; 254, 255; 254, 256; 255, identifier:total; 256, integer:0; 257, block; 257, 258; 258, return_statement; 258, 259; 259, identifier:total; 260, for_statement; 260, 261; 260, 262; 260, 263; 261, identifier:image; 262, identifier:images_items; 263, block; 263, 264; 263, 270; 263, 279; 263, 291; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 267; 266, identifier:data; 267, subscript; 267, 268; 267, 269; 268, identifier:images_items; 269, identifier:image; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 273; 272, identifier:data_json; 273, call; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:json; 276, identifier:dumps; 277, argument_list; 277, 278; 278, identifier:data; 279, expression_statement; 279, 280; 280, augmented_assignment:+=; 280, 281; 280, 282; 281, identifier:bulk_json; 282, binary_operator:%; 282, 283; 282, 284; 282, 285; 283, string:'{"index" : {"_id" : "%s" } }\n'; 284, line_continuation:\; 285, parenthesized_expression; 285, 286; 286, binary_operator:+; 286, 287; 286, 290; 287, subscript; 287, 288; 287, 289; 288, identifier:data; 289, string:'id'; 290, string:"_image"; 291, expression_statement; 291, 292; 292, augmented_assignment:+=; 292, 293; 292, 294; 293, identifier:bulk_json; 294, binary_operator:+; 294, 295; 294, 296; 295, identifier:data_json; 296, string:"\n"; 297, expression_statement; 297, 298; 298, augmented_assignment:+=; 298, 299; 298, 300; 299, identifier:total; 300, call; 300, 301; 300, 306; 301, attribute; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:self; 304, identifier:elastic; 305, identifier:safe_put_bulk; 306, argument_list; 306, 307; 306, 308; 307, identifier:url; 308, identifier:bulk_json; 309, return_statement; 309, 310; 310, identifier:total | def enrich_items(self, ocean_backend, events=False):
max_items = self.elastic.max_items_bulk
current = 0
total = 0
bulk_json = ""
items = ocean_backend.fetch()
images_items = {}
url = self.elastic.index_url + '/items/_bulk'
logger.debug("Adding items to %s (in %i packs)", self.elastic.anonymize_url(url), max_items)
for item in items:
if current >= max_items:
total += self.elastic.safe_put_bulk(url, bulk_json)
json_size = sys.getsizeof(bulk_json) / (1024 * 1024)
logger.debug("Added %i items to %s (%0.2f MB)", total, self.elastic.anonymize_url(url), json_size)
bulk_json = ""
current = 0
rich_item = self.get_rich_item(item)
data_json = json.dumps(rich_item)
bulk_json += '{"index" : {"_id" : "%s" } }\n' % \
(item[self.get_field_unique_id()])
bulk_json += data_json + "\n"
current += 1
if rich_item['id'] not in images_items:
rich_item['is_docker_image'] = 1
rich_item['is_event'] = 0
images_items[rich_item['id']] = rich_item
else:
image_date = images_items[rich_item['id']]['last_updated']
if image_date <= rich_item['last_updated']:
rich_item['is_docker_image'] = 1
rich_item['is_event'] = 0
images_items[rich_item['id']] = rich_item
if current > 0:
total += self.elastic.safe_put_bulk(url, bulk_json)
if total == 0:
return total
for image in images_items:
data = images_items[image]
data_json = json.dumps(data)
bulk_json += '{"index" : {"_id" : "%s" } }\n' % \
(data['id'] + "_image")
bulk_json += data_json + "\n"
total += self.elastic.safe_put_bulk(url, bulk_json)
return total |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:add_identity; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:cls; 5, identifier:db; 6, identifier:identity; 7, identifier:backend; 8, block; 8, 9; 8, 13; 8, 154; 8, 204; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:uuid; 12, None; 13, try_statement; 13, 14; 13, 82; 13, 94; 13, 107; 13, 129; 14, block; 14, 15; 14, 34; 14, 51; 14, 72; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:uuid; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:api; 21, identifier:add_identity; 22, argument_list; 22, 23; 22, 24; 22, 25; 22, 28; 22, 31; 23, identifier:db; 24, identifier:backend; 25, subscript; 25, 26; 25, 27; 26, identifier:identity; 27, string:'email'; 28, subscript; 28, 29; 28, 30; 29, identifier:identity; 30, string:'name'; 31, subscript; 31, 32; 31, 33; 32, identifier:identity; 33, string:'username'; 34, expression_statement; 34, 35; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:logger; 38, identifier:debug; 39, argument_list; 39, 40; 39, 41; 39, 42; 39, 45; 39, 48; 40, string:"New sortinghat identity %s %s,%s,%s "; 41, identifier:uuid; 42, subscript; 42, 43; 42, 44; 43, identifier:identity; 44, string:'username'; 45, subscript; 45, 46; 45, 47; 46, identifier:identity; 47, string:'name'; 48, subscript; 48, 49; 48, 50; 49, identifier:identity; 50, string:'email'; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:profile; 54, dictionary; 54, 55; 54, 67; 55, pair; 55, 56; 55, 57; 56, string:"name"; 57, conditional_expression:if; 57, 58; 57, 61; 57, 64; 58, subscript; 58, 59; 58, 60; 59, identifier:identity; 60, string:'name'; 61, subscript; 61, 62; 61, 63; 62, identifier:identity; 63, string:'name'; 64, subscript; 64, 65; 64, 66; 65, identifier:identity; 66, string:'username'; 67, pair; 67, 68; 67, 69; 68, string:"email"; 69, subscript; 69, 70; 69, 71; 70, identifier:identity; 71, string:'email'; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:api; 76, identifier:edit_profile; 77, argument_list; 77, 78; 77, 79; 77, 80; 78, identifier:db; 79, identifier:uuid; 80, dictionary_splat; 80, 81; 81, identifier:profile; 82, except_clause; 82, 83; 82, 87; 83, as_pattern; 83, 84; 83, 85; 84, identifier:AlreadyExistsError; 85, as_pattern_target; 85, 86; 86, identifier:ex; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:uuid; 91, attribute; 91, 92; 91, 93; 92, identifier:ex; 93, identifier:eid; 94, except_clause; 94, 95; 94, 99; 95, as_pattern; 95, 96; 95, 97; 96, identifier:InvalidValueError; 97, as_pattern_target; 97, 98; 98, identifier:ex; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:logger; 104, identifier:warning; 105, argument_list; 105, 106; 106, string:"Trying to add a None identity. Ignoring it."; 107, except_clause; 107, 108; 107, 112; 108, as_pattern; 108, 109; 108, 110; 109, identifier:UnicodeEncodeError; 110, as_pattern_target; 110, 111; 111, identifier:ex; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:logger; 117, identifier:warning; 118, argument_list; 118, 119; 118, 120; 118, 123; 118, 126; 119, string:"UnicodeEncodeError. Ignoring it. %s %s %s"; 120, subscript; 120, 121; 120, 122; 121, identifier:identity; 122, string:'email'; 123, subscript; 123, 124; 123, 125; 124, identifier:identity; 125, string:'name'; 126, subscript; 126, 127; 126, 128; 127, identifier:identity; 128, string:'username'; 129, except_clause; 129, 130; 129, 134; 130, as_pattern; 130, 131; 130, 132; 131, identifier:Exception; 132, as_pattern_target; 132, 133; 133, identifier:ex; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:logger; 139, identifier:warning; 140, argument_list; 140, 141; 140, 142; 140, 145; 140, 148; 140, 151; 141, string:"Unknown exception adding identity. Ignoring it. %s %s %s"; 142, subscript; 142, 143; 142, 144; 143, identifier:identity; 144, string:'email'; 145, subscript; 145, 146; 145, 147; 146, identifier:identity; 147, string:'name'; 148, subscript; 148, 149; 148, 150; 149, identifier:identity; 150, string:'username'; 151, keyword_argument; 151, 152; 151, 153; 152, identifier:exc_info; 153, True; 154, if_statement; 154, 155; 154, 164; 155, boolean_operator:and; 155, 156; 155, 159; 156, comparison_operator:in; 156, 157; 156, 158; 157, string:'company'; 158, identifier:identity; 159, comparison_operator:is; 159, 160; 159, 163; 160, subscript; 160, 161; 160, 162; 161, identifier:identity; 162, string:'company'; 163, None; 164, block; 164, 165; 165, try_statement; 165, 166; 165, 200; 166, block; 166, 167; 166, 177; 167, expression_statement; 167, 168; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:api; 171, identifier:add_organization; 172, argument_list; 172, 173; 172, 174; 173, identifier:db; 174, subscript; 174, 175; 174, 176; 175, identifier:identity; 176, string:'company'; 177, expression_statement; 177, 178; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:api; 181, identifier:add_enrollment; 182, argument_list; 182, 183; 182, 184; 182, 185; 182, 188; 182, 194; 183, identifier:db; 184, identifier:uuid; 185, subscript; 185, 186; 185, 187; 186, identifier:identity; 187, string:'company'; 188, call; 188, 189; 188, 190; 189, identifier:datetime; 190, argument_list; 190, 191; 190, 192; 190, 193; 191, integer:1900; 192, integer:1; 193, integer:1; 194, call; 194, 195; 194, 196; 195, identifier:datetime; 196, argument_list; 196, 197; 196, 198; 196, 199; 197, integer:2100; 198, integer:1; 199, integer:1; 200, except_clause; 200, 201; 200, 202; 201, identifier:AlreadyExistsError; 202, block; 202, 203; 203, pass_statement; 204, return_statement; 204, 205; 205, identifier:uuid | def add_identity(cls, db, identity, backend):
uuid = None
try:
uuid = api.add_identity(db, backend, identity['email'],
identity['name'], identity['username'])
logger.debug("New sortinghat identity %s %s,%s,%s ",
uuid, identity['username'], identity['name'], identity['email'])
profile = {"name": identity['name'] if identity['name'] else identity['username'],
"email": identity['email']}
api.edit_profile(db, uuid, **profile)
except AlreadyExistsError as ex:
uuid = ex.eid
except InvalidValueError as ex:
logger.warning("Trying to add a None identity. Ignoring it.")
except UnicodeEncodeError as ex:
logger.warning("UnicodeEncodeError. Ignoring it. %s %s %s",
identity['email'], identity['name'],
identity['username'])
except Exception as ex:
logger.warning("Unknown exception adding identity. Ignoring it. %s %s %s",
identity['email'], identity['name'],
identity['username'], exc_info=True)
if 'company' in identity and identity['company'] is not None:
try:
api.add_organization(db, identity['company'])
api.add_enrollment(db, uuid, identity['company'],
datetime(1900, 1, 1),
datetime(2100, 1, 1))
except AlreadyExistsError:
pass
return uuid |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:add_identities; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:cls; 5, identifier:db; 6, identifier:identities; 7, identifier:backend; 8, block; 8, 9; 8, 16; 8, 20; 8, 55; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:logger; 13, identifier:info; 14, argument_list; 14, 15; 15, string:"Adding the identities to SortingHat"; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:total; 19, integer:0; 20, for_statement; 20, 21; 20, 22; 20, 23; 21, identifier:identity; 22, identifier:identities; 23, block; 23, 24; 24, try_statement; 24, 25; 24, 39; 25, block; 25, 26; 25, 35; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:cls; 30, identifier:add_identity; 31, argument_list; 31, 32; 31, 33; 31, 34; 32, identifier:db; 33, identifier:identity; 34, identifier:backend; 35, expression_statement; 35, 36; 36, augmented_assignment:+=; 36, 37; 36, 38; 37, identifier:total; 38, integer:1; 39, except_clause; 39, 40; 39, 44; 40, as_pattern; 40, 41; 40, 42; 41, identifier:Exception; 42, as_pattern_target; 42, 43; 43, identifier:e; 44, block; 44, 45; 44, 54; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:logger; 49, identifier:error; 50, argument_list; 50, 51; 51, binary_operator:%; 51, 52; 51, 53; 52, string:"Unexcepted error when adding identities: %s"; 53, identifier:e; 54, continue_statement; 55, expression_statement; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:logger; 59, identifier:info; 60, argument_list; 60, 61; 60, 62; 61, string:"Total identities added to SH: %i"; 62, identifier:total | def add_identities(cls, db, identities, backend):
logger.info("Adding the identities to SortingHat")
total = 0
for identity in identities:
try:
cls.add_identity(db, identity, backend)
total += 1
except Exception as e:
logger.error("Unexcepted error when adding identities: %s" % e)
continue
logger.info("Total identities added to SH: %i", total) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:remove_identity; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:cls; 5, identifier:sh_db; 6, identifier:ident_id; 7, block; 7, 8; 7, 12; 7, 51; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:success; 11, False; 12, try_statement; 12, 13; 12, 34; 13, block; 13, 14; 13, 22; 13, 30; 14, expression_statement; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:api; 18, identifier:delete_identity; 19, argument_list; 19, 20; 19, 21; 20, identifier:sh_db; 21, identifier:ident_id; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:logger; 26, identifier:debug; 27, argument_list; 27, 28; 27, 29; 28, string:"Identity %s deleted"; 29, identifier:ident_id; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:success; 33, True; 34, except_clause; 34, 35; 34, 39; 35, as_pattern; 35, 36; 35, 37; 36, identifier:Exception; 37, as_pattern_target; 37, 38; 38, identifier:e; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:logger; 44, identifier:debug; 45, argument_list; 45, 46; 45, 47; 46, string:"Identity not deleted due to %s"; 47, call; 47, 48; 47, 49; 48, identifier:str; 49, argument_list; 49, 50; 50, identifier:e; 51, return_statement; 51, 52; 52, identifier:success | def remove_identity(cls, sh_db, ident_id):
success = False
try:
api.delete_identity(sh_db, ident_id)
logger.debug("Identity %s deleted", ident_id)
success = True
except Exception as e:
logger.debug("Identity not deleted due to %s", str(e))
return success |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:remove_unique_identity; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:cls; 5, identifier:sh_db; 6, identifier:uuid; 7, block; 7, 8; 7, 12; 7, 51; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:success; 11, False; 12, try_statement; 12, 13; 12, 34; 13, block; 13, 14; 13, 22; 13, 30; 14, expression_statement; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:api; 18, identifier:delete_unique_identity; 19, argument_list; 19, 20; 19, 21; 20, identifier:sh_db; 21, identifier:uuid; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:logger; 26, identifier:debug; 27, argument_list; 27, 28; 27, 29; 28, string:"Unique identity %s deleted"; 29, identifier:uuid; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:success; 33, True; 34, except_clause; 34, 35; 34, 39; 35, as_pattern; 35, 36; 35, 37; 36, identifier:Exception; 37, as_pattern_target; 37, 38; 38, identifier:e; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:logger; 44, identifier:debug; 45, argument_list; 45, 46; 45, 47; 46, string:"Unique identity not deleted due to %s"; 47, call; 47, 48; 47, 49; 48, identifier:str; 49, argument_list; 49, 50; 50, identifier:e; 51, return_statement; 51, 52; 52, identifier:success | def remove_unique_identity(cls, sh_db, uuid):
success = False
try:
api.delete_unique_identity(sh_db, uuid)
logger.debug("Unique identity %s deleted", uuid)
success = True
except Exception as e:
logger.debug("Unique identity not deleted due to %s", str(e))
return success |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:unique_identities; 3, parameters; 3, 4; 3, 5; 4, identifier:cls; 5, identifier:sh_db; 6, block; 6, 7; 7, try_statement; 7, 8; 7, 21; 8, block; 8, 9; 9, for_statement; 9, 10; 9, 11; 9, 17; 10, identifier:unique_identity; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:api; 14, identifier:unique_identities; 15, argument_list; 15, 16; 16, identifier:sh_db; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, yield; 19, 20; 20, identifier:unique_identity; 21, except_clause; 21, 22; 21, 26; 22, as_pattern; 22, 23; 22, 24; 23, identifier:Exception; 24, as_pattern_target; 24, 25; 25, identifier:e; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:logger; 31, identifier:debug; 32, argument_list; 32, 33; 32, 34; 33, string:"Unique identities not returned from SortingHat due to %s"; 34, call; 34, 35; 34, 36; 35, identifier:str; 36, argument_list; 36, 37; 37, identifier:e | def unique_identities(cls, sh_db):
try:
for unique_identity in api.unique_identities(sh_db):
yield unique_identity
except Exception as e:
logger.debug("Unique identities not returned from SortingHat due to %s", str(e)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:refresh_identities; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:enrich_backend; 5, default_parameter; 5, 6; 5, 7; 6, identifier:author_field; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:author_values; 10, None; 11, block; 11, 12; 11, 62; 11, 81; 11, 85; 11, 93; 11, 100; 11, 204; 12, function_definition; 12, 13; 12, 14; 12, 16; 13, function_name:update_items; 14, parameters; 14, 15; 15, identifier:new_filter_author; 16, block; 16, 17; 17, for_statement; 17, 18; 17, 19; 17, 25; 18, identifier:eitem; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:enrich_backend; 22, identifier:fetch; 23, argument_list; 23, 24; 24, identifier:new_filter_author; 25, block; 25, 26; 25, 30; 25, 42; 25, 52; 25, 59; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:roles; 29, None; 30, try_statement; 30, 31; 30, 38; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:roles; 35, attribute; 35, 36; 35, 37; 36, identifier:enrich_backend; 37, identifier:roles; 38, except_clause; 38, 39; 38, 40; 39, identifier:AttributeError; 40, block; 40, 41; 41, pass_statement; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:new_identities; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:enrich_backend; 48, identifier:get_item_sh_from_id; 49, argument_list; 49, 50; 49, 51; 50, identifier:eitem; 51, identifier:roles; 52, expression_statement; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:eitem; 56, identifier:update; 57, argument_list; 57, 58; 58, identifier:new_identities; 59, expression_statement; 59, 60; 60, yield; 60, 61; 61, identifier:eitem; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:logger; 66, identifier:debug; 67, argument_list; 67, 68; 67, 69; 68, string:"Refreshing identities fields from %s"; 69, call; 69, 70; 69, 75; 70, attribute; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:enrich_backend; 73, identifier:elastic; 74, identifier:anonymize_url; 75, argument_list; 75, 76; 76, attribute; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:enrich_backend; 79, identifier:elastic; 80, identifier:index_url; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:total; 84, integer:0; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:max_ids; 88, attribute; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:enrich_backend; 91, identifier:elastic; 92, identifier:max_items_clause; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:logger; 97, identifier:debug; 98, argument_list; 98, 99; 99, string:'Refreshing identities'; 100, if_statement; 100, 101; 100, 104; 100, 119; 101, comparison_operator:is; 101, 102; 101, 103; 102, identifier:author_field; 103, None; 104, block; 104, 105; 105, for_statement; 105, 106; 105, 107; 105, 111; 106, identifier:item; 107, call; 107, 108; 107, 109; 108, identifier:update_items; 109, argument_list; 109, 110; 110, None; 111, block; 111, 112; 111, 115; 112, expression_statement; 112, 113; 113, yield; 113, 114; 114, identifier:item; 115, expression_statement; 115, 116; 116, augmented_assignment:+=; 116, 117; 116, 118; 117, identifier:total; 118, integer:1; 119, else_clause; 119, 120; 120, block; 120, 121; 120, 125; 120, 172; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:to_refresh; 124, list:[]; 125, for_statement; 125, 126; 125, 127; 125, 128; 126, identifier:author_value; 127, identifier:author_values; 128, block; 128, 129; 128, 136; 129, expression_statement; 129, 130; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:to_refresh; 133, identifier:append; 134, argument_list; 134, 135; 135, identifier:author_value; 136, if_statement; 136, 137; 136, 143; 137, comparison_operator:>; 137, 138; 137, 142; 138, call; 138, 139; 138, 140; 139, identifier:len; 140, argument_list; 140, 141; 141, identifier:to_refresh; 142, identifier:max_ids; 143, block; 143, 144; 143, 154; 143, 168; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:filter_author; 147, dictionary; 147, 148; 147, 151; 148, pair; 148, 149; 148, 150; 149, string:"name"; 150, identifier:author_field; 151, pair; 151, 152; 151, 153; 152, string:"value"; 153, identifier:to_refresh; 154, for_statement; 154, 155; 154, 156; 154, 160; 155, identifier:item; 156, call; 156, 157; 156, 158; 157, identifier:update_items; 158, argument_list; 158, 159; 159, identifier:filter_author; 160, block; 160, 161; 160, 164; 161, expression_statement; 161, 162; 162, yield; 162, 163; 163, identifier:item; 164, expression_statement; 164, 165; 165, augmented_assignment:+=; 165, 166; 165, 167; 166, identifier:total; 167, integer:1; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:to_refresh; 171, list:[]; 172, if_statement; 172, 173; 172, 179; 173, comparison_operator:>; 173, 174; 173, 178; 174, call; 174, 175; 174, 176; 175, identifier:len; 176, argument_list; 176, 177; 177, identifier:to_refresh; 178, integer:0; 179, block; 179, 180; 179, 190; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:filter_author; 183, dictionary; 183, 184; 183, 187; 184, pair; 184, 185; 184, 186; 185, string:"name"; 186, identifier:author_field; 187, pair; 187, 188; 187, 189; 188, string:"value"; 189, identifier:to_refresh; 190, for_statement; 190, 191; 190, 192; 190, 196; 191, identifier:item; 192, call; 192, 193; 192, 194; 193, identifier:update_items; 194, argument_list; 194, 195; 195, identifier:filter_author; 196, block; 196, 197; 196, 200; 197, expression_statement; 197, 198; 198, yield; 198, 199; 199, identifier:item; 200, expression_statement; 200, 201; 201, augmented_assignment:+=; 201, 202; 201, 203; 202, identifier:total; 203, integer:1; 204, expression_statement; 204, 205; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:logger; 208, identifier:info; 209, argument_list; 209, 210; 209, 211; 210, string:"Total eitems refreshed for identities fields %i"; 211, identifier:total | def refresh_identities(enrich_backend, author_field=None, author_values=None):
def update_items(new_filter_author):
for eitem in enrich_backend.fetch(new_filter_author):
roles = None
try:
roles = enrich_backend.roles
except AttributeError:
pass
new_identities = enrich_backend.get_item_sh_from_id(eitem, roles)
eitem.update(new_identities)
yield eitem
logger.debug("Refreshing identities fields from %s",
enrich_backend.elastic.anonymize_url(enrich_backend.elastic.index_url))
total = 0
max_ids = enrich_backend.elastic.max_items_clause
logger.debug('Refreshing identities')
if author_field is None:
for item in update_items(None):
yield item
total += 1
else:
to_refresh = []
for author_value in author_values:
to_refresh.append(author_value)
if len(to_refresh) > max_ids:
filter_author = {"name": author_field,
"value": to_refresh}
for item in update_items(filter_author):
yield item
total += 1
to_refresh = []
if len(to_refresh) > 0:
filter_author = {"name": author_field,
"value": to_refresh}
for item in update_items(filter_author):
yield item
total += 1
logger.info("Total eitems refreshed for identities fields %i", total) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:get_ocean_backend; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 4, identifier:backend_cmd; 5, identifier:enrich_backend; 6, identifier:no_incremental; 7, default_parameter; 7, 8; 7, 9; 8, identifier:filter_raw; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:filter_raw_should; 12, None; 13, block; 13, 14; 13, 34; 13, 42; 13, 46; 13, 58; 13, 216; 13, 226; 13, 236; 14, if_statement; 14, 15; 14, 16; 14, 21; 15, identifier:no_incremental; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:last_enrich; 20, None; 21, else_clause; 21, 22; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:last_enrich; 26, call; 26, 27; 26, 28; 27, identifier:get_last_enrich; 28, argument_list; 28, 29; 28, 30; 28, 31; 29, identifier:backend_cmd; 30, identifier:enrich_backend; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:filter_raw; 33, identifier:filter_raw; 34, expression_statement; 34, 35; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:logger; 38, identifier:debug; 39, argument_list; 39, 40; 39, 41; 40, string:"Last enrichment: %s"; 41, identifier:last_enrich; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:backend; 45, None; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:connector; 49, subscript; 49, 50; 49, 53; 50, call; 50, 51; 50, 52; 51, identifier:get_connectors; 52, argument_list; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:enrich_backend; 56, identifier:get_connector_name; 57, argument_list; 58, if_statement; 58, 59; 58, 60; 58, 151; 59, identifier:backend_cmd; 60, block; 60, 61; 60, 68; 60, 74; 60, 85; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:backend_cmd; 64, call; 64, 65; 64, 66; 65, identifier:init_backend; 66, argument_list; 66, 67; 67, identifier:backend_cmd; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:backend; 71, attribute; 71, 72; 71, 73; 72, identifier:backend_cmd; 73, identifier:backend; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:signature; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:inspect; 80, identifier:signature; 81, argument_list; 81, 82; 82, attribute; 82, 83; 82, 84; 83, identifier:backend; 84, identifier:fetch; 85, if_statement; 85, 86; 85, 91; 85, 104; 85, 123; 86, comparison_operator:in; 86, 87; 86, 88; 87, string:'from_date'; 88, attribute; 88, 89; 88, 90; 89, identifier:signature; 90, identifier:parameters; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:ocean_backend; 95, call; 95, 96; 95, 99; 96, subscript; 96, 97; 96, 98; 97, identifier:connector; 98, integer:1; 99, argument_list; 99, 100; 99, 101; 100, identifier:backend; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:from_date; 103, identifier:last_enrich; 104, elif_clause; 104, 105; 104, 110; 105, comparison_operator:in; 105, 106; 105, 107; 106, string:'offset'; 107, attribute; 107, 108; 107, 109; 108, identifier:signature; 109, identifier:parameters; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:ocean_backend; 114, call; 114, 115; 114, 118; 115, subscript; 115, 116; 115, 117; 116, identifier:connector; 117, integer:1; 118, argument_list; 118, 119; 118, 120; 119, identifier:backend; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:offset; 122, identifier:last_enrich; 123, else_clause; 123, 124; 124, block; 124, 125; 125, if_statement; 125, 126; 125, 127; 125, 140; 126, identifier:last_enrich; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:ocean_backend; 131, call; 131, 132; 131, 135; 132, subscript; 132, 133; 132, 134; 133, identifier:connector; 134, integer:1; 135, argument_list; 135, 136; 135, 137; 136, identifier:backend; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:from_date; 139, identifier:last_enrich; 140, else_clause; 140, 141; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:ocean_backend; 145, call; 145, 146; 145, 149; 146, subscript; 146, 147; 146, 148; 147, identifier:connector; 148, integer:1; 149, argument_list; 149, 150; 150, identifier:backend; 151, else_clause; 151, 152; 152, block; 152, 153; 152, 159; 152, 190; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:params; 156, attribute; 156, 157; 156, 158; 157, identifier:enrich_backend; 158, identifier:backend_params; 159, if_statement; 159, 160; 159, 161; 160, identifier:params; 161, block; 161, 162; 162, try_statement; 162, 163; 162, 186; 163, block; 163, 164; 163, 173; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:date_pos; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:params; 170, identifier:index; 171, argument_list; 171, 172; 172, string:'--from-date'; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:last_enrich; 176, call; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:parser; 179, identifier:parse; 180, argument_list; 180, 181; 181, subscript; 181, 182; 181, 183; 182, identifier:params; 183, binary_operator:+; 183, 184; 183, 185; 184, identifier:date_pos; 185, integer:1; 186, except_clause; 186, 187; 186, 188; 187, identifier:ValueError; 188, block; 188, 189; 189, pass_statement; 190, if_statement; 190, 191; 190, 192; 190, 205; 191, identifier:last_enrich; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:ocean_backend; 196, call; 196, 197; 196, 200; 197, subscript; 197, 198; 197, 199; 198, identifier:connector; 199, integer:1; 200, argument_list; 200, 201; 200, 202; 201, identifier:backend; 202, keyword_argument; 202, 203; 202, 204; 203, identifier:from_date; 204, identifier:last_enrich; 205, else_clause; 205, 206; 206, block; 206, 207; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:ocean_backend; 210, call; 210, 211; 210, 214; 211, subscript; 211, 212; 211, 213; 212, identifier:connector; 213, integer:1; 214, argument_list; 214, 215; 215, identifier:backend; 216, if_statement; 216, 217; 216, 218; 217, identifier:filter_raw; 218, block; 218, 219; 219, expression_statement; 219, 220; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:ocean_backend; 223, identifier:set_filter_raw; 224, argument_list; 224, 225; 225, identifier:filter_raw; 226, if_statement; 226, 227; 226, 228; 227, identifier:filter_raw_should; 228, block; 228, 229; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:ocean_backend; 233, identifier:set_filter_raw_should; 234, argument_list; 234, 235; 235, identifier:filter_raw_should; 236, return_statement; 236, 237; 237, identifier:ocean_backend | def get_ocean_backend(backend_cmd, enrich_backend, no_incremental,
filter_raw=None, filter_raw_should=None):
if no_incremental:
last_enrich = None
else:
last_enrich = get_last_enrich(backend_cmd, enrich_backend, filter_raw=filter_raw)
logger.debug("Last enrichment: %s", last_enrich)
backend = None
connector = get_connectors()[enrich_backend.get_connector_name()]
if backend_cmd:
backend_cmd = init_backend(backend_cmd)
backend = backend_cmd.backend
signature = inspect.signature(backend.fetch)
if 'from_date' in signature.parameters:
ocean_backend = connector[1](backend, from_date=last_enrich)
elif 'offset' in signature.parameters:
ocean_backend = connector[1](backend, offset=last_enrich)
else:
if last_enrich:
ocean_backend = connector[1](backend, from_date=last_enrich)
else:
ocean_backend = connector[1](backend)
else:
params = enrich_backend.backend_params
if params:
try:
date_pos = params.index('--from-date')
last_enrich = parser.parse(params[date_pos + 1])
except ValueError:
pass
if last_enrich:
ocean_backend = connector[1](backend, from_date=last_enrich)
else:
ocean_backend = connector[1](backend)
if filter_raw:
ocean_backend.set_filter_raw(filter_raw)
if filter_raw_should:
ocean_backend.set_filter_raw_should(filter_raw_should)
return ocean_backend |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:delete_orphan_unique_identities; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:es; 5, identifier:sortinghat_db; 6, identifier:current_data_source; 7, identifier:active_data_sources; 8, block; 8, 9; 8, 73; 8, 107; 8, 153; 8, 183; 8, 187; 8, 191; 8, 195; 8, 301; 8, 342; 8, 350; 9, function_definition; 9, 10; 9, 11; 9, 13; 10, function_name:get_uuids_in_index; 11, parameters; 11, 12; 12, identifier:target_uuids; 13, block; 13, 14; 13, 50; 13, 54; 13, 71; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:page; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:es; 20, identifier:search; 21, argument_list; 21, 22; 21, 25; 21, 28; 21, 31; 22, keyword_argument; 22, 23; 22, 24; 23, identifier:index; 24, identifier:IDENTITIES_INDEX; 25, keyword_argument; 25, 26; 25, 27; 26, identifier:scroll; 27, string:"360m"; 28, keyword_argument; 28, 29; 28, 30; 29, identifier:size; 30, identifier:SIZE_SCROLL_IDENTITIES_INDEX; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:body; 33, dictionary; 33, 34; 34, pair; 34, 35; 34, 36; 35, string:"query"; 36, dictionary; 36, 37; 37, pair; 37, 38; 37, 39; 38, string:"bool"; 39, dictionary; 39, 40; 40, pair; 40, 41; 40, 42; 41, string:"filter"; 42, list:[
{
"terms": {
"sh_uuid": target_uuids
}
}
]; 42, 43; 43, dictionary; 43, 44; 44, pair; 44, 45; 44, 46; 45, string:"terms"; 46, dictionary; 46, 47; 47, pair; 47, 48; 47, 49; 48, string:"sh_uuid"; 49, identifier:target_uuids; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:hits; 53, list:[]; 54, if_statement; 54, 55; 54, 62; 55, comparison_operator:!=; 55, 56; 55, 61; 56, subscript; 56, 57; 56, 60; 57, subscript; 57, 58; 57, 59; 58, identifier:page; 59, string:'hits'; 60, string:'total'; 61, integer:0; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:hits; 66, subscript; 66, 67; 66, 70; 67, subscript; 67, 68; 67, 69; 68, identifier:page; 69, string:'hits'; 70, string:'hits'; 71, return_statement; 71, 72; 72, identifier:hits; 73, function_definition; 73, 74; 73, 75; 73, 77; 74, function_name:delete_unique_identities; 75, parameters; 75, 76; 76, identifier:target_uuids; 77, block; 77, 78; 77, 82; 77, 105; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:count; 81, integer:0; 82, for_statement; 82, 83; 82, 84; 82, 85; 83, identifier:uuid; 84, identifier:target_uuids; 85, block; 85, 86; 85, 96; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:success; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:SortingHat; 92, identifier:remove_unique_identity; 93, argument_list; 93, 94; 93, 95; 94, identifier:sortinghat_db; 95, identifier:uuid; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:count; 99, conditional_expression:if; 99, 100; 99, 103; 99, 104; 100, binary_operator:+; 100, 101; 100, 102; 101, identifier:count; 102, integer:1; 103, identifier:success; 104, identifier:count; 105, return_statement; 105, 106; 106, identifier:count; 107, function_definition; 107, 108; 107, 109; 107, 112; 108, function_name:delete_identities; 109, parameters; 109, 110; 109, 111; 110, identifier:unique_ident; 111, identifier:data_sources; 112, block; 112, 113; 112, 117; 112, 151; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:count; 116, integer:0; 117, for_statement; 117, 118; 117, 119; 117, 122; 118, identifier:ident; 119, attribute; 119, 120; 119, 121; 120, identifier:unique_ident; 121, identifier:identities; 122, block; 122, 123; 123, if_statement; 123, 124; 123, 129; 124, comparison_operator:not; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:ident; 127, identifier:source; 128, identifier:data_sources; 129, block; 129, 130; 129, 142; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:success; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:SortingHat; 136, identifier:remove_identity; 137, argument_list; 137, 138; 137, 139; 138, identifier:sortinghat_db; 139, attribute; 139, 140; 139, 141; 140, identifier:ident; 141, identifier:id; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:count; 145, conditional_expression:if; 145, 146; 145, 149; 145, 150; 146, binary_operator:+; 146, 147; 146, 148; 147, identifier:count; 148, integer:1; 149, identifier:success; 150, identifier:count; 151, return_statement; 151, 152; 152, identifier:count; 153, function_definition; 153, 154; 153, 155; 153, 158; 154, function_name:has_identities_in_data_sources; 155, parameters; 155, 156; 155, 157; 156, identifier:unique_ident; 157, identifier:data_sources; 158, block; 158, 159; 158, 163; 158, 181; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:in_active; 162, False; 163, for_statement; 163, 164; 163, 165; 163, 168; 164, identifier:ident; 165, attribute; 165, 166; 165, 167; 166, identifier:unique_ident; 167, identifier:identities; 168, block; 168, 169; 169, if_statement; 169, 170; 169, 175; 170, comparison_operator:in; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:ident; 173, identifier:source; 174, identifier:data_sources; 175, block; 175, 176; 175, 180; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:in_active; 179, True; 180, break_statement; 181, return_statement; 181, 182; 182, identifier:in_active; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:deleted_unique_identities; 186, integer:0; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:deleted_identities; 190, integer:0; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:uuids_to_process; 194, list:[]; 195, for_statement; 195, 196; 195, 197; 195, 203; 196, identifier:unique_identity; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:SortingHat; 200, identifier:unique_identities; 201, argument_list; 201, 202; 202, identifier:sortinghat_db; 203, block; 203, 204; 203, 223; 203, 231; 203, 241; 203, 250; 203, 259; 203, 266; 203, 278; 203, 290; 203, 297; 204, if_statement; 204, 205; 204, 211; 205, not_operator; 205, 206; 206, call; 206, 207; 206, 208; 207, identifier:has_identities_in_data_sources; 208, argument_list; 208, 209; 208, 210; 209, identifier:unique_identity; 210, identifier:active_data_sources; 211, block; 211, 212; 211, 222; 212, expression_statement; 212, 213; 213, augmented_assignment:+=; 213, 214; 213, 215; 214, identifier:deleted_unique_identities; 215, call; 215, 216; 215, 217; 216, identifier:delete_unique_identities; 217, argument_list; 217, 218; 218, list:[unique_identity.uuid]; 218, 219; 219, attribute; 219, 220; 219, 221; 220, identifier:unique_identity; 221, identifier:uuid; 222, continue_statement; 223, expression_statement; 223, 224; 224, augmented_assignment:+=; 224, 225; 224, 226; 225, identifier:deleted_identities; 226, call; 226, 227; 226, 228; 227, identifier:delete_identities; 228, argument_list; 228, 229; 228, 230; 229, identifier:unique_identity; 230, identifier:active_data_sources; 231, if_statement; 231, 232; 231, 239; 232, not_operator; 232, 233; 233, call; 233, 234; 233, 235; 234, identifier:has_identities_in_data_sources; 235, argument_list; 235, 236; 235, 237; 236, identifier:unique_identity; 237, list:[current_data_source]; 237, 238; 238, identifier:current_data_source; 239, block; 239, 240; 240, continue_statement; 241, expression_statement; 241, 242; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:uuids_to_process; 245, identifier:append; 246, argument_list; 246, 247; 247, attribute; 247, 248; 247, 249; 248, identifier:unique_identity; 249, identifier:uuid; 250, if_statement; 250, 251; 250, 257; 251, comparison_operator:!=; 251, 252; 251, 256; 252, call; 252, 253; 252, 254; 253, identifier:len; 254, argument_list; 254, 255; 255, identifier:uuids_to_process; 256, identifier:SIZE_SCROLL_IDENTITIES_INDEX; 257, block; 257, 258; 258, continue_statement; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:results; 262, call; 262, 263; 262, 264; 263, identifier:get_uuids_in_index; 264, argument_list; 264, 265; 265, identifier:uuids_to_process; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 269; 268, identifier:uuids_found; 269, list_comprehension; 269, 270; 269, 275; 270, subscript; 270, 271; 270, 274; 271, subscript; 271, 272; 271, 273; 272, identifier:item; 273, string:'_source'; 274, string:'sh_uuid'; 275, for_in_clause; 275, 276; 275, 277; 276, identifier:item; 277, identifier:results; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 281; 280, identifier:orphan_uuids; 281, binary_operator:-; 281, 282; 281, 286; 282, call; 282, 283; 282, 284; 283, identifier:set; 284, argument_list; 284, 285; 285, identifier:uuids_to_process; 286, call; 286, 287; 286, 288; 287, identifier:set; 288, argument_list; 288, 289; 289, identifier:uuids_found; 290, expression_statement; 290, 291; 291, augmented_assignment:+=; 291, 292; 291, 293; 292, identifier:deleted_unique_identities; 293, call; 293, 294; 293, 295; 294, identifier:delete_unique_identities; 295, argument_list; 295, 296; 296, identifier:orphan_uuids; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 300; 299, identifier:uuids_to_process; 300, list:[]; 301, if_statement; 301, 302; 301, 303; 302, identifier:uuids_to_process; 303, block; 303, 304; 303, 311; 303, 323; 303, 335; 304, expression_statement; 304, 305; 305, assignment; 305, 306; 305, 307; 306, identifier:results; 307, call; 307, 308; 307, 309; 308, identifier:get_uuids_in_index; 309, argument_list; 309, 310; 310, identifier:uuids_to_process; 311, expression_statement; 311, 312; 312, assignment; 312, 313; 312, 314; 313, identifier:uuids_found; 314, list_comprehension; 314, 315; 314, 320; 315, subscript; 315, 316; 315, 319; 316, subscript; 316, 317; 316, 318; 317, identifier:item; 318, string:'_source'; 319, string:'sh_uuid'; 320, for_in_clause; 320, 321; 320, 322; 321, identifier:item; 322, identifier:results; 323, expression_statement; 323, 324; 324, assignment; 324, 325; 324, 326; 325, identifier:orphan_uuids; 326, binary_operator:-; 326, 327; 326, 331; 327, call; 327, 328; 327, 329; 328, identifier:set; 329, argument_list; 329, 330; 330, identifier:uuids_to_process; 331, call; 331, 332; 331, 333; 332, identifier:set; 333, argument_list; 333, 334; 334, identifier:uuids_found; 335, expression_statement; 335, 336; 336, augmented_assignment:+=; 336, 337; 336, 338; 337, identifier:deleted_unique_identities; 338, call; 338, 339; 338, 340; 339, identifier:delete_unique_identities; 340, argument_list; 340, 341; 341, identifier:orphan_uuids; 342, expression_statement; 342, 343; 343, call; 343, 344; 343, 347; 344, attribute; 344, 345; 344, 346; 345, identifier:logger; 346, identifier:debug; 347, argument_list; 347, 348; 347, 349; 348, string:"[identities retention] Total orphan unique identities deleted from SH: %i"; 349, identifier:deleted_unique_identities; 350, expression_statement; 350, 351; 351, call; 351, 352; 351, 355; 352, attribute; 352, 353; 352, 354; 353, identifier:logger; 354, identifier:debug; 355, argument_list; 355, 356; 355, 357; 356, string:"[identities retention] Total identities in non-active data sources deleted from SH: %i"; 357, identifier:deleted_identities | def delete_orphan_unique_identities(es, sortinghat_db, current_data_source, active_data_sources):
def get_uuids_in_index(target_uuids):
page = es.search(
index=IDENTITIES_INDEX,
scroll="360m",
size=SIZE_SCROLL_IDENTITIES_INDEX,
body={
"query": {
"bool": {
"filter": [
{
"terms": {
"sh_uuid": target_uuids
}
}
]
}
}
}
)
hits = []
if page['hits']['total'] != 0:
hits = page['hits']['hits']
return hits
def delete_unique_identities(target_uuids):
count = 0
for uuid in target_uuids:
success = SortingHat.remove_unique_identity(sortinghat_db, uuid)
count = count + 1 if success else count
return count
def delete_identities(unique_ident, data_sources):
count = 0
for ident in unique_ident.identities:
if ident.source not in data_sources:
success = SortingHat.remove_identity(sortinghat_db, ident.id)
count = count + 1 if success else count
return count
def has_identities_in_data_sources(unique_ident, data_sources):
in_active = False
for ident in unique_ident.identities:
if ident.source in data_sources:
in_active = True
break
return in_active
deleted_unique_identities = 0
deleted_identities = 0
uuids_to_process = []
for unique_identity in SortingHat.unique_identities(sortinghat_db):
if not has_identities_in_data_sources(unique_identity, active_data_sources):
deleted_unique_identities += delete_unique_identities([unique_identity.uuid])
continue
deleted_identities += delete_identities(unique_identity, active_data_sources)
if not has_identities_in_data_sources(unique_identity, [current_data_source]):
continue
uuids_to_process.append(unique_identity.uuid)
if len(uuids_to_process) != SIZE_SCROLL_IDENTITIES_INDEX:
continue
results = get_uuids_in_index(uuids_to_process)
uuids_found = [item['_source']['sh_uuid'] for item in results]
orphan_uuids = set(uuids_to_process) - set(uuids_found)
deleted_unique_identities += delete_unique_identities(orphan_uuids)
uuids_to_process = []
if uuids_to_process:
results = get_uuids_in_index(uuids_to_process)
uuids_found = [item['_source']['sh_uuid'] for item in results]
orphan_uuids = set(uuids_to_process) - set(uuids_found)
deleted_unique_identities += delete_unique_identities(orphan_uuids)
logger.debug("[identities retention] Total orphan unique identities deleted from SH: %i",
deleted_unique_identities)
logger.debug("[identities retention] Total identities in non-active data sources deleted from SH: %i",
deleted_identities) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:delete_inactive_unique_identities; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:es; 5, identifier:sortinghat_db; 6, identifier:before_date; 7, block; 7, 8; 7, 40; 7, 46; 7, 54; 7, 69; 7, 73; 7, 144; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:page; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:es; 14, identifier:search; 15, argument_list; 15, 16; 15, 19; 15, 22; 15, 25; 16, keyword_argument; 16, 17; 16, 18; 17, identifier:index; 18, identifier:IDENTITIES_INDEX; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:scroll; 21, string:"360m"; 22, keyword_argument; 22, 23; 22, 24; 23, identifier:size; 24, identifier:SIZE_SCROLL_IDENTITIES_INDEX; 25, keyword_argument; 25, 26; 25, 27; 26, identifier:body; 27, dictionary; 27, 28; 28, pair; 28, 29; 28, 30; 29, string:"query"; 30, dictionary; 30, 31; 31, pair; 31, 32; 31, 33; 32, string:"range"; 33, dictionary; 33, 34; 34, pair; 34, 35; 34, 36; 35, string:"last_seen"; 36, dictionary; 36, 37; 37, pair; 37, 38; 37, 39; 38, string:"lte"; 39, identifier:before_date; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:sid; 43, subscript; 43, 44; 43, 45; 44, identifier:page; 45, string:'_scroll_id'; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:scroll_size; 49, subscript; 49, 50; 49, 53; 50, subscript; 50, 51; 50, 52; 51, identifier:page; 52, string:'hits'; 53, string:'total'; 54, if_statement; 54, 55; 54, 58; 55, comparison_operator:==; 55, 56; 55, 57; 56, identifier:scroll_size; 57, integer:0; 58, block; 58, 59; 58, 68; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:logging; 63, identifier:warning; 64, argument_list; 64, 65; 64, 66; 64, 67; 65, string:"[identities retention] No inactive identities found in %s after %s!"; 66, identifier:IDENTITIES_INDEX; 67, identifier:before_date; 68, return_statement; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:count; 72, integer:0; 73, while_statement; 73, 74; 73, 77; 74, comparison_operator:>; 74, 75; 74, 76; 75, identifier:scroll_size; 76, integer:0; 77, block; 77, 78; 77, 113; 77, 127; 77, 133; 78, for_statement; 78, 79; 78, 80; 78, 85; 79, identifier:item; 80, subscript; 80, 81; 80, 84; 81, subscript; 81, 82; 81, 83; 82, identifier:page; 83, string:'hits'; 84, string:'hits'; 85, block; 85, 86; 85, 94; 85, 104; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:to_delete; 89, subscript; 89, 90; 89, 93; 90, subscript; 90, 91; 90, 92; 91, identifier:item; 92, string:'_source'; 93, string:'sh_uuid'; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:success; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:SortingHat; 100, identifier:remove_unique_identity; 101, argument_list; 101, 102; 101, 103; 102, identifier:sortinghat_db; 103, identifier:to_delete; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:count; 107, conditional_expression:if; 107, 108; 107, 111; 107, 112; 108, binary_operator:+; 108, 109; 108, 110; 109, identifier:count; 110, integer:1; 111, identifier:success; 112, identifier:count; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:page; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:es; 119, identifier:scroll; 120, argument_list; 120, 121; 120, 124; 121, keyword_argument; 121, 122; 121, 123; 122, identifier:scroll_id; 123, identifier:sid; 124, keyword_argument; 124, 125; 124, 126; 125, identifier:scroll; 126, string:'60m'; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:sid; 130, subscript; 130, 131; 130, 132; 131, identifier:page; 132, string:'_scroll_id'; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:scroll_size; 136, call; 136, 137; 136, 138; 137, identifier:len; 138, argument_list; 138, 139; 139, subscript; 139, 140; 139, 143; 140, subscript; 140, 141; 140, 142; 141, identifier:page; 142, string:'hits'; 143, string:'hits'; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:logger; 148, identifier:debug; 149, argument_list; 149, 150; 149, 151; 150, string:"[identities retention] Total inactive identities deleted from SH: %i"; 151, identifier:count | def delete_inactive_unique_identities(es, sortinghat_db, before_date):
page = es.search(
index=IDENTITIES_INDEX,
scroll="360m",
size=SIZE_SCROLL_IDENTITIES_INDEX,
body={
"query": {
"range": {
"last_seen": {
"lte": before_date
}
}
}
}
)
sid = page['_scroll_id']
scroll_size = page['hits']['total']
if scroll_size == 0:
logging.warning("[identities retention] No inactive identities found in %s after %s!",
IDENTITIES_INDEX, before_date)
return
count = 0
while scroll_size > 0:
for item in page['hits']['hits']:
to_delete = item['_source']['sh_uuid']
success = SortingHat.remove_unique_identity(sortinghat_db, to_delete)
count = count + 1 if success else count
page = es.scroll(scroll_id=sid, scroll='60m')
sid = page['_scroll_id']
scroll_size = len(page['hits']['hits'])
logger.debug("[identities retention] Total inactive identities deleted from SH: %i", count) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:retain_identities; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:retention_time; 5, identifier:es_enrichment_url; 6, identifier:sortinghat_db; 7, identifier:data_source; 8, identifier:active_data_sources; 9, block; 9, 10; 9, 19; 9, 27; 9, 47; 9, 54; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:before_date; 13, call; 13, 14; 13, 15; 14, identifier:get_diff_current_date; 15, argument_list; 15, 16; 16, keyword_argument; 16, 17; 16, 18; 17, identifier:minutes; 18, identifier:retention_time; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:before_date_str; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:before_date; 25, identifier:isoformat; 26, argument_list; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:es; 30, call; 30, 31; 30, 32; 31, identifier:Elasticsearch; 32, argument_list; 32, 33; 32, 35; 32, 38; 32, 41; 32, 44; 33, list:[es_enrichment_url]; 33, 34; 34, identifier:es_enrichment_url; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:timeout; 37, integer:120; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:max_retries; 40, integer:20; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:retry_on_timeout; 43, True; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:verify_certs; 46, False; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:delete_inactive_unique_identities; 50, argument_list; 50, 51; 50, 52; 50, 53; 51, identifier:es; 52, identifier:sortinghat_db; 53, identifier:before_date_str; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 57; 56, identifier:delete_orphan_unique_identities; 57, argument_list; 57, 58; 57, 59; 57, 60; 57, 61; 58, identifier:es; 59, identifier:sortinghat_db; 60, identifier:data_source; 61, identifier:active_data_sources | def retain_identities(retention_time, es_enrichment_url, sortinghat_db, data_source, active_data_sources):
before_date = get_diff_current_date(minutes=retention_time)
before_date_str = before_date.isoformat()
es = Elasticsearch([es_enrichment_url], timeout=120, max_retries=20, retry_on_timeout=True, verify_certs=False)
delete_inactive_unique_identities(es, sortinghat_db, before_date_str)
delete_orphan_unique_identities(es, sortinghat_db, data_source, active_data_sources) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:get_review_sh; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:revision; 6, identifier:item; 7, block; 7, 8; 7, 17; 7, 32; 7, 42; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:identity; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:get_sh_identity; 15, argument_list; 15, 16; 16, identifier:revision; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:update; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:parser; 23, identifier:parse; 24, argument_list; 24, 25; 25, subscript; 25, 26; 25, 27; 26, identifier:item; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:get_field_date; 31, argument_list; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:erevision; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:get_item_sh_fields; 39, argument_list; 39, 40; 39, 41; 40, identifier:identity; 41, identifier:update; 42, return_statement; 42, 43; 43, identifier:erevision | def get_review_sh(self, revision, item):
identity = self.get_sh_identity(revision)
update = parser.parse(item[self.get_field_date()])
erevision = self.get_item_sh_fields(identity, update)
return erevision |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:get_item_sh; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:item; 6, default_parameter; 6, 7; 6, 8; 7, identifier:roles; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:date_field; 11, None; 12, block; 12, 13; 12, 17; 12, 25; 12, 34; 12, 62; 12, 71; 12, 154; 12, 158; 12, 229; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:eitem_sh; 16, dictionary; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:author_field; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:get_field_author; 24, argument_list; 25, if_statement; 25, 26; 25, 28; 26, not_operator; 26, 27; 27, identifier:roles; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:roles; 32, list:[author_field]; 32, 33; 33, identifier:author_field; 34, if_statement; 34, 35; 34, 37; 34, 51; 35, not_operator; 35, 36; 36, identifier:date_field; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:item_date; 41, call; 41, 42; 41, 43; 42, identifier:str_to_datetime; 43, argument_list; 43, 44; 44, subscript; 44, 45; 44, 46; 45, identifier:item; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:get_field_date; 50, argument_list; 51, else_clause; 51, 52; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:item_date; 56, call; 56, 57; 56, 58; 57, identifier:str_to_datetime; 58, argument_list; 58, 59; 59, subscript; 59, 60; 59, 61; 60, identifier:item; 61, identifier:date_field; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:users_data; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:get_users_data; 69, argument_list; 69, 70; 70, identifier:item; 71, for_statement; 71, 72; 71, 73; 71, 74; 72, identifier:rol; 73, identifier:roles; 74, block; 74, 75; 75, if_statement; 75, 76; 75, 79; 76, comparison_operator:in; 76, 77; 76, 78; 77, identifier:rol; 78, identifier:users_data; 79, block; 79, 80; 79, 90; 79, 106; 79, 122; 79, 138; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:identity; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:get_sh_identity; 87, argument_list; 87, 88; 87, 89; 88, identifier:item; 89, identifier:rol; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:eitem_sh; 94, identifier:update; 95, argument_list; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:get_item_sh_fields; 100, argument_list; 100, 101; 100, 102; 100, 103; 101, identifier:identity; 102, identifier:item_date; 103, keyword_argument; 103, 104; 103, 105; 104, identifier:rol; 105, identifier:rol; 106, if_statement; 106, 107; 106, 113; 107, not_operator; 107, 108; 108, subscript; 108, 109; 108, 110; 109, identifier:eitem_sh; 110, binary_operator:+; 110, 111; 110, 112; 111, identifier:rol; 112, string:'_org_name'; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 121; 116, subscript; 116, 117; 116, 118; 117, identifier:eitem_sh; 118, binary_operator:+; 118, 119; 118, 120; 119, identifier:rol; 120, string:'_org_name'; 121, identifier:SH_UNKNOWN_VALUE; 122, if_statement; 122, 123; 122, 129; 123, not_operator; 123, 124; 124, subscript; 124, 125; 124, 126; 125, identifier:eitem_sh; 126, binary_operator:+; 126, 127; 126, 128; 127, identifier:rol; 128, string:'_name'; 129, block; 129, 130; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 137; 132, subscript; 132, 133; 132, 134; 133, identifier:eitem_sh; 134, binary_operator:+; 134, 135; 134, 136; 135, identifier:rol; 136, string:'_name'; 137, identifier:SH_UNKNOWN_VALUE; 138, if_statement; 138, 139; 138, 145; 139, not_operator; 139, 140; 140, subscript; 140, 141; 140, 142; 141, identifier:eitem_sh; 142, binary_operator:+; 142, 143; 142, 144; 143, identifier:rol; 144, string:'_user_name'; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 153; 148, subscript; 148, 149; 148, 150; 149, identifier:eitem_sh; 150, binary_operator:+; 150, 151; 150, 152; 151, identifier:rol; 152, string:'_user_name'; 153, identifier:SH_UNKNOWN_VALUE; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:rol_author; 157, string:'author'; 158, if_statement; 158, 159; 158, 166; 159, boolean_operator:and; 159, 160; 159, 163; 160, comparison_operator:in; 160, 161; 160, 162; 161, identifier:author_field; 162, identifier:users_data; 163, comparison_operator:!=; 163, 164; 163, 165; 164, identifier:author_field; 165, identifier:rol_author; 166, block; 166, 167; 166, 177; 166, 193; 166, 205; 166, 217; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:identity; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:self; 173, identifier:get_sh_identity; 174, argument_list; 174, 175; 174, 176; 175, identifier:item; 176, identifier:author_field; 177, expression_statement; 177, 178; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:eitem_sh; 181, identifier:update; 182, argument_list; 182, 183; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:get_item_sh_fields; 187, argument_list; 187, 188; 187, 189; 187, 190; 188, identifier:identity; 189, identifier:item_date; 190, keyword_argument; 190, 191; 190, 192; 191, identifier:rol; 192, identifier:rol_author; 193, if_statement; 193, 194; 193, 198; 194, not_operator; 194, 195; 195, subscript; 195, 196; 195, 197; 196, identifier:eitem_sh; 197, string:'author_org_name'; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 204; 201, subscript; 201, 202; 201, 203; 202, identifier:eitem_sh; 203, string:'author_org_name'; 204, identifier:SH_UNKNOWN_VALUE; 205, if_statement; 205, 206; 205, 210; 206, not_operator; 206, 207; 207, subscript; 207, 208; 207, 209; 208, identifier:eitem_sh; 209, string:'author_name'; 210, block; 210, 211; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 216; 213, subscript; 213, 214; 213, 215; 214, identifier:eitem_sh; 215, string:'author_name'; 216, identifier:SH_UNKNOWN_VALUE; 217, if_statement; 217, 218; 217, 222; 218, not_operator; 218, 219; 219, subscript; 219, 220; 219, 221; 220, identifier:eitem_sh; 221, string:'author_user_name'; 222, block; 222, 223; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 228; 225, subscript; 225, 226; 225, 227; 226, identifier:eitem_sh; 227, string:'author_user_name'; 228, identifier:SH_UNKNOWN_VALUE; 229, return_statement; 229, 230; 230, identifier:eitem_sh | def get_item_sh(self, item, roles=None, date_field=None):
eitem_sh = {}
author_field = self.get_field_author()
if not roles:
roles = [author_field]
if not date_field:
item_date = str_to_datetime(item[self.get_field_date()])
else:
item_date = str_to_datetime(item[date_field])
users_data = self.get_users_data(item)
for rol in roles:
if rol in users_data:
identity = self.get_sh_identity(item, rol)
eitem_sh.update(self.get_item_sh_fields(identity, item_date, rol=rol))
if not eitem_sh[rol + '_org_name']:
eitem_sh[rol + '_org_name'] = SH_UNKNOWN_VALUE
if not eitem_sh[rol + '_name']:
eitem_sh[rol + '_name'] = SH_UNKNOWN_VALUE
if not eitem_sh[rol + '_user_name']:
eitem_sh[rol + '_user_name'] = SH_UNKNOWN_VALUE
rol_author = 'author'
if author_field in users_data and author_field != rol_author:
identity = self.get_sh_identity(item, author_field)
eitem_sh.update(self.get_item_sh_fields(identity, item_date, rol=rol_author))
if not eitem_sh['author_org_name']:
eitem_sh['author_org_name'] = SH_UNKNOWN_VALUE
if not eitem_sh['author_name']:
eitem_sh['author_name'] = SH_UNKNOWN_VALUE
if not eitem_sh['author_user_name']:
eitem_sh['author_user_name'] = SH_UNKNOWN_VALUE
return eitem_sh |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.