sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:merge; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:features; 6, default_parameter; 6, 7; 6, 8; 7, identifier:ignore_strand; 8, False; 9, block; 9, 10; 9, 17; 9, 27; 9, 70; 9, 80; 9, 98; 9, 104; 9, 112; 9, 120; 9, 213; 9, 227; 9, 264; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:features; 13, call; 13, 14; 13, 15; 14, identifier:list; 15, argument_list; 15, 16; 16, identifier:features; 17, if_statement; 17, 18; 17, 24; 18, comparison_operator:==; 18, 19; 18, 23; 19, call; 19, 20; 19, 21; 20, identifier:len; 21, argument_list; 21, 22; 22, identifier:features; 23, integer:0; 24, block; 24, 25; 25, raise_statement; 25, 26; 26, identifier:StopIteration; 27, if_statement; 27, 28; 27, 29; 27, 34; 28, identifier:ignore_strand; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:strand; 33, string:'.'; 34, else_clause; 34, 35; 35, block; 35, 36; 35, 46; 35, 64; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:strands; 39, list_comprehension; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:i; 42, identifier:strand; 43, for_in_clause; 43, 44; 43, 45; 44, identifier:i; 45, identifier:features; 46, if_statement; 46, 47; 46, 56; 47, comparison_operator:>; 47, 48; 47, 55; 48, call; 48, 49; 48, 50; 49, identifier:len; 50, argument_list; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:set; 53, argument_list; 53, 54; 54, identifier:strands; 55, integer:1; 56, block; 56, 57; 57, raise_statement; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:ValueError; 60, argument_list; 60, 61; 61, concatenated_string; 61, 62; 61, 63; 62, string:'Specify ignore_strand=True to force merging '; 63, string:'of multiple strands'; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:strand; 67, subscript; 67, 68; 67, 69; 68, identifier:strands; 69, integer:0; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:chroms; 73, list_comprehension; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:i; 76, identifier:chrom; 77, for_in_clause; 77, 78; 77, 79; 78, identifier:i; 79, identifier:features; 80, if_statement; 80, 81; 80, 90; 81, comparison_operator:>; 81, 82; 81, 89; 82, call; 82, 83; 82, 84; 83, identifier:len; 84, argument_list; 84, 85; 85, call; 85, 86; 85, 87; 86, identifier:set; 87, argument_list; 87, 88; 88, identifier:chroms; 89, integer:1; 90, block; 90, 91; 91, raise_statement; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:NotImplementedError; 94, argument_list; 94, 95; 95, concatenated_string; 95, 96; 95, 97; 96, string:'Merging multiple chromosomes not '; 97, string:'implemented'; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:chrom; 101, subscript; 101, 102; 101, 103; 102, identifier:chroms; 103, integer:0; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:current_merged_start; 107, attribute; 107, 108; 107, 111; 108, subscript; 108, 109; 108, 110; 109, identifier:features; 110, integer:0; 111, identifier:start; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:current_merged_stop; 115, attribute; 115, 116; 115, 119; 116, subscript; 116, 117; 116, 118; 117, identifier:features; 118, integer:0; 119, identifier:stop; 120, for_statement; 120, 121; 120, 122; 120, 127; 121, identifier:feature; 122, subscript; 122, 123; 122, 124; 123, identifier:features; 124, slice; 124, 125; 124, 126; 125, integer:1; 126, colon; 127, block; 127, 128; 128, if_statement; 128, 129; 128, 136; 128, 153; 129, comparison_operator:<=; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:feature; 132, identifier:start; 133, binary_operator:+; 133, 134; 133, 135; 134, identifier:current_merged_stop; 135, integer:1; 136, block; 136, 137; 137, if_statement; 137, 138; 137, 143; 137, 150; 138, comparison_operator:>=; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:feature; 141, identifier:stop; 142, identifier:current_merged_stop; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:current_merged_stop; 147, attribute; 147, 148; 147, 149; 148, identifier:feature; 149, identifier:stop; 150, else_clause; 150, 151; 151, block; 151, 152; 152, continue_statement; 153, else_clause; 153, 154; 154, block; 154, 155; 154, 192; 154, 201; 154, 207; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:merged_feature; 158, call; 158, 159; 158, 160; 159, identifier:dict; 160, argument_list; 160, 161; 160, 166; 160, 169; 160, 174; 160, 177; 160, 180; 160, 183; 160, 186; 160, 189; 161, keyword_argument; 161, 162; 161, 163; 162, identifier:seqid; 163, attribute; 163, 164; 163, 165; 164, identifier:feature; 165, identifier:chrom; 166, keyword_argument; 166, 167; 166, 168; 167, identifier:source; 168, string:'.'; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:featuretype; 171, attribute; 171, 172; 171, 173; 172, identifier:feature; 173, identifier:featuretype; 174, keyword_argument; 174, 175; 174, 176; 175, identifier:start; 176, identifier:current_merged_start; 177, keyword_argument; 177, 178; 177, 179; 178, identifier:end; 179, identifier:current_merged_stop; 180, keyword_argument; 180, 181; 180, 182; 181, identifier:score; 182, string:'.'; 183, keyword_argument; 183, 184; 183, 185; 184, identifier:strand; 185, identifier:strand; 186, keyword_argument; 186, 187; 186, 188; 187, identifier:frame; 188, string:'.'; 189, keyword_argument; 189, 190; 189, 191; 190, identifier:attributes; 191, string:''; 192, expression_statement; 192, 193; 193, yield; 193, 194; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:self; 197, identifier:_feature_returner; 198, argument_list; 198, 199; 199, dictionary_splat; 199, 200; 200, identifier:merged_feature; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:current_merged_start; 204, attribute; 204, 205; 204, 206; 205, identifier:feature; 206, identifier:start; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:current_merged_stop; 210, attribute; 210, 211; 210, 212; 211, identifier:feature; 212, identifier:stop; 213, if_statement; 213, 214; 213, 220; 214, comparison_operator:==; 214, 215; 214, 219; 215, call; 215, 216; 215, 217; 216, identifier:len; 217, argument_list; 217, 218; 218, identifier:features; 219, integer:1; 220, block; 220, 221; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:feature; 224, subscript; 224, 225; 224, 226; 225, identifier:features; 226, integer:0; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:merged_feature; 230, call; 230, 231; 230, 232; 231, identifier:dict; 232, argument_list; 232, 233; 232, 238; 232, 241; 232, 246; 232, 249; 232, 252; 232, 255; 232, 258; 232, 261; 233, keyword_argument; 233, 234; 233, 235; 234, identifier:seqid; 235, attribute; 235, 236; 235, 237; 236, identifier:feature; 237, identifier:chrom; 238, keyword_argument; 238, 239; 238, 240; 239, identifier:source; 240, string:'.'; 241, keyword_argument; 241, 242; 241, 243; 242, identifier:featuretype; 243, attribute; 243, 244; 243, 245; 244, identifier:feature; 245, identifier:featuretype; 246, keyword_argument; 246, 247; 246, 248; 247, identifier:start; 248, identifier:current_merged_start; 249, keyword_argument; 249, 250; 249, 251; 250, identifier:end; 251, identifier:current_merged_stop; 252, keyword_argument; 252, 253; 252, 254; 253, identifier:score; 254, string:'.'; 255, keyword_argument; 255, 256; 255, 257; 256, identifier:strand; 257, identifier:strand; 258, keyword_argument; 258, 259; 258, 260; 259, identifier:frame; 260, string:'.'; 261, keyword_argument; 261, 262; 261, 263; 262, identifier:attributes; 263, string:''; 264, expression_statement; 264, 265; 265, yield; 265, 266; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:self; 269, identifier:_feature_returner; 270, argument_list; 270, 271; 271, dictionary_splat; 271, 272; 272, identifier:merged_feature | def merge(self, features, ignore_strand=False):
features = list(features)
if len(features) == 0:
raise StopIteration
if ignore_strand:
strand = '.'
else:
strands = [i.strand for i in features]
if len(set(strands)) > 1:
raise ValueError('Specify ignore_strand=True to force merging '
'of multiple strands')
strand = strands[0]
chroms = [i.chrom for i in features]
if len(set(chroms)) > 1:
raise NotImplementedError('Merging multiple chromosomes not '
'implemented')
chrom = chroms[0]
current_merged_start = features[0].start
current_merged_stop = features[0].stop
for feature in features[1:]:
if feature.start <= current_merged_stop + 1:
if feature.stop >= current_merged_stop:
current_merged_stop = feature.stop
else:
continue
else:
merged_feature = dict(
seqid=feature.chrom,
source='.',
featuretype=feature.featuretype,
start=current_merged_start,
end=current_merged_stop,
score='.',
strand=strand,
frame='.',
attributes='')
yield self._feature_returner(**merged_feature)
current_merged_start = feature.start
current_merged_stop = feature.stop
if len(features) == 1:
feature = features[0]
merged_feature = dict(
seqid=feature.chrom,
source='.',
featuretype=feature.featuretype,
start=current_merged_start,
end=current_merged_stop,
score='.',
strand=strand,
frame='.',
attributes='')
yield self._feature_returner(**merged_feature) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:bed12; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 10; 3, 14; 3, 17; 3, 20; 4, identifier:self; 5, identifier:feature; 6, default_parameter; 6, 7; 6, 8; 7, identifier:block_featuretype; 8, list:['exon']; 8, 9; 9, string:'exon'; 10, default_parameter; 10, 11; 10, 12; 11, identifier:thick_featuretype; 12, list:['CDS']; 12, 13; 13, string:'CDS'; 14, default_parameter; 14, 15; 14, 16; 15, identifier:thin_featuretype; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:name_field; 19, string:'ID'; 20, default_parameter; 20, 21; 20, 22; 21, identifier:color; 22, None; 23, block; 23, 24; 23, 36; 23, 54; 23, 67; 23, 73; 23, 81; 23, 90; 23, 108; 23, 126; 23, 135; 23, 149; 23, 155; 23, 163; 23, 169; 23, 175; 23, 181; 23, 198; 23, 204; 23, 210; 23, 219; 23, 225; 23, 229; 23, 236; 23, 247; 23, 261; 23, 323; 23, 385; 23, 399; 23, 408; 23, 442; 24, if_statement; 24, 25; 24, 28; 25, boolean_operator:and; 25, 26; 25, 27; 26, identifier:thick_featuretype; 27, identifier:thin_featuretype; 28, block; 28, 29; 29, raise_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:ValueError; 32, argument_list; 32, 33; 33, concatenated_string; 33, 34; 33, 35; 34, string:"Can only specify one of `thick_featuertype` or "; 35, string:"`thin_featuretype`"; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:exons; 39, call; 39, 40; 39, 41; 40, identifier:list; 41, argument_list; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:children; 46, argument_list; 46, 47; 46, 48; 46, 51; 47, identifier:feature; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:featuretype; 50, identifier:block_featuretype; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:order_by; 53, string:'start'; 54, if_statement; 54, 55; 54, 61; 55, comparison_operator:==; 55, 56; 55, 60; 56, call; 56, 57; 56, 58; 57, identifier:len; 58, argument_list; 58, 59; 59, identifier:exons; 60, integer:0; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:exons; 65, list:[feature]; 65, 66; 66, identifier:feature; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:feature; 70, subscript; 70, 71; 70, 72; 71, identifier:self; 72, identifier:feature; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:first; 76, attribute; 76, 77; 76, 80; 77, subscript; 77, 78; 77, 79; 78, identifier:exons; 79, integer:0; 80, identifier:start; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:last; 84, attribute; 84, 85; 84, 89; 85, subscript; 85, 86; 85, 87; 86, identifier:exons; 87, unary_operator:-; 87, 88; 88, integer:1; 89, identifier:stop; 90, if_statement; 90, 91; 90, 96; 91, comparison_operator:!=; 91, 92; 91, 93; 92, identifier:first; 93, attribute; 93, 94; 93, 95; 94, identifier:feature; 95, identifier:start; 96, block; 96, 97; 97, raise_statement; 97, 98; 98, call; 98, 99; 98, 100; 99, identifier:ValueError; 100, argument_list; 100, 101; 101, binary_operator:%; 101, 102; 101, 103; 102, string:"Start of first exon (%s) does not match start of feature (%s)"; 103, tuple; 103, 104; 103, 105; 104, identifier:first; 105, attribute; 105, 106; 105, 107; 106, identifier:feature; 107, identifier:start; 108, if_statement; 108, 109; 108, 114; 109, comparison_operator:!=; 109, 110; 109, 111; 110, identifier:last; 111, attribute; 111, 112; 111, 113; 112, identifier:feature; 113, identifier:stop; 114, block; 114, 115; 115, raise_statement; 115, 116; 116, call; 116, 117; 116, 118; 117, identifier:ValueError; 118, argument_list; 118, 119; 119, binary_operator:%; 119, 120; 119, 121; 120, string:"End of last exon (%s) does not match end of feature (%s)"; 121, tuple; 121, 122; 121, 123; 122, identifier:last; 123, attribute; 123, 124; 123, 125; 124, identifier:feature; 125, identifier:stop; 126, if_statement; 126, 127; 126, 130; 127, comparison_operator:is; 127, 128; 127, 129; 128, identifier:color; 129, None; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:color; 134, string:'0,0,0'; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:color; 138, call; 138, 139; 138, 148; 139, attribute; 139, 140; 139, 147; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:color; 143, identifier:replace; 144, argument_list; 144, 145; 144, 146; 145, string:' '; 146, string:''; 147, identifier:strip; 148, argument_list; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:chrom; 152, attribute; 152, 153; 152, 154; 153, identifier:feature; 154, identifier:chrom; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:chromStart; 158, binary_operator:-; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:feature; 161, identifier:start; 162, integer:1; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:chromEnd; 166, attribute; 166, 167; 166, 168; 167, identifier:feature; 168, identifier:stop; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:orig; 172, attribute; 172, 173; 172, 174; 173, identifier:constants; 174, identifier:always_return_list; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:constants; 179, identifier:always_return_list; 180, True; 181, try_statement; 181, 182; 181, 191; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:name; 186, subscript; 186, 187; 186, 190; 187, subscript; 187, 188; 187, 189; 188, identifier:feature; 189, identifier:name_field; 190, integer:0; 191, except_clause; 191, 192; 191, 193; 192, identifier:KeyError; 193, block; 193, 194; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:name; 197, string:"."; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:constants; 202, identifier:always_return_list; 203, identifier:orig; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:score; 207, attribute; 207, 208; 207, 209; 208, identifier:feature; 209, identifier:score; 210, if_statement; 210, 211; 210, 214; 211, comparison_operator:==; 211, 212; 211, 213; 212, identifier:score; 213, string:'.'; 214, block; 214, 215; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:score; 218, string:'0'; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:strand; 222, attribute; 222, 223; 222, 224; 223, identifier:feature; 224, identifier:strand; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:itemRgb; 228, identifier:color; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:blockCount; 232, call; 232, 233; 232, 234; 233, identifier:len; 234, argument_list; 234, 235; 235, identifier:exons; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:blockSizes; 239, list_comprehension; 239, 240; 239, 244; 240, call; 240, 241; 240, 242; 241, identifier:len; 242, argument_list; 242, 243; 243, identifier:i; 244, for_in_clause; 244, 245; 244, 246; 245, identifier:i; 246, identifier:exons; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:blockStarts; 250, list_comprehension; 250, 251; 250, 258; 251, binary_operator:-; 251, 252; 251, 257; 252, binary_operator:-; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:i; 255, identifier:start; 256, integer:1; 257, identifier:chromStart; 258, for_in_clause; 258, 259; 258, 260; 259, identifier:i; 260, identifier:exons; 261, if_statement; 261, 262; 261, 263; 262, identifier:thick_featuretype; 263, block; 263, 264; 263, 282; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 267; 266, identifier:thick; 267, call; 267, 268; 267, 269; 268, identifier:list; 269, argument_list; 269, 270; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:self; 273, identifier:children; 274, argument_list; 274, 275; 274, 276; 274, 279; 275, identifier:feature; 276, keyword_argument; 276, 277; 276, 278; 277, identifier:featuretype; 278, identifier:thick_featuretype; 279, keyword_argument; 279, 280; 279, 281; 280, identifier:order_by; 281, string:'start'; 282, if_statement; 282, 283; 282, 289; 282, 302; 283, comparison_operator:==; 283, 284; 283, 288; 284, call; 284, 285; 284, 286; 285, identifier:len; 286, argument_list; 286, 287; 287, identifier:thick; 288, integer:0; 289, block; 289, 290; 289, 296; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 293; 292, identifier:thickStart; 293, attribute; 293, 294; 293, 295; 294, identifier:feature; 295, identifier:start; 296, expression_statement; 296, 297; 297, assignment; 297, 298; 297, 299; 298, identifier:thickEnd; 299, attribute; 299, 300; 299, 301; 300, identifier:feature; 301, identifier:stop; 302, else_clause; 302, 303; 303, block; 303, 304; 303, 314; 304, expression_statement; 304, 305; 305, assignment; 305, 306; 305, 307; 306, identifier:thickStart; 307, binary_operator:-; 307, 308; 307, 313; 308, attribute; 308, 309; 308, 312; 309, subscript; 309, 310; 309, 311; 310, identifier:thick; 311, integer:0; 312, identifier:start; 313, integer:1; 314, expression_statement; 314, 315; 315, assignment; 315, 316; 315, 317; 316, identifier:thickEnd; 317, attribute; 317, 318; 317, 322; 318, subscript; 318, 319; 318, 320; 319, identifier:thick; 320, unary_operator:-; 320, 321; 321, integer:1; 322, identifier:stop; 323, if_statement; 323, 324; 323, 325; 324, identifier:thin_featuretype; 325, block; 325, 326; 325, 344; 326, expression_statement; 326, 327; 327, assignment; 327, 328; 327, 329; 328, identifier:thin; 329, call; 329, 330; 329, 331; 330, identifier:list; 331, argument_list; 331, 332; 332, call; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:self; 335, identifier:children; 336, argument_list; 336, 337; 336, 338; 336, 341; 337, identifier:feature; 338, keyword_argument; 338, 339; 338, 340; 339, identifier:featuretype; 340, identifier:thin_featuretype; 341, keyword_argument; 341, 342; 341, 343; 342, identifier:order_by; 343, string:'start'; 344, if_statement; 344, 345; 344, 351; 344, 364; 345, comparison_operator:==; 345, 346; 345, 350; 346, call; 346, 347; 346, 348; 347, identifier:len; 348, argument_list; 348, 349; 349, identifier:thin; 350, integer:0; 351, block; 351, 352; 351, 358; 352, expression_statement; 352, 353; 353, assignment; 353, 354; 353, 355; 354, identifier:thickStart; 355, attribute; 355, 356; 355, 357; 356, identifier:feature; 357, identifier:start; 358, expression_statement; 358, 359; 359, assignment; 359, 360; 359, 361; 360, identifier:thickEnd; 361, attribute; 361, 362; 361, 363; 362, identifier:feature; 363, identifier:stop; 364, else_clause; 364, 365; 365, block; 365, 366; 365, 374; 366, expression_statement; 366, 367; 367, assignment; 367, 368; 367, 369; 368, identifier:thickStart; 369, attribute; 369, 370; 369, 373; 370, subscript; 370, 371; 370, 372; 371, identifier:thin; 372, integer:0; 373, identifier:stop; 374, expression_statement; 374, 375; 375, assignment; 375, 376; 375, 377; 376, identifier:thickEnd; 377, binary_operator:-; 377, 378; 377, 384; 378, attribute; 378, 379; 378, 383; 379, subscript; 379, 380; 379, 381; 380, identifier:thin; 381, unary_operator:-; 381, 382; 382, integer:1; 383, identifier:start; 384, integer:1; 385, expression_statement; 385, 386; 386, assignment; 386, 387; 386, 388; 387, identifier:tst; 388, binary_operator:+; 388, 389; 388, 395; 389, binary_operator:+; 389, 390; 389, 391; 390, identifier:chromStart; 391, subscript; 391, 392; 391, 393; 392, identifier:blockStarts; 393, unary_operator:-; 393, 394; 394, integer:1; 395, subscript; 395, 396; 395, 397; 396, identifier:blockSizes; 397, unary_operator:-; 397, 398; 398, integer:1; 399, assert_statement; 399, 400; 399, 403; 400, comparison_operator:==; 400, 401; 400, 402; 401, identifier:tst; 402, identifier:chromEnd; 403, binary_operator:%; 403, 404; 403, 405; 404, string:"tst=%s; chromEnd=%s"; 405, tuple; 405, 406; 405, 407; 406, identifier:tst; 407, identifier:chromEnd; 408, expression_statement; 408, 409; 409, assignment; 409, 410; 409, 411; 410, identifier:fields; 411, list:[
chrom,
chromStart,
chromEnd,
name,
score,
strand,
thickStart,
thickEnd,
itemRgb,
blockCount,
','.join(map(str, blockSizes)),
','.join(map(str, blockStarts))]; 411, 412; 411, 413; 411, 414; 411, 415; 411, 416; 411, 417; 411, 418; 411, 419; 411, 420; 411, 421; 411, 422; 411, 432; 412, identifier:chrom; 413, identifier:chromStart; 414, identifier:chromEnd; 415, identifier:name; 416, identifier:score; 417, identifier:strand; 418, identifier:thickStart; 419, identifier:thickEnd; 420, identifier:itemRgb; 421, identifier:blockCount; 422, call; 422, 423; 422, 426; 423, attribute; 423, 424; 423, 425; 424, string:','; 425, identifier:join; 426, argument_list; 426, 427; 427, call; 427, 428; 427, 429; 428, identifier:map; 429, argument_list; 429, 430; 429, 431; 430, identifier:str; 431, identifier:blockSizes; 432, call; 432, 433; 432, 436; 433, attribute; 433, 434; 433, 435; 434, string:','; 435, identifier:join; 436, argument_list; 436, 437; 437, call; 437, 438; 437, 439; 438, identifier:map; 439, argument_list; 439, 440; 439, 441; 440, identifier:str; 441, identifier:blockStarts; 442, return_statement; 442, 443; 443, call; 443, 444; 443, 447; 444, attribute; 444, 445; 444, 446; 445, string:'\t'; 446, identifier:join; 447, argument_list; 447, 448; 448, call; 448, 449; 448, 450; 449, identifier:map; 450, argument_list; 450, 451; 450, 452; 451, identifier:str; 452, identifier:fields | def bed12(self, feature, block_featuretype=['exon'],
thick_featuretype=['CDS'], thin_featuretype=None,
name_field='ID', color=None):
if thick_featuretype and thin_featuretype:
raise ValueError("Can only specify one of `thick_featuertype` or "
"`thin_featuretype`")
exons = list(self.children(feature, featuretype=block_featuretype,
order_by='start'))
if len(exons) == 0:
exons = [feature]
feature = self[feature]
first = exons[0].start
last = exons[-1].stop
if first != feature.start:
raise ValueError(
"Start of first exon (%s) does not match start of feature (%s)"
% (first, feature.start))
if last != feature.stop:
raise ValueError(
"End of last exon (%s) does not match end of feature (%s)"
% (last, feature.stop))
if color is None:
color = '0,0,0'
color = color.replace(' ', '').strip()
chrom = feature.chrom
chromStart = feature.start - 1
chromEnd = feature.stop
orig = constants.always_return_list
constants.always_return_list = True
try:
name = feature[name_field][0]
except KeyError:
name = "."
constants.always_return_list = orig
score = feature.score
if score == '.':
score = '0'
strand = feature.strand
itemRgb = color
blockCount = len(exons)
blockSizes = [len(i) for i in exons]
blockStarts = [i.start - 1 - chromStart for i in exons]
if thick_featuretype:
thick = list(self.children(feature, featuretype=thick_featuretype,
order_by='start'))
if len(thick) == 0:
thickStart = feature.start
thickEnd = feature.stop
else:
thickStart = thick[0].start - 1
thickEnd = thick[-1].stop
if thin_featuretype:
thin = list(self.children(feature, featuretype=thin_featuretype,
order_by='start'))
if len(thin) == 0:
thickStart = feature.start
thickEnd = feature.stop
else:
thickStart = thin[0].stop
thickEnd = thin[-1].start - 1
tst = chromStart + blockStarts[-1] + blockSizes[-1]
assert tst == chromEnd, "tst=%s; chromEnd=%s" % (tst, chromEnd)
fields = [
chrom,
chromStart,
chromEnd,
name,
score,
strand,
thickStart,
thickEnd,
itemRgb,
blockCount,
','.join(map(str, blockSizes)),
','.join(map(str, blockStarts))]
return '\t'.join(map(str, fields)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:inspect; 3, parameters; 3, 4; 3, 5; 3, 12; 3, 15; 4, identifier:data; 5, default_parameter; 5, 6; 5, 7; 6, identifier:look_for; 7, list:['featuretype', 'chrom', 'attribute_keys',
'feature_count']; 7, 8; 7, 9; 7, 10; 7, 11; 8, string:'featuretype'; 9, string:'chrom'; 10, string:'attribute_keys'; 11, string:'feature_count'; 12, default_parameter; 12, 13; 12, 14; 13, identifier:limit; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:verbose; 17, True; 18, block; 18, 19; 18, 23; 18, 27; 18, 53; 18, 59; 18, 68; 18, 72; 18, 146; 18, 150; 18, 169; 18, 175; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:results; 22, dictionary; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:obj_attrs; 26, list:[]; 27, for_statement; 27, 28; 27, 29; 27, 30; 28, identifier:i; 29, identifier:look_for; 30, block; 30, 31; 30, 45; 31, if_statement; 31, 32; 31, 37; 32, comparison_operator:not; 32, 33; 32, 34; 33, identifier:i; 34, list:['attribute_keys', 'feature_count']; 34, 35; 34, 36; 35, string:'attribute_keys'; 36, string:'feature_count'; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:obj_attrs; 42, identifier:append; 43, argument_list; 43, 44; 44, identifier:i; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, subscript; 47, 48; 47, 49; 48, identifier:results; 49, identifier:i; 50, call; 50, 51; 50, 52; 51, identifier:Counter; 52, argument_list; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:attr_keys; 56, comparison_operator:in; 56, 57; 56, 58; 57, string:'attribute_keys'; 58, identifier:look_for; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:d; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:iterators; 65, identifier:DataIterator; 66, argument_list; 66, 67; 67, identifier:data; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:feature_count; 71, integer:0; 72, for_statement; 72, 73; 72, 74; 72, 75; 73, identifier:f; 74, identifier:d; 75, block; 75, 76; 75, 98; 75, 116; 75, 134; 75, 138; 76, if_statement; 76, 77; 76, 78; 77, identifier:verbose; 78, block; 78, 79; 78, 90; 79, expression_statement; 79, 80; 80, call; 80, 81; 80, 86; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:sys; 84, identifier:stderr; 85, identifier:write; 86, argument_list; 86, 87; 87, binary_operator:%; 87, 88; 87, 89; 88, string:'\r%s features inspected'; 89, identifier:feature_count; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 97; 92, attribute; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:sys; 95, identifier:stderr; 96, identifier:flush; 97, argument_list; 98, for_statement; 98, 99; 98, 100; 98, 101; 99, identifier:obj_attr; 100, identifier:obj_attrs; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 109; 104, attribute; 104, 105; 104, 108; 105, subscript; 105, 106; 105, 107; 106, identifier:results; 107, identifier:obj_attr; 108, identifier:update; 109, argument_list; 109, 110; 110, list:[getattr(f, obj_attr)]; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:getattr; 113, argument_list; 113, 114; 113, 115; 114, identifier:f; 115, identifier:obj_attr; 116, if_statement; 116, 117; 116, 118; 117, identifier:attr_keys; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 126; 121, attribute; 121, 122; 121, 125; 122, subscript; 122, 123; 122, 124; 123, identifier:results; 124, string:'attribute_keys'; 125, identifier:update; 126, argument_list; 126, 127; 127, call; 127, 128; 127, 133; 128, attribute; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:f; 131, identifier:attributes; 132, identifier:keys; 133, argument_list; 134, expression_statement; 134, 135; 135, augmented_assignment:+=; 135, 136; 135, 137; 136, identifier:feature_count; 137, integer:1; 138, if_statement; 138, 139; 138, 144; 139, boolean_operator:and; 139, 140; 139, 141; 140, identifier:limit; 141, comparison_operator:==; 141, 142; 141, 143; 142, identifier:feature_count; 143, identifier:limit; 144, block; 144, 145; 145, break_statement; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:new_results; 149, dictionary; 150, for_statement; 150, 151; 150, 154; 150, 159; 151, pattern_list; 151, 152; 151, 153; 152, identifier:k; 153, identifier:v; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:results; 157, identifier:items; 158, argument_list; 159, block; 159, 160; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 165; 162, subscript; 162, 163; 162, 164; 163, identifier:new_results; 164, identifier:k; 165, call; 165, 166; 165, 167; 166, identifier:dict; 167, argument_list; 167, 168; 168, identifier:v; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 174; 171, subscript; 171, 172; 171, 173; 172, identifier:new_results; 173, string:'feature_count'; 174, identifier:feature_count; 175, return_statement; 175, 176; 176, identifier:new_results | def inspect(data, look_for=['featuretype', 'chrom', 'attribute_keys',
'feature_count'], limit=None, verbose=True):
results = {}
obj_attrs = []
for i in look_for:
if i not in ['attribute_keys', 'feature_count']:
obj_attrs.append(i)
results[i] = Counter()
attr_keys = 'attribute_keys' in look_for
d = iterators.DataIterator(data)
feature_count = 0
for f in d:
if verbose:
sys.stderr.write('\r%s features inspected' % feature_count)
sys.stderr.flush()
for obj_attr in obj_attrs:
results[obj_attr].update([getattr(f, obj_attr)])
if attr_keys:
results['attribute_keys'].update(f.attributes.keys())
feature_count += 1
if limit and feature_count == limit:
break
new_results = {}
for k, v in results.items():
new_results[k] = dict(v)
new_results['feature_count'] = feature_count
return new_results |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:feature_from_line; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:line; 5, default_parameter; 5, 6; 5, 7; 6, identifier:dialect; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:strict; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:keep_order; 13, False; 14, block; 14, 15; 14, 125; 14, 140; 14, 154; 14, 170; 14, 176; 14, 186; 14, 192; 14, 201; 15, if_statement; 15, 16; 15, 18; 15, 109; 16, not_operator; 16, 17; 17, identifier:strict; 18, block; 18, 19; 18, 28; 18, 32; 18, 59; 18, 67; 18, 73; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:lines; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:line; 25, identifier:splitlines; 26, argument_list; 26, 27; 27, False; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:_lines; 31, list:[]; 32, for_statement; 32, 33; 32, 34; 32, 35; 33, identifier:i; 34, identifier:lines; 35, block; 35, 36; 35, 44; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:i; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:i; 42, identifier:strip; 43, argument_list; 44, if_statement; 44, 45; 44, 51; 45, comparison_operator:>; 45, 46; 45, 50; 46, call; 46, 47; 46, 48; 47, identifier:len; 48, argument_list; 48, 49; 49, identifier:i; 50, integer:0; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:_lines; 56, identifier:append; 57, argument_list; 57, 58; 58, identifier:i; 59, assert_statement; 59, 60; 59, 66; 60, comparison_operator:==; 60, 61; 60, 65; 61, call; 61, 62; 61, 63; 62, identifier:len; 63, argument_list; 63, 64; 64, identifier:_lines; 65, integer:1; 66, identifier:_lines; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:line; 70, subscript; 70, 71; 70, 72; 71, identifier:_lines; 72, integer:0; 73, if_statement; 73, 74; 73, 77; 73, 92; 74, comparison_operator:in; 74, 75; 74, 76; 75, string:'\t'; 76, identifier:line; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:fields; 81, call; 81, 82; 81, 90; 82, attribute; 82, 83; 82, 89; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:line; 86, identifier:rstrip; 87, argument_list; 87, 88; 88, string:'\n\r'; 89, identifier:split; 90, argument_list; 90, 91; 91, string:'\t'; 92, else_clause; 92, 93; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:fields; 97, call; 97, 98; 97, 106; 98, attribute; 98, 99; 98, 105; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:line; 102, identifier:rstrip; 103, argument_list; 103, 104; 104, string:'\n\r'; 105, identifier:split; 106, argument_list; 106, 107; 106, 108; 107, None; 108, integer:8; 109, else_clause; 109, 110; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:fields; 114, call; 114, 115; 114, 123; 115, attribute; 115, 116; 115, 122; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:line; 119, identifier:rstrip; 120, argument_list; 120, 121; 121, string:'\n\r'; 122, identifier:split; 123, argument_list; 123, 124; 124, string:'\t'; 125, try_statement; 125, 126; 125, 133; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:attr_string; 130, subscript; 130, 131; 130, 132; 131, identifier:fields; 132, integer:8; 133, except_clause; 133, 134; 133, 135; 134, identifier:IndexError; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:attr_string; 139, string:""; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 145; 142, pattern_list; 142, 143; 142, 144; 143, identifier:attrs; 144, identifier:_dialect; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:parser; 148, identifier:_split_keyvals; 149, argument_list; 149, 150; 149, 151; 150, identifier:attr_string; 151, keyword_argument; 151, 152; 151, 153; 152, identifier:dialect; 153, identifier:dialect; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:d; 157, call; 157, 158; 157, 159; 158, identifier:dict; 159, argument_list; 159, 160; 160, call; 160, 161; 160, 162; 161, identifier:list; 162, argument_list; 162, 163; 163, call; 163, 164; 163, 165; 164, identifier:zip; 165, argument_list; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:constants; 168, identifier:_gffkeys; 169, identifier:fields; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 175; 172, subscript; 172, 173; 172, 174; 173, identifier:d; 174, string:'attributes'; 175, identifier:attrs; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 181; 178, subscript; 178, 179; 178, 180; 179, identifier:d; 180, string:'extra'; 181, subscript; 181, 182; 181, 183; 182, identifier:fields; 183, slice; 183, 184; 183, 185; 184, integer:9; 185, colon; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 191; 188, subscript; 188, 189; 188, 190; 189, identifier:d; 190, string:'keep_order'; 191, identifier:keep_order; 192, if_statement; 192, 193; 192, 196; 193, comparison_operator:is; 193, 194; 193, 195; 194, identifier:dialect; 195, None; 196, block; 196, 197; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 200; 199, identifier:dialect; 200, identifier:_dialect; 201, return_statement; 201, 202; 202, call; 202, 203; 202, 204; 203, identifier:Feature; 204, argument_list; 204, 205; 204, 208; 205, keyword_argument; 205, 206; 205, 207; 206, identifier:dialect; 207, identifier:dialect; 208, dictionary_splat; 208, 209; 209, identifier:d | def feature_from_line(line, dialect=None, strict=True, keep_order=False):
if not strict:
lines = line.splitlines(False)
_lines = []
for i in lines:
i = i.strip()
if len(i) > 0:
_lines.append(i)
assert len(_lines) == 1, _lines
line = _lines[0]
if '\t' in line:
fields = line.rstrip('\n\r').split('\t')
else:
fields = line.rstrip('\n\r').split(None, 8)
else:
fields = line.rstrip('\n\r').split('\t')
try:
attr_string = fields[8]
except IndexError:
attr_string = ""
attrs, _dialect = parser._split_keyvals(attr_string, dialect=dialect)
d = dict(list(zip(constants._gffkeys, fields)))
d['attributes'] = attrs
d['extra'] = fields[9:]
d['keep_order'] = keep_order
if dialect is None:
dialect = _dialect
return Feature(dialect=dialect, **d) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:_reconstruct; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:keyvals; 5, identifier:dialect; 6, default_parameter; 6, 7; 6, 8; 7, identifier:keep_order; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort_attribute_values; 11, False; 12, block; 12, 13; 12, 21; 12, 27; 12, 31; 12, 92; 12, 157; 12, 180; 12, 192; 12, 284; 12, 295; 12, 304; 13, if_statement; 13, 14; 13, 16; 14, not_operator; 14, 15; 15, identifier:dialect; 16, block; 16, 17; 17, raise_statement; 17, 18; 18, call; 18, 19; 18, 20; 19, identifier:AttributeStringError; 20, argument_list; 21, if_statement; 21, 22; 21, 24; 22, not_operator; 22, 23; 23, identifier:keyvals; 24, block; 24, 25; 25, return_statement; 25, 26; 26, string:""; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:parts; 30, list:[]; 31, if_statement; 31, 32; 31, 41; 31, 46; 32, boolean_operator:or; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:constants; 35, identifier:ignore_url_escape_characters; 36, comparison_operator:!=; 36, 37; 36, 40; 37, subscript; 37, 38; 37, 39; 38, identifier:dialect; 39, string:'fmt'; 40, string:'gff3'; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:attributes; 45, identifier:keyvals; 46, else_clause; 46, 47; 47, block; 47, 48; 47, 52; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:attributes; 51, dictionary; 52, for_statement; 52, 53; 52, 56; 52, 61; 53, pattern_list; 53, 54; 53, 55; 54, identifier:k; 55, identifier:v; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:keyvals; 59, identifier:items; 60, argument_list; 61, block; 61, 62; 61, 68; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 67; 64, subscript; 64, 65; 64, 66; 65, identifier:attributes; 66, identifier:k; 67, list:[]; 68, for_statement; 68, 69; 68, 70; 68, 71; 69, identifier:i; 70, identifier:v; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 79; 74, attribute; 74, 75; 74, 78; 75, subscript; 75, 76; 75, 77; 76, identifier:attributes; 77, identifier:k; 78, identifier:append; 79, argument_list; 79, 80; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, string:''; 83, identifier:join; 84, argument_list; 84, 85; 85, list_comprehension; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:quoter; 88, identifier:j; 89, for_in_clause; 89, 90; 89, 91; 90, identifier:j; 91, identifier:i; 92, if_statement; 92, 93; 92, 96; 92, 144; 93, subscript; 93, 94; 93, 95; 94, identifier:dialect; 95, string:'repeated keys'; 96, block; 96, 97; 96, 101; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:items; 100, list:[]; 101, for_statement; 101, 102; 101, 105; 101, 110; 102, pattern_list; 102, 103; 102, 104; 103, identifier:key; 104, identifier:val; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:attributes; 108, identifier:items; 109, argument_list; 110, block; 110, 111; 111, if_statement; 111, 112; 111, 118; 111, 133; 112, comparison_operator:>; 112, 113; 112, 117; 113, call; 113, 114; 113, 115; 114, identifier:len; 115, argument_list; 115, 116; 116, identifier:val; 117, integer:1; 118, block; 118, 119; 119, for_statement; 119, 120; 119, 121; 119, 122; 120, identifier:v; 121, identifier:val; 122, block; 122, 123; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:items; 127, identifier:append; 128, argument_list; 128, 129; 129, tuple; 129, 130; 129, 131; 130, identifier:key; 131, list:[v]; 131, 132; 132, identifier:v; 133, else_clause; 133, 134; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:items; 139, identifier:append; 140, argument_list; 140, 141; 141, tuple; 141, 142; 141, 143; 142, identifier:key; 143, identifier:val; 144, else_clause; 144, 145; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:items; 149, call; 149, 150; 149, 151; 150, identifier:list; 151, argument_list; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:attributes; 155, identifier:items; 156, argument_list; 157, function_definition; 157, 158; 157, 159; 157, 161; 158, function_name:sort_key; 159, parameters; 159, 160; 160, identifier:x; 161, block; 161, 162; 162, try_statement; 162, 163; 162, 175; 163, block; 163, 164; 164, return_statement; 164, 165; 165, call; 165, 166; 165, 171; 166, attribute; 166, 167; 166, 170; 167, subscript; 167, 168; 167, 169; 168, identifier:dialect; 169, string:'order'; 170, identifier:index; 171, argument_list; 171, 172; 172, subscript; 172, 173; 172, 174; 173, identifier:x; 174, integer:0; 175, except_clause; 175, 176; 175, 177; 176, identifier:ValueError; 177, block; 177, 178; 178, return_statement; 178, 179; 179, float:1e6; 180, if_statement; 180, 181; 180, 182; 181, identifier:keep_order; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:items; 187, identifier:sort; 188, argument_list; 188, 189; 189, keyword_argument; 189, 190; 189, 191; 190, identifier:key; 191, identifier:sort_key; 192, for_statement; 192, 193; 192, 196; 192, 197; 193, pattern_list; 193, 194; 193, 195; 194, identifier:key; 195, identifier:val; 196, identifier:items; 197, block; 197, 198; 197, 277; 198, if_statement; 198, 199; 198, 200; 198, 249; 199, identifier:val; 200, block; 200, 201; 200, 211; 200, 222; 201, if_statement; 201, 202; 201, 203; 202, identifier:sort_attribute_values; 203, block; 203, 204; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:val; 207, call; 207, 208; 207, 209; 208, identifier:sorted; 209, argument_list; 209, 210; 210, identifier:val; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:val_str; 214, call; 214, 215; 214, 220; 215, attribute; 215, 216; 215, 219; 216, subscript; 216, 217; 216, 218; 217, identifier:dialect; 218, string:'multival separator'; 219, identifier:join; 220, argument_list; 220, 221; 221, identifier:val; 222, if_statement; 222, 223; 222, 224; 223, identifier:val_str; 224, block; 224, 225; 224, 236; 225, if_statement; 225, 226; 225, 229; 226, subscript; 226, 227; 226, 228; 227, identifier:dialect; 228, string:'quoted GFF2 values'; 229, block; 229, 230; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:val_str; 233, binary_operator:%; 233, 234; 233, 235; 234, string:'"%s"'; 235, identifier:val_str; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:part; 239, call; 239, 240; 239, 245; 240, attribute; 240, 241; 240, 244; 241, subscript; 241, 242; 241, 243; 242, identifier:dialect; 243, string:'keyval separator'; 244, identifier:join; 245, argument_list; 245, 246; 246, list:[key, val_str]; 246, 247; 246, 248; 247, identifier:key; 248, identifier:val_str; 249, else_clause; 249, 250; 250, block; 250, 251; 251, if_statement; 251, 252; 251, 257; 251, 271; 252, comparison_operator:==; 252, 253; 252, 256; 253, subscript; 253, 254; 253, 255; 254, identifier:dialect; 255, string:'fmt'; 256, string:'gtf'; 257, block; 257, 258; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 261; 260, identifier:part; 261, call; 261, 262; 261, 267; 262, attribute; 262, 263; 262, 266; 263, subscript; 263, 264; 263, 265; 264, identifier:dialect; 265, string:'keyval separator'; 266, identifier:join; 267, argument_list; 267, 268; 268, list:[key, '""']; 268, 269; 268, 270; 269, identifier:key; 270, string:'""'; 271, else_clause; 271, 272; 272, block; 272, 273; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:part; 276, identifier:key; 277, expression_statement; 277, 278; 278, call; 278, 279; 278, 282; 279, attribute; 279, 280; 279, 281; 280, identifier:parts; 281, identifier:append; 282, argument_list; 282, 283; 283, identifier:part; 284, expression_statement; 284, 285; 285, assignment; 285, 286; 285, 287; 286, identifier:parts_str; 287, call; 287, 288; 287, 293; 288, attribute; 288, 289; 288, 292; 289, subscript; 289, 290; 289, 291; 290, identifier:dialect; 291, string:'field separator'; 292, identifier:join; 293, argument_list; 293, 294; 294, identifier:parts; 295, if_statement; 295, 296; 295, 299; 296, subscript; 296, 297; 296, 298; 297, identifier:dialect; 298, string:'trailing semicolon'; 299, block; 299, 300; 300, expression_statement; 300, 301; 301, augmented_assignment:+=; 301, 302; 301, 303; 302, identifier:parts_str; 303, string:';'; 304, return_statement; 304, 305; 305, identifier:parts_str | def _reconstruct(keyvals, dialect, keep_order=False,
sort_attribute_values=False):
if not dialect:
raise AttributeStringError()
if not keyvals:
return ""
parts = []
if constants.ignore_url_escape_characters or dialect['fmt'] != 'gff3':
attributes = keyvals
else:
attributes = {}
for k, v in keyvals.items():
attributes[k] = []
for i in v:
attributes[k].append(''.join([quoter[j] for j in i]))
if dialect['repeated keys']:
items = []
for key, val in attributes.items():
if len(val) > 1:
for v in val:
items.append((key, [v]))
else:
items.append((key, val))
else:
items = list(attributes.items())
def sort_key(x):
try:
return dialect['order'].index(x[0])
except ValueError:
return 1e6
if keep_order:
items.sort(key=sort_key)
for key, val in items:
if val:
if sort_attribute_values:
val = sorted(val)
val_str = dialect['multival separator'].join(val)
if val_str:
if dialect['quoted GFF2 values']:
val_str = '"%s"' % val_str
part = dialect['keyval separator'].join([key, val_str])
else:
if dialect['fmt'] == 'gtf':
part = dialect['keyval separator'].join([key, '""'])
else:
part = key
parts.append(part)
parts_str = dialect['field separator'].join(parts)
if dialect['trailing semicolon']:
parts_str += ';'
return parts_str |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 78; 2, function_name:create_db; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 3, 27; 3, 30; 3, 33; 3, 36; 3, 39; 3, 42; 3, 45; 3, 50; 3, 53; 3, 58; 3, 61; 3, 64; 3, 67; 3, 70; 3, 73; 3, 76; 4, identifier:data; 5, identifier:dbfn; 6, default_parameter; 6, 7; 6, 8; 7, identifier:id_spec; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:force; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:verbose; 14, False; 15, default_parameter; 15, 16; 15, 17; 16, identifier:checklines; 17, integer:10; 18, default_parameter; 18, 19; 18, 20; 19, identifier:merge_strategy; 20, string:'error'; 21, default_parameter; 21, 22; 21, 23; 22, identifier:transform; 23, None; 24, default_parameter; 24, 25; 24, 26; 25, identifier:gtf_transcript_key; 26, string:'transcript_id'; 27, default_parameter; 27, 28; 27, 29; 28, identifier:gtf_gene_key; 29, string:'gene_id'; 30, default_parameter; 30, 31; 30, 32; 31, identifier:gtf_subfeature; 32, string:'exon'; 33, default_parameter; 33, 34; 33, 35; 34, identifier:force_gff; 35, False; 36, default_parameter; 36, 37; 36, 38; 37, identifier:force_dialect_check; 38, False; 39, default_parameter; 39, 40; 39, 41; 40, identifier:from_string; 41, False; 42, default_parameter; 42, 43; 42, 44; 43, identifier:keep_order; 44, False; 45, default_parameter; 45, 46; 45, 47; 46, identifier:text_factory; 47, attribute; 47, 48; 47, 49; 48, identifier:sqlite3; 49, identifier:OptimizedUnicode; 50, default_parameter; 50, 51; 50, 52; 51, identifier:force_merge_fields; 52, None; 53, default_parameter; 53, 54; 53, 55; 54, identifier:pragmas; 55, attribute; 55, 56; 55, 57; 56, identifier:constants; 57, identifier:default_pragmas; 58, default_parameter; 58, 59; 58, 60; 59, identifier:sort_attribute_values; 60, False; 61, default_parameter; 61, 62; 61, 63; 62, identifier:dialect; 63, None; 64, default_parameter; 64, 65; 64, 66; 65, identifier:_keep_tempfiles; 66, False; 67, default_parameter; 67, 68; 67, 69; 68, identifier:infer_gene_extent; 69, True; 70, default_parameter; 70, 71; 70, 72; 71, identifier:disable_infer_genes; 72, False; 73, default_parameter; 73, 74; 73, 75; 74, identifier:disable_infer_transcripts; 75, False; 76, dictionary_splat_pattern; 76, 77; 77, identifier:kwargs; 78, block; 78, 79; 78, 85; 78, 90; 78, 106; 78, 116; 78, 124; 78, 135; 78, 143; 78, 151; 78, 157; 78, 227; 78, 235; 78, 241; 78, 249; 78, 255; 78, 306; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:_locals; 82, call; 82, 83; 82, 84; 83, identifier:locals; 84, argument_list; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:deprecation_handler; 88, argument_list; 88, 89; 89, identifier:kwargs; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:kwargs; 93, call; 93, 94; 93, 95; 94, identifier:dict; 95, generator_expression; 95, 96; 95, 101; 96, tuple; 96, 97; 96, 98; 97, identifier:i; 98, subscript; 98, 99; 98, 100; 99, identifier:_locals; 100, identifier:i; 101, for_in_clause; 101, 102; 101, 103; 102, identifier:i; 103, attribute; 103, 104; 103, 105; 104, identifier:constants; 105, identifier:_iterator_kwargs; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:iterator; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:iterators; 112, identifier:DataIterator; 113, argument_list; 113, 114; 114, dictionary_splat; 114, 115; 115, identifier:kwargs; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:kwargs; 120, identifier:update; 121, argument_list; 121, 122; 122, dictionary_splat; 122, 123; 123, identifier:_locals; 124, if_statement; 124, 125; 124, 128; 125, comparison_operator:is; 125, 126; 125, 127; 126, identifier:dialect; 127, None; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:dialect; 132, attribute; 132, 133; 132, 134; 133, identifier:iterator; 134, identifier:dialect; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 140; 137, subscript; 137, 138; 137, 139; 138, identifier:kwargs; 139, string:'data'; 140, attribute; 140, 141; 140, 142; 141, identifier:iterator; 142, identifier:_iter; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:kwargs; 147, string:'directives'; 148, attribute; 148, 149; 148, 150; 149, identifier:iterator; 150, identifier:directives; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 156; 153, subscript; 153, 154; 153, 155; 154, identifier:kwargs; 155, string:'checklines'; 156, integer:0; 157, if_statement; 157, 158; 157, 166; 157, 186; 158, boolean_operator:or; 158, 159; 158, 160; 159, identifier:force_gff; 160, parenthesized_expression; 160, 161; 161, comparison_operator:==; 161, 162; 161, 165; 162, subscript; 162, 163; 162, 164; 163, identifier:dialect; 164, string:'fmt'; 165, string:'gff3'; 166, block; 166, 167; 166, 171; 166, 177; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:cls; 170, identifier:_GFFDBCreator; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:id_spec; 174, boolean_operator:or; 174, 175; 174, 176; 175, identifier:id_spec; 176, string:'ID'; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:add_kwargs; 180, call; 180, 181; 180, 182; 181, identifier:dict; 182, argument_list; 182, 183; 183, keyword_argument; 183, 184; 183, 185; 184, identifier:id_spec; 185, identifier:id_spec; 186, elif_clause; 186, 187; 186, 192; 187, comparison_operator:==; 187, 188; 187, 191; 188, subscript; 188, 189; 188, 190; 189, identifier:dialect; 190, string:'fmt'; 191, string:'gtf'; 192, block; 192, 193; 192, 197; 192, 209; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:cls; 196, identifier:_GTFDBCreator; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 200; 199, identifier:id_spec; 200, boolean_operator:or; 200, 201; 200, 202; 201, identifier:id_spec; 202, dictionary; 202, 203; 202, 206; 203, pair; 203, 204; 203, 205; 204, string:'gene'; 205, string:'gene_id'; 206, pair; 206, 207; 206, 208; 207, string:'transcript'; 208, string:'transcript_id'; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:add_kwargs; 212, call; 212, 213; 212, 214; 213, identifier:dict; 214, argument_list; 214, 215; 214, 218; 214, 221; 214, 224; 215, keyword_argument; 215, 216; 215, 217; 216, identifier:transcript_key; 217, identifier:gtf_transcript_key; 218, keyword_argument; 218, 219; 218, 220; 219, identifier:gene_key; 220, identifier:gtf_gene_key; 221, keyword_argument; 221, 222; 221, 223; 222, identifier:subfeature; 223, identifier:gtf_subfeature; 224, keyword_argument; 224, 225; 224, 226; 225, identifier:id_spec; 226, identifier:id_spec; 227, expression_statement; 227, 228; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:kwargs; 231, identifier:update; 232, argument_list; 232, 233; 233, dictionary_splat; 233, 234; 234, identifier:add_kwargs; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 240; 237, subscript; 237, 238; 237, 239; 238, identifier:kwargs; 239, string:'dialect'; 240, identifier:dialect; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:c; 244, call; 244, 245; 244, 246; 245, identifier:cls; 246, argument_list; 246, 247; 247, dictionary_splat; 247, 248; 248, identifier:kwargs; 249, expression_statement; 249, 250; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:c; 253, identifier:create; 254, argument_list; 255, if_statement; 255, 256; 255, 259; 255, 283; 256, comparison_operator:==; 256, 257; 256, 258; 257, identifier:dbfn; 258, string:':memory:'; 259, block; 259, 260; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 263; 262, identifier:db; 263, call; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:interface; 266, identifier:FeatureDB; 267, argument_list; 267, 268; 267, 271; 267, 274; 267, 277; 267, 280; 268, attribute; 268, 269; 268, 270; 269, identifier:c; 270, identifier:conn; 271, keyword_argument; 271, 272; 271, 273; 272, identifier:keep_order; 273, identifier:keep_order; 274, keyword_argument; 274, 275; 274, 276; 275, identifier:pragmas; 276, identifier:pragmas; 277, keyword_argument; 277, 278; 277, 279; 278, identifier:sort_attribute_values; 279, identifier:sort_attribute_values; 280, keyword_argument; 280, 281; 280, 282; 281, identifier:text_factory; 282, identifier:text_factory; 283, else_clause; 283, 284; 284, block; 284, 285; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:db; 288, call; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:interface; 291, identifier:FeatureDB; 292, argument_list; 292, 293; 292, 294; 292, 297; 292, 300; 292, 303; 293, identifier:c; 294, keyword_argument; 294, 295; 294, 296; 295, identifier:keep_order; 296, identifier:keep_order; 297, keyword_argument; 297, 298; 297, 299; 298, identifier:pragmas; 299, identifier:pragmas; 300, keyword_argument; 300, 301; 300, 302; 301, identifier:sort_attribute_values; 302, identifier:sort_attribute_values; 303, keyword_argument; 303, 304; 303, 305; 304, identifier:text_factory; 305, identifier:text_factory; 306, return_statement; 306, 307; 307, identifier:db | def create_db(data, dbfn, id_spec=None, force=False, verbose=False,
checklines=10, merge_strategy='error', transform=None,
gtf_transcript_key='transcript_id', gtf_gene_key='gene_id',
gtf_subfeature='exon', force_gff=False,
force_dialect_check=False, from_string=False, keep_order=False,
text_factory=sqlite3.OptimizedUnicode, force_merge_fields=None,
pragmas=constants.default_pragmas, sort_attribute_values=False,
dialect=None, _keep_tempfiles=False, infer_gene_extent=True,
disable_infer_genes=False, disable_infer_transcripts=False,
**kwargs):
_locals = locals()
deprecation_handler(kwargs)
kwargs = dict((i, _locals[i]) for i in constants._iterator_kwargs)
iterator = iterators.DataIterator(**kwargs)
kwargs.update(**_locals)
if dialect is None:
dialect = iterator.dialect
kwargs['data'] = iterator._iter
kwargs['directives'] = iterator.directives
kwargs['checklines'] = 0
if force_gff or (dialect['fmt'] == 'gff3'):
cls = _GFFDBCreator
id_spec = id_spec or 'ID'
add_kwargs = dict(
id_spec=id_spec,
)
elif dialect['fmt'] == 'gtf':
cls = _GTFDBCreator
id_spec = id_spec or {'gene': 'gene_id', 'transcript': 'transcript_id'}
add_kwargs = dict(
transcript_key=gtf_transcript_key,
gene_key=gtf_gene_key,
subfeature=gtf_subfeature,
id_spec=id_spec,
)
kwargs.update(**add_kwargs)
kwargs['dialect'] = dialect
c = cls(**kwargs)
c.create()
if dbfn == ':memory:':
db = interface.FeatureDB(c.conn,
keep_order=keep_order,
pragmas=pragmas,
sort_attribute_values=sort_attribute_values,
text_factory=text_factory)
else:
db = interface.FeatureDB(c,
keep_order=keep_order,
pragmas=pragmas,
sort_attribute_values=sort_attribute_values,
text_factory=text_factory)
return db |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_id_handler; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:f; 6, block; 6, 7; 6, 96; 6, 194; 7, if_statement; 7, 8; 7, 17; 7, 25; 7, 41; 7, 88; 8, call; 8, 9; 8, 10; 9, identifier:isinstance; 10, argument_list; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:id_spec; 14, attribute; 14, 15; 14, 16; 15, identifier:six; 16, identifier:string_types; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:id_key; 21, list:[self.id_spec]; 21, 22; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:id_spec; 25, elif_clause; 25, 26; 25, 33; 26, call; 26, 27; 26, 28; 27, identifier:hasattr; 28, argument_list; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:id_spec; 32, string:'__call__'; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:id_key; 37, list:[self.id_spec]; 37, 38; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:id_spec; 41, elif_clause; 41, 42; 41, 49; 42, call; 42, 43; 42, 44; 43, identifier:isinstance; 44, argument_list; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:id_spec; 48, identifier:dict; 49, block; 49, 50; 50, try_statement; 50, 51; 50, 76; 51, block; 51, 52; 51, 62; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:id_key; 55, subscript; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:id_spec; 59, attribute; 59, 60; 59, 61; 60, identifier:f; 61, identifier:featuretype; 62, if_statement; 62, 63; 62, 70; 63, call; 63, 64; 63, 65; 64, identifier:isinstance; 65, argument_list; 65, 66; 65, 67; 66, identifier:id_key; 67, attribute; 67, 68; 67, 69; 68, identifier:six; 69, identifier:string_types; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:id_key; 74, list:[id_key]; 74, 75; 75, identifier:id_key; 76, except_clause; 76, 77; 76, 78; 77, identifier:KeyError; 78, block; 78, 79; 79, return_statement; 79, 80; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:_increment_featuretype_autoid; 84, argument_list; 84, 85; 85, attribute; 85, 86; 85, 87; 86, identifier:f; 87, identifier:featuretype; 88, else_clause; 88, 89; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:id_key; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:id_spec; 96, for_statement; 96, 97; 96, 98; 96, 99; 97, identifier:k; 98, identifier:id_key; 99, block; 99, 100; 100, if_statement; 100, 101; 100, 106; 100, 138; 101, call; 101, 102; 101, 103; 102, identifier:hasattr; 103, argument_list; 103, 104; 103, 105; 104, identifier:k; 105, string:'__call__'; 106, block; 106, 107; 106, 114; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:_id; 110, call; 110, 111; 110, 112; 111, identifier:k; 112, argument_list; 112, 113; 113, identifier:f; 114, if_statement; 114, 115; 114, 116; 115, identifier:_id; 116, block; 116, 117; 116, 136; 117, if_statement; 117, 118; 117, 124; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:_id; 121, identifier:startswith; 122, argument_list; 122, 123; 123, string:'autoincrement:'; 124, block; 124, 125; 125, return_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:_increment_featuretype_autoid; 130, argument_list; 130, 131; 131, subscript; 131, 132; 131, 133; 132, identifier:_id; 133, slice; 133, 134; 133, 135; 134, integer:14; 135, colon; 136, return_statement; 136, 137; 137, identifier:_id; 138, else_clause; 138, 139; 139, block; 139, 140; 140, if_statement; 140, 141; 140, 163; 140, 176; 141, boolean_operator:and; 141, 142; 141, 156; 142, boolean_operator:and; 142, 143; 142, 150; 143, parenthesized_expression; 143, 144; 144, comparison_operator:>; 144, 145; 144, 149; 145, call; 145, 146; 145, 147; 146, identifier:len; 147, argument_list; 147, 148; 148, identifier:k; 149, integer:3; 150, parenthesized_expression; 150, 151; 151, comparison_operator:==; 151, 152; 151, 155; 152, subscript; 152, 153; 152, 154; 153, identifier:k; 154, integer:0; 155, string:':'; 156, parenthesized_expression; 156, 157; 157, comparison_operator:==; 157, 158; 157, 162; 158, subscript; 158, 159; 158, 160; 159, identifier:k; 160, unary_operator:-; 160, 161; 161, integer:1; 162, string:':'; 163, block; 163, 164; 164, return_statement; 164, 165; 165, call; 165, 166; 165, 167; 166, identifier:getattr; 167, argument_list; 167, 168; 167, 169; 168, identifier:f; 169, subscript; 169, 170; 169, 171; 170, identifier:k; 171, slice; 171, 172; 171, 173; 171, 174; 172, integer:1; 173, colon; 174, unary_operator:-; 174, 175; 175, integer:1; 176, else_clause; 176, 177; 177, block; 177, 178; 178, try_statement; 178, 179; 178, 188; 179, block; 179, 180; 180, return_statement; 180, 181; 181, subscript; 181, 182; 181, 187; 182, subscript; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:f; 185, identifier:attributes; 186, identifier:k; 187, integer:0; 188, except_clause; 188, 189; 188, 192; 189, tuple; 189, 190; 189, 191; 190, identifier:KeyError; 191, identifier:IndexError; 192, block; 192, 193; 193, pass_statement; 194, return_statement; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:self; 198, identifier:_increment_featuretype_autoid; 199, argument_list; 199, 200; 200, attribute; 200, 201; 200, 202; 201, identifier:f; 202, identifier:featuretype | def _id_handler(self, f):
if isinstance(self.id_spec, six.string_types):
id_key = [self.id_spec]
elif hasattr(self.id_spec, '__call__'):
id_key = [self.id_spec]
elif isinstance(self.id_spec, dict):
try:
id_key = self.id_spec[f.featuretype]
if isinstance(id_key, six.string_types):
id_key = [id_key]
except KeyError:
return self._increment_featuretype_autoid(f.featuretype)
else:
id_key = self.id_spec
for k in id_key:
if hasattr(k, '__call__'):
_id = k(f)
if _id:
if _id.startswith('autoincrement:'):
return self._increment_featuretype_autoid(_id[14:])
return _id
else:
if (len(k) > 3) and (k[0] == ':') and (k[-1] == ':'):
return getattr(f, k[1:-1])
else:
try:
return f.attributes[k][0]
except (KeyError, IndexError):
pass
return self._increment_featuretype_autoid(f.featuretype) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:browser; 3, parameters; 3, 4; 3, 7; 3, 10; 4, default_parameter; 4, 5; 4, 6; 5, identifier:tags; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:proxy; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:other_caps; 12, None; 13, block; 13, 14; 13, 26; 13, 162; 13, 180; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:browser_name; 17, call; 17, 18; 17, 23; 18, attribute; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:os; 21, identifier:environ; 22, identifier:get; 23, argument_list; 23, 24; 23, 25; 24, string:'SELENIUM_BROWSER'; 25, string:'firefox'; 26, function_definition; 26, 27; 26, 28; 26, 29; 27, function_name:browser_check_func; 28, parameters; 29, block; 29, 30; 30, try_statement; 30, 31; 30, 132; 31, block; 31, 32; 31, 78; 31, 90; 31, 122; 32, if_statement; 32, 33; 32, 37; 32, 49; 32, 66; 33, call; 33, 34; 33, 35; 34, identifier:_use_remote_browser; 35, argument_list; 35, 36; 36, identifier:SAUCE_ENV_VARS; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 44; 40, pattern_list; 40, 41; 40, 42; 40, 43; 41, identifier:browser_class; 42, identifier:browser_args; 43, identifier:browser_kwargs; 44, call; 44, 45; 44, 46; 45, identifier:_remote_browser_class; 46, argument_list; 46, 47; 46, 48; 47, identifier:SAUCE_ENV_VARS; 48, identifier:tags; 49, elif_clause; 49, 50; 49, 54; 50, call; 50, 51; 50, 52; 51, identifier:_use_remote_browser; 52, argument_list; 52, 53; 53, identifier:REMOTE_ENV_VARS; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 61; 57, pattern_list; 57, 58; 57, 59; 57, 60; 58, identifier:browser_class; 59, identifier:browser_args; 60, identifier:browser_kwargs; 61, call; 61, 62; 61, 63; 62, identifier:_remote_browser_class; 63, argument_list; 63, 64; 63, 65; 64, identifier:REMOTE_ENV_VARS; 65, identifier:tags; 66, else_clause; 66, 67; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 74; 70, pattern_list; 70, 71; 70, 72; 70, 73; 71, identifier:browser_class; 72, identifier:browser_args; 73, identifier:browser_kwargs; 74, call; 74, 75; 74, 76; 75, identifier:_local_browser_class; 76, argument_list; 76, 77; 77, identifier:browser_name; 78, if_statement; 78, 79; 78, 80; 79, identifier:proxy; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:browser_kwargs; 84, call; 84, 85; 84, 86; 85, identifier:_proxy_kwargs; 86, argument_list; 86, 87; 86, 88; 86, 89; 87, identifier:browser_name; 88, identifier:proxy; 89, identifier:browser_kwargs; 90, if_statement; 90, 91; 90, 96; 91, comparison_operator:==; 91, 92; 91, 93; 92, identifier:browser_class; 93, attribute; 93, 94; 93, 95; 94, identifier:webdriver; 95, identifier:Remote; 96, block; 96, 97; 96, 103; 96, 116; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:desired_caps; 100, boolean_operator:or; 100, 101; 100, 102; 101, identifier:other_caps; 102, dictionary; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:desired_caps; 107, identifier:update; 108, argument_list; 108, 109; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:browser_kwargs; 112, identifier:get; 113, argument_list; 113, 114; 113, 115; 114, string:'desired_capabilities'; 115, dictionary; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 121; 118, subscript; 118, 119; 118, 120; 119, identifier:browser_kwargs; 120, string:'desired_capabilities'; 121, identifier:desired_caps; 122, return_statement; 122, 123; 123, expression_list; 123, 124; 123, 125; 124, True; 125, call; 125, 126; 125, 127; 126, identifier:browser_class; 127, argument_list; 127, 128; 127, 130; 128, list_splat; 128, 129; 129, identifier:browser_args; 130, dictionary_splat; 130, 131; 131, identifier:browser_kwargs; 132, except_clause; 132, 133; 132, 141; 133, as_pattern; 133, 134; 133, 139; 134, tuple; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:socket; 137, identifier:error; 138, identifier:WebDriverException; 139, as_pattern_target; 139, 140; 140, identifier:err; 141, block; 141, 142; 141, 149; 141, 158; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:msg; 145, call; 145, 146; 145, 147; 146, identifier:str; 147, argument_list; 147, 148; 148, identifier:err; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:LOGGER; 153, identifier:debug; 154, argument_list; 154, 155; 155, binary_operator:+; 155, 156; 155, 157; 156, string:'Failed to instantiate browser: '; 157, identifier:msg; 158, return_statement; 158, 159; 159, expression_list; 159, 160; 159, 161; 160, False; 161, None; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:browser_instance; 165, call; 165, 166; 165, 179; 166, attribute; 166, 167; 166, 178; 167, call; 167, 168; 167, 169; 168, identifier:Promise; 169, argument_list; 169, 170; 169, 171; 169, 172; 169, 175; 170, identifier:browser_check_func; 171, string:"Browser is instantiated successfully."; 172, keyword_argument; 172, 173; 172, 174; 173, identifier:try_limit; 174, integer:3; 175, keyword_argument; 175, 176; 175, 177; 176, identifier:timeout; 177, integer:95; 178, identifier:fulfill; 179, argument_list; 180, return_statement; 180, 181; 181, identifier:browser_instance | def browser(tags=None, proxy=None, other_caps=None):
browser_name = os.environ.get('SELENIUM_BROWSER', 'firefox')
def browser_check_func():
try:
if _use_remote_browser(SAUCE_ENV_VARS):
browser_class, browser_args, browser_kwargs = _remote_browser_class(
SAUCE_ENV_VARS, tags)
elif _use_remote_browser(REMOTE_ENV_VARS):
browser_class, browser_args, browser_kwargs = _remote_browser_class(
REMOTE_ENV_VARS, tags)
else:
browser_class, browser_args, browser_kwargs = _local_browser_class(
browser_name)
if proxy:
browser_kwargs = _proxy_kwargs(browser_name, proxy, browser_kwargs)
if browser_class == webdriver.Remote:
desired_caps = other_caps or {}
desired_caps.update(browser_kwargs.get('desired_capabilities', {}))
browser_kwargs['desired_capabilities'] = desired_caps
return True, browser_class(*browser_args, **browser_kwargs)
except (socket.error, WebDriverException) as err:
msg = str(err)
LOGGER.debug('Failed to instantiate browser: ' + msg)
return False, None
browser_instance = Promise(
browser_check_func, "Browser is instantiated successfully.", try_limit=3, timeout=95).fulfill()
return browser_instance |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_local_browser_class; 3, parameters; 3, 4; 4, identifier:browser_name; 5, block; 5, 6; 5, 14; 5, 23; 5, 41; 6, expression_statement; 6, 7; 7, call; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:LOGGER; 10, identifier:info; 11, argument_list; 11, 12; 11, 13; 12, string:u"Using local browser: %s [Default is firefox]"; 13, identifier:browser_name; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:browser_class; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:BROWSERS; 20, identifier:get; 21, argument_list; 21, 22; 22, identifier:browser_name; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:headless; 26, comparison_operator:==; 26, 27; 26, 40; 27, call; 27, 28; 27, 39; 28, attribute; 28, 29; 28, 38; 29, call; 29, 30; 29, 35; 30, attribute; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:os; 33, identifier:environ; 34, identifier:get; 35, argument_list; 35, 36; 35, 37; 36, string:'BOKCHOY_HEADLESS'; 37, string:'false'; 38, identifier:lower; 39, argument_list; 40, string:'true'; 41, if_statement; 41, 42; 41, 45; 41, 73; 42, comparison_operator:is; 42, 43; 42, 44; 43, identifier:browser_class; 44, None; 45, block; 45, 46; 46, raise_statement; 46, 47; 47, call; 47, 48; 47, 49; 48, identifier:BrowserConfigError; 49, argument_list; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, string:u"Invalid browser name {name}. Options are: {options}"; 53, identifier:format; 54, argument_list; 54, 55; 54, 58; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:name; 57, identifier:browser_name; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:options; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, string:", "; 63, identifier:join; 64, argument_list; 64, 65; 65, call; 65, 66; 65, 67; 66, identifier:list; 67, argument_list; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:BROWSERS; 71, identifier:keys; 72, argument_list; 73, else_clause; 73, 74; 74, block; 74, 75; 74, 288; 75, if_statement; 75, 76; 75, 79; 75, 233; 75, 278; 76, comparison_operator:==; 76, 77; 76, 78; 77, identifier:browser_name; 78, string:'firefox'; 79, block; 79, 80; 79, 96; 79, 113; 79, 119; 79, 127; 79, 136; 79, 140; 79, 152; 79, 163; 79, 174; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:log_path; 83, call; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:os; 87, identifier:path; 88, identifier:join; 89, argument_list; 89, 90; 89, 95; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:os; 93, identifier:getcwd; 94, argument_list; 95, string:'geckodriver.log'; 96, if_statement; 96, 97; 96, 105; 97, call; 97, 98; 97, 103; 98, attribute; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:os; 101, identifier:path; 102, identifier:exists; 103, argument_list; 103, 104; 104, identifier:log_path; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:os; 110, identifier:remove; 111, argument_list; 111, 112; 112, identifier:log_path; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:firefox_options; 116, call; 116, 117; 116, 118; 117, identifier:FirefoxOptions; 118, argument_list; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 126; 121, attribute; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:firefox_options; 124, identifier:log; 125, identifier:level; 126, string:'trace'; 127, if_statement; 127, 128; 127, 129; 128, identifier:headless; 129, block; 129, 130; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:firefox_options; 134, identifier:headless; 135, True; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:browser_args; 139, list:[]; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:browser_kwargs; 143, dictionary; 143, 144; 143, 149; 144, pair; 144, 145; 144, 146; 145, string:'firefox_profile'; 146, call; 146, 147; 146, 148; 147, identifier:_firefox_profile; 148, argument_list; 149, pair; 149, 150; 149, 151; 150, string:'options'; 151, identifier:firefox_options; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:firefox_path; 155, call; 155, 156; 155, 161; 156, attribute; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:os; 159, identifier:environ; 160, identifier:get; 161, argument_list; 161, 162; 162, string:'SELENIUM_FIREFOX_PATH'; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:firefox_log; 166, call; 166, 167; 166, 172; 167, attribute; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:os; 170, identifier:environ; 171, identifier:get; 172, argument_list; 172, 173; 173, string:'SELENIUM_FIREFOX_LOG'; 174, if_statement; 174, 175; 174, 178; 174, 197; 174, 215; 175, boolean_operator:and; 175, 176; 175, 177; 176, identifier:firefox_path; 177, identifier:firefox_log; 178, block; 178, 179; 179, expression_statement; 179, 180; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:browser_kwargs; 183, identifier:update; 184, argument_list; 184, 185; 185, dictionary; 185, 186; 186, pair; 186, 187; 186, 188; 187, string:'firefox_binary'; 188, call; 188, 189; 188, 190; 189, identifier:FirefoxBinary; 190, argument_list; 190, 191; 190, 194; 191, keyword_argument; 191, 192; 191, 193; 192, identifier:firefox_path; 193, identifier:firefox_path; 194, keyword_argument; 194, 195; 194, 196; 195, identifier:log_file; 196, identifier:firefox_log; 197, elif_clause; 197, 198; 197, 199; 198, identifier:firefox_path; 199, block; 199, 200; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:browser_kwargs; 204, identifier:update; 205, argument_list; 205, 206; 206, dictionary; 206, 207; 207, pair; 207, 208; 207, 209; 208, string:'firefox_binary'; 209, call; 209, 210; 209, 211; 210, identifier:FirefoxBinary; 211, argument_list; 211, 212; 212, keyword_argument; 212, 213; 212, 214; 213, identifier:firefox_path; 214, identifier:firefox_path; 215, elif_clause; 215, 216; 215, 217; 216, identifier:firefox_log; 217, block; 217, 218; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:browser_kwargs; 222, identifier:update; 223, argument_list; 223, 224; 224, dictionary; 224, 225; 225, pair; 225, 226; 225, 227; 226, string:'firefox_binary'; 227, call; 227, 228; 227, 229; 228, identifier:FirefoxBinary; 229, argument_list; 229, 230; 230, keyword_argument; 230, 231; 230, 232; 231, identifier:log_file; 232, identifier:firefox_log; 233, elif_clause; 233, 234; 233, 237; 234, comparison_operator:==; 234, 235; 234, 236; 235, identifier:browser_name; 236, string:'chrome'; 237, block; 237, 238; 237, 244; 237, 253; 237, 260; 237, 267; 237, 271; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:chrome_options; 241, call; 241, 242; 241, 243; 242, identifier:ChromeOptions; 243, argument_list; 244, if_statement; 244, 245; 244, 246; 245, identifier:headless; 246, block; 246, 247; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:chrome_options; 251, identifier:headless; 252, True; 253, expression_statement; 253, 254; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:chrome_options; 257, identifier:add_argument; 258, argument_list; 258, 259; 259, string:'--use-fake-device-for-media-stream'; 260, expression_statement; 260, 261; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:chrome_options; 264, identifier:add_argument; 265, argument_list; 265, 266; 266, string:'--use-fake-ui-for-media-stream'; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:browser_args; 270, list:[]; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:browser_kwargs; 274, dictionary; 274, 275; 275, pair; 275, 276; 275, 277; 276, string:'options'; 277, identifier:chrome_options; 278, else_clause; 278, 279; 279, block; 279, 280; 280, expression_statement; 280, 281; 281, assignment; 281, 282; 281, 285; 282, pattern_list; 282, 283; 282, 284; 283, identifier:browser_args; 284, identifier:browser_kwargs; 285, expression_list; 285, 286; 285, 287; 286, list:[]; 287, dictionary; 288, return_statement; 288, 289; 289, expression_list; 289, 290; 289, 291; 289, 292; 290, identifier:browser_class; 291, identifier:browser_args; 292, identifier:browser_kwargs | def _local_browser_class(browser_name):
LOGGER.info(u"Using local browser: %s [Default is firefox]", browser_name)
browser_class = BROWSERS.get(browser_name)
headless = os.environ.get('BOKCHOY_HEADLESS', 'false').lower() == 'true'
if browser_class is None:
raise BrowserConfigError(
u"Invalid browser name {name}. Options are: {options}".format(
name=browser_name, options=", ".join(list(BROWSERS.keys()))))
else:
if browser_name == 'firefox':
log_path = os.path.join(os.getcwd(), 'geckodriver.log')
if os.path.exists(log_path):
os.remove(log_path)
firefox_options = FirefoxOptions()
firefox_options.log.level = 'trace'
if headless:
firefox_options.headless = True
browser_args = []
browser_kwargs = {
'firefox_profile': _firefox_profile(),
'options': firefox_options,
}
firefox_path = os.environ.get('SELENIUM_FIREFOX_PATH')
firefox_log = os.environ.get('SELENIUM_FIREFOX_LOG')
if firefox_path and firefox_log:
browser_kwargs.update({
'firefox_binary': FirefoxBinary(
firefox_path=firefox_path, log_file=firefox_log)
})
elif firefox_path:
browser_kwargs.update({
'firefox_binary': FirefoxBinary(firefox_path=firefox_path)
})
elif firefox_log:
browser_kwargs.update({
'firefox_binary': FirefoxBinary(log_file=firefox_log)
})
elif browser_name == 'chrome':
chrome_options = ChromeOptions()
if headless:
chrome_options.headless = True
chrome_options.add_argument('--use-fake-device-for-media-stream')
chrome_options.add_argument('--use-fake-ui-for-media-stream')
browser_args = []
browser_kwargs = {
'options': chrome_options,
}
else:
browser_args, browser_kwargs = [], {}
return browser_class, browser_args, browser_kwargs |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:filter; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:filter_fn; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:desc; 10, None; 11, dictionary_splat_pattern; 11, 12; 12, identifier:kwargs; 13, block; 13, 14; 13, 26; 13, 39; 13, 86; 13, 95; 13, 123; 14, if_statement; 14, 15; 14, 20; 15, boolean_operator:and; 15, 16; 15, 19; 16, comparison_operator:is; 16, 17; 16, 18; 17, identifier:filter_fn; 18, None; 19, identifier:kwargs; 20, block; 20, 21; 21, raise_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:TypeError; 24, argument_list; 24, 25; 25, string:'Must supply either a filter_fn or attribute filter parameters to filter(), but not both.'; 26, if_statement; 26, 27; 26, 33; 27, boolean_operator:and; 27, 28; 27, 31; 28, comparison_operator:is; 28, 29; 28, 30; 29, identifier:filter_fn; 30, None; 31, not_operator; 31, 32; 32, identifier:kwargs; 33, block; 33, 34; 34, raise_statement; 34, 35; 35, call; 35, 36; 35, 37; 36, identifier:TypeError; 37, argument_list; 37, 38; 38, string:'Must supply one of filter_fn or one or more attribute filter parameters to filter().'; 39, if_statement; 39, 40; 39, 43; 40, comparison_operator:is; 40, 41; 40, 42; 41, identifier:desc; 42, None; 43, block; 43, 44; 44, if_statement; 44, 45; 44, 48; 44, 58; 45, comparison_operator:is; 45, 46; 45, 47; 46, identifier:filter_fn; 47, None; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:desc; 52, call; 52, 53; 52, 54; 53, identifier:getattr; 54, argument_list; 54, 55; 54, 56; 54, 57; 55, identifier:filter_fn; 56, string:'__name__'; 57, string:''; 58, elif_clause; 58, 59; 58, 60; 59, identifier:kwargs; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:desc; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, string:u", "; 67, identifier:join; 68, argument_list; 68, 69; 69, list_comprehension; 69, 70; 69, 77; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, string:u"{}={!r}"; 73, identifier:format; 74, argument_list; 74, 75; 74, 76; 75, identifier:key; 76, identifier:value; 77, for_in_clause; 77, 78; 77, 81; 78, pattern_list; 78, 79; 78, 80; 79, identifier:key; 80, identifier:value; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:kwargs; 84, identifier:items; 85, argument_list; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:desc; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, string:u"filter({})"; 92, identifier:format; 93, argument_list; 93, 94; 94, identifier:desc; 95, if_statement; 95, 96; 95, 97; 96, identifier:kwargs; 97, block; 97, 98; 98, function_definition; 98, 99; 98, 100; 98, 102; 99, function_name:filter_fn; 100, parameters; 100, 101; 101, identifier:elem; 102, block; 102, 103; 103, return_statement; 103, 104; 104, call; 104, 105; 104, 106; 105, identifier:all; 106, generator_expression; 106, 107; 106, 114; 107, comparison_operator:==; 107, 108; 107, 113; 108, call; 108, 109; 108, 110; 109, identifier:getattr; 110, argument_list; 110, 111; 110, 112; 111, identifier:elem; 112, identifier:filter_key; 113, identifier:filter_value; 114, for_in_clause; 114, 115; 114, 118; 115, pattern_list; 115, 116; 115, 117; 116, identifier:filter_key; 117, identifier:filter_value; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:kwargs; 121, identifier:items; 122, argument_list; 123, return_statement; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:self; 127, identifier:transform; 128, argument_list; 128, 129; 128, 142; 129, lambda; 129, 130; 129, 132; 130, lambda_parameters; 130, 131; 131, identifier:xs; 132, generator_expression; 132, 133; 132, 134; 132, 137; 133, identifier:x; 134, for_in_clause; 134, 135; 134, 136; 135, identifier:x; 136, identifier:xs; 137, if_clause; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:filter_fn; 140, argument_list; 140, 141; 141, identifier:x; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:desc; 144, identifier:desc | def filter(self, filter_fn=None, desc=None, **kwargs):
if filter_fn is not None and kwargs:
raise TypeError('Must supply either a filter_fn or attribute filter parameters to filter(), but not both.')
if filter_fn is None and not kwargs:
raise TypeError('Must supply one of filter_fn or one or more attribute filter parameters to filter().')
if desc is None:
if filter_fn is not None:
desc = getattr(filter_fn, '__name__', '')
elif kwargs:
desc = u", ".join([u"{}={!r}".format(key, value) for key, value in kwargs.items()])
desc = u"filter({})".format(desc)
if kwargs:
def filter_fn(elem):
return all(
getattr(elem, filter_key) == filter_value
for filter_key, filter_value
in kwargs.items()
)
return self.transform(lambda xs: (x for x in xs if filter_fn(x)), desc=desc) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:order_by_on_list; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:objects; 5, identifier:order_field; 6, default_parameter; 6, 7; 6, 8; 7, identifier:is_desc; 8, False; 9, block; 9, 10; 9, 29; 9, 51; 10, if_statement; 10, 11; 10, 15; 11, call; 11, 12; 11, 13; 12, identifier:callable; 13, argument_list; 13, 14; 14, identifier:order_field; 15, block; 15, 16; 15, 28; 16, expression_statement; 16, 17; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:objects; 20, identifier:sort; 21, argument_list; 21, 22; 21, 25; 22, keyword_argument; 22, 23; 22, 24; 23, identifier:key; 24, identifier:order_field; 25, keyword_argument; 25, 26; 25, 27; 26, identifier:reverse; 27, identifier:is_desc; 28, return_statement; 29, function_definition; 29, 30; 29, 31; 29, 33; 30, function_name:order_key; 31, parameters; 31, 32; 32, identifier:x; 33, block; 33, 34; 33, 42; 33, 49; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:v; 37, call; 37, 38; 37, 39; 38, identifier:getattr_path; 39, argument_list; 39, 40; 39, 41; 40, identifier:x; 41, identifier:order_field; 42, if_statement; 42, 43; 42, 46; 43, comparison_operator:is; 43, 44; 43, 45; 44, identifier:v; 45, None; 46, block; 46, 47; 47, return_statement; 47, 48; 48, identifier:MIN; 49, return_statement; 49, 50; 50, identifier:v; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:objects; 55, identifier:sort; 56, argument_list; 56, 57; 56, 60; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:key; 59, identifier:order_key; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:reverse; 62, identifier:is_desc | def order_by_on_list(objects, order_field, is_desc=False):
if callable(order_field):
objects.sort(key=order_field, reverse=is_desc)
return
def order_key(x):
v = getattr_path(x, order_field)
if v is None:
return MIN
return v
objects.sort(key=order_key, reverse=is_desc) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 41; 2, function_name:render_table; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 3, 27; 3, 30; 3, 33; 4, identifier:request; 5, identifier:table; 6, default_parameter; 6, 7; 6, 8; 7, identifier:links; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:context; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:template; 14, string:'tri_table/list.html'; 15, default_parameter; 15, 16; 15, 17; 16, identifier:blank_on_empty; 17, False; 18, default_parameter; 18, 19; 18, 20; 19, identifier:paginate_by; 20, integer:40; 21, default_parameter; 21, 22; 21, 23; 22, identifier:page; 23, None; 24, default_parameter; 24, 25; 24, 26; 25, identifier:paginator; 26, None; 27, default_parameter; 27, 28; 27, 29; 28, identifier:show_hits; 29, False; 30, default_parameter; 30, 31; 30, 32; 31, identifier:hit_label; 32, string:'Items'; 33, default_parameter; 33, 34; 33, 35; 34, identifier:post_bulk_edit; 35, lambda; 35, 36; 35, 40; 36, lambda_parameters; 36, 37; 36, 38; 36, 39; 37, identifier:table; 38, identifier:queryset; 39, identifier:updates; 40, None; 41, block; 41, 42; 41, 50; 41, 63; 41, 70; 41, 76; 41, 90; 41, 95; 41, 103; 41, 111; 41, 119; 41, 213; 41, 246; 41, 256; 41, 287; 42, if_statement; 42, 43; 42, 45; 43, not_operator; 43, 44; 44, identifier:context; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:context; 49, dictionary; 50, if_statement; 50, 51; 50, 56; 51, call; 51, 52; 51, 53; 52, identifier:isinstance; 53, argument_list; 53, 54; 53, 55; 54, identifier:table; 55, identifier:Namespace; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:table; 60, call; 60, 61; 60, 62; 61, identifier:table; 62, argument_list; 63, assert_statement; 63, 64; 63, 69; 64, call; 64, 65; 64, 66; 65, identifier:isinstance; 66, argument_list; 66, 67; 66, 68; 67, identifier:table; 68, identifier:Table; 69, identifier:table; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:table; 74, identifier:request; 75, identifier:request; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 81; 78, pattern_list; 78, 79; 78, 80; 79, identifier:should_return; 80, identifier:dispatch_result; 81, call; 81, 82; 81, 83; 82, identifier:handle_dispatch; 83, argument_list; 83, 84; 83, 87; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:request; 86, identifier:request; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:obj; 89, identifier:table; 90, if_statement; 90, 91; 90, 92; 91, identifier:should_return; 92, block; 92, 93; 93, return_statement; 93, 94; 94, identifier:dispatch_result; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 100; 97, subscript; 97, 98; 97, 99; 98, identifier:context; 99, string:'bulk_form'; 100, attribute; 100, 101; 100, 102; 101, identifier:table; 102, identifier:bulk_form; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 108; 105, subscript; 105, 106; 105, 107; 106, identifier:context; 107, string:'query_form'; 108, attribute; 108, 109; 108, 110; 109, identifier:table; 110, identifier:query_form; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 116; 113, subscript; 113, 114; 113, 115; 114, identifier:context; 115, string:'tri_query_error'; 116, attribute; 116, 117; 116, 118; 117, identifier:table; 118, identifier:query_error; 119, if_statement; 119, 120; 119, 129; 120, boolean_operator:and; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:table; 123, identifier:bulk_form; 124, comparison_operator:==; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:request; 127, identifier:method; 128, string:'POST'; 129, block; 129, 130; 130, if_statement; 130, 131; 130, 138; 131, call; 131, 132; 131, 137; 132, attribute; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:table; 135, identifier:bulk_form; 136, identifier:is_valid; 137, argument_list; 138, block; 138, 139; 138, 147; 138, 183; 138, 191; 138, 204; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:queryset; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:table; 145, identifier:bulk_queryset; 146, argument_list; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:updates; 150, dictionary_comprehension; 150, 151; 150, 158; 150, 165; 151, pair; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:field; 154, identifier:name; 155, attribute; 155, 156; 155, 157; 156, identifier:field; 157, identifier:value; 158, for_in_clause; 158, 159; 158, 160; 159, identifier:field; 160, attribute; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:table; 163, identifier:bulk_form; 164, identifier:fields; 165, if_clause; 165, 166; 166, boolean_operator:and; 166, 167; 166, 178; 167, boolean_operator:and; 167, 168; 167, 173; 168, comparison_operator:is; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:field; 171, identifier:value; 172, None; 173, comparison_operator:!=; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:field; 176, identifier:value; 177, string:''; 178, comparison_operator:is; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:field; 181, identifier:attr; 182, None; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:queryset; 187, identifier:update; 188, argument_list; 188, 189; 189, dictionary_splat; 189, 190; 190, identifier:updates; 191, expression_statement; 191, 192; 192, call; 192, 193; 192, 194; 193, identifier:post_bulk_edit; 194, argument_list; 194, 195; 194, 198; 194, 201; 195, keyword_argument; 195, 196; 195, 197; 196, identifier:table; 197, identifier:table; 198, keyword_argument; 198, 199; 198, 200; 199, identifier:queryset; 200, identifier:queryset; 201, keyword_argument; 201, 202; 201, 203; 202, identifier:updates; 203, identifier:updates; 204, return_statement; 204, 205; 205, call; 205, 206; 205, 207; 206, identifier:HttpResponseRedirect; 207, argument_list; 207, 208; 208, subscript; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:request; 211, identifier:META; 212, string:'HTTP_REFERER'; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:table; 217, identifier:context; 218, call; 218, 219; 218, 220; 219, identifier:table_context; 220, argument_list; 220, 221; 220, 222; 220, 225; 220, 228; 220, 231; 220, 234; 220, 237; 220, 240; 220, 243; 221, identifier:request; 222, keyword_argument; 222, 223; 222, 224; 223, identifier:table; 224, identifier:table; 225, keyword_argument; 225, 226; 225, 227; 226, identifier:links; 227, identifier:links; 228, keyword_argument; 228, 229; 228, 230; 229, identifier:paginate_by; 230, identifier:paginate_by; 231, keyword_argument; 231, 232; 231, 233; 232, identifier:page; 233, identifier:page; 234, keyword_argument; 234, 235; 234, 236; 235, identifier:extra_context; 236, identifier:context; 237, keyword_argument; 237, 238; 237, 239; 238, identifier:paginator; 239, identifier:paginator; 240, keyword_argument; 240, 241; 240, 242; 241, identifier:show_hits; 242, identifier:show_hits; 243, keyword_argument; 243, 244; 243, 245; 244, identifier:hit_label; 245, identifier:hit_label; 246, if_statement; 246, 247; 246, 253; 247, boolean_operator:and; 247, 248; 247, 252; 248, not_operator; 248, 249; 249, attribute; 249, 250; 249, 251; 250, identifier:table; 251, identifier:data; 252, identifier:blank_on_empty; 253, block; 253, 254; 254, return_statement; 254, 255; 255, string:''; 256, if_statement; 256, 257; 256, 269; 257, boolean_operator:and; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:table; 260, identifier:query_form; 261, not_operator; 261, 262; 262, call; 262, 263; 262, 268; 263, attribute; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:table; 266, identifier:query_form; 267, identifier:is_valid; 268, argument_list; 269, block; 269, 270; 269, 276; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:table; 274, identifier:data; 275, None; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 283; 278, subscript; 278, 279; 278, 282; 279, attribute; 279, 280; 279, 281; 280, identifier:table; 281, identifier:context; 282, string:'invalid_form_message'; 283, call; 283, 284; 283, 285; 284, identifier:mark_safe; 285, argument_list; 285, 286; 286, string:'<i class="fa fa-meh-o fa-5x" aria-hidden="true"></i>'; 287, return_statement; 287, 288; 288, call; 288, 289; 288, 290; 289, identifier:render_template; 290, argument_list; 290, 291; 290, 292; 290, 293; 291, identifier:request; 292, identifier:template; 293, attribute; 293, 294; 293, 295; 294, identifier:table; 295, identifier:context | def render_table(request,
table,
links=None,
context=None,
template='tri_table/list.html',
blank_on_empty=False,
paginate_by=40,
page=None,
paginator=None,
show_hits=False,
hit_label='Items',
post_bulk_edit=lambda table, queryset, updates: None):
if not context:
context = {}
if isinstance(table, Namespace):
table = table()
assert isinstance(table, Table), table
table.request = request
should_return, dispatch_result = handle_dispatch(request=request, obj=table)
if should_return:
return dispatch_result
context['bulk_form'] = table.bulk_form
context['query_form'] = table.query_form
context['tri_query_error'] = table.query_error
if table.bulk_form and request.method == 'POST':
if table.bulk_form.is_valid():
queryset = table.bulk_queryset()
updates = {
field.name: field.value
for field in table.bulk_form.fields
if field.value is not None and field.value != '' and field.attr is not None
}
queryset.update(**updates)
post_bulk_edit(table=table, queryset=queryset, updates=updates)
return HttpResponseRedirect(request.META['HTTP_REFERER'])
table.context = table_context(
request,
table=table,
links=links,
paginate_by=paginate_by,
page=page,
extra_context=context,
paginator=paginator,
show_hits=show_hits,
hit_label=hit_label,
)
if not table.data and blank_on_empty:
return ''
if table.query_form and not table.query_form.is_valid():
table.data = None
table.context['invalid_form_message'] = mark_safe('<i class="fa fa-meh-o fa-5x" aria-hidden="true"></i>')
return render_template(request, template, table.context) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 22; 2, function_name:create_network; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 4, identifier:self; 5, identifier:net_view_name; 6, identifier:cidr; 7, default_parameter; 7, 8; 7, 9; 8, identifier:nameservers; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:members; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:gateway_ip; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:dhcp_trel_ip; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:network_extattrs; 21, None; 22, block; 22, 23; 22, 34; 22, 38; 22, 63; 22, 85; 22, 110; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:ipv4; 26, comparison_operator:==; 26, 27; 26, 33; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:ib_utils; 30, identifier:determine_ip_version; 31, argument_list; 31, 32; 32, identifier:cidr; 33, integer:4; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:options; 37, list:[]; 38, if_statement; 38, 39; 38, 40; 39, identifier:nameservers; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:options; 45, identifier:append; 46, argument_list; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:obj; 50, identifier:DhcpOption; 51, argument_list; 51, 52; 51, 55; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:name; 54, string:'domain-name-servers'; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:value; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, string:","; 60, identifier:join; 61, argument_list; 61, 62; 62, identifier:nameservers; 63, if_statement; 63, 64; 63, 67; 64, boolean_operator:and; 64, 65; 64, 66; 65, identifier:ipv4; 66, identifier:gateway_ip; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:options; 72, identifier:append; 73, argument_list; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:obj; 77, identifier:DhcpOption; 78, argument_list; 78, 79; 78, 82; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:name; 81, string:'routers'; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:value; 84, identifier:gateway_ip; 85, if_statement; 85, 86; 85, 89; 86, boolean_operator:and; 86, 87; 86, 88; 87, identifier:ipv4; 88, identifier:dhcp_trel_ip; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:options; 94, identifier:append; 95, argument_list; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:obj; 99, identifier:DhcpOption; 100, argument_list; 100, 101; 100, 104; 100, 107; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:name; 103, string:'dhcp-server-identifier'; 104, keyword_argument; 104, 105; 104, 106; 105, identifier:num; 106, integer:54; 107, keyword_argument; 107, 108; 107, 109; 108, identifier:value; 109, identifier:dhcp_trel_ip; 110, return_statement; 110, 111; 111, call; 111, 112; 111, 117; 112, attribute; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:obj; 115, identifier:Network; 116, identifier:create; 117, argument_list; 117, 118; 117, 121; 117, 124; 117, 127; 117, 130; 117, 133; 117, 136; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:connector; 121, keyword_argument; 121, 122; 121, 123; 122, identifier:network_view; 123, identifier:net_view_name; 124, keyword_argument; 124, 125; 124, 126; 125, identifier:cidr; 126, identifier:cidr; 127, keyword_argument; 127, 128; 127, 129; 128, identifier:members; 129, identifier:members; 130, keyword_argument; 130, 131; 130, 132; 131, identifier:options; 132, identifier:options; 133, keyword_argument; 133, 134; 133, 135; 134, identifier:extattrs; 135, identifier:network_extattrs; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:check_if_exists; 138, False | def create_network(self, net_view_name, cidr, nameservers=None,
members=None, gateway_ip=None, dhcp_trel_ip=None,
network_extattrs=None):
ipv4 = ib_utils.determine_ip_version(cidr) == 4
options = []
if nameservers:
options.append(obj.DhcpOption(name='domain-name-servers',
value=",".join(nameservers)))
if ipv4 and gateway_ip:
options.append(obj.DhcpOption(name='routers',
value=gateway_ip))
if ipv4 and dhcp_trel_ip:
options.append(obj.DhcpOption(name='dhcp-server-identifier',
num=54,
value=dhcp_trel_ip))
return obj.Network.create(self.connector,
network_view=net_view_name,
cidr=cidr,
members=members,
options=options,
extattrs=network_extattrs,
check_if_exists=False) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_run_pass; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 173; 6, while_statement; 6, 7; 6, 8; 7, True; 8, block; 8, 9; 8, 43; 8, 52; 8, 101; 8, 111; 8, 142; 8, 152; 9, try_statement; 9, 10; 9, 22; 10, block; 10, 11; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:data; 14, call; 14, 15; 14, 20; 15, attribute; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:_file; 19, identifier:read; 20, argument_list; 20, 21; 21, integer:4096; 22, except_clause; 22, 23; 22, 24; 22, 25; 23, identifier:IOError; 24, identifier:e; 25, block; 25, 26; 26, if_statement; 26, 27; 26, 34; 27, comparison_operator:==; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:e; 30, identifier:errno; 31, attribute; 31, 32; 31, 33; 32, identifier:errno; 33, identifier:ESTALE; 34, block; 34, 35; 34, 41; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:active; 40, False; 41, return_statement; 41, 42; 42, False; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:lines; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:_buffer_extract; 50, argument_list; 50, 51; 51, identifier:data; 52, if_statement; 52, 53; 52, 55; 53, not_operator; 53, 54; 54, identifier:lines; 55, block; 55, 56; 55, 100; 56, if_statement; 56, 57; 56, 72; 57, boolean_operator:and; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:_current_event; 61, comparison_operator:>; 61, 62; 61, 71; 62, binary_operator:-; 62, 63; 62, 68; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:time; 66, identifier:time; 67, argument_list; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:_last_activity; 71, integer:1; 72, block; 72, 73; 72, 84; 72, 92; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:event; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, string:'\n'; 79, identifier:join; 80, argument_list; 80, 81; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:_current_event; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 91; 86, attribute; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:_current_event; 90, identifier:clear; 91, argument_list; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:_callback_wrapper; 97, argument_list; 97, 98; 98, list:[event]; 98, 99; 99, identifier:event; 100, break_statement; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:_last_activity; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:time; 109, identifier:time; 110, argument_list; 111, if_statement; 111, 112; 111, 119; 111, 136; 112, boolean_operator:or; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:_multiline_regex_after; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:_multiline_regex_before; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:events; 123, call; 123, 124; 123, 125; 124, identifier:multiline_merge; 125, argument_list; 125, 126; 125, 127; 125, 130; 125, 133; 126, identifier:lines; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:_current_event; 130, attribute; 130, 131; 130, 132; 131, identifier:self; 132, identifier:_multiline_regex_after; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:_multiline_regex_before; 136, else_clause; 136, 137; 137, block; 137, 138; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:events; 141, identifier:lines; 142, if_statement; 142, 143; 142, 144; 143, identifier:events; 144, block; 144, 145; 145, expression_statement; 145, 146; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:_callback_wrapper; 150, argument_list; 150, 151; 151, identifier:events; 152, if_statement; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:_sincedb_path; 156, block; 156, 157; 156, 164; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:current_line_count; 160, call; 160, 161; 160, 162; 161, identifier:len; 162, argument_list; 162, 163; 163, identifier:lines; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:_sincedb_update_position; 169, argument_list; 169, 170; 170, keyword_argument; 170, 171; 170, 172; 171, identifier:lines; 172, identifier:current_line_count; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:_sincedb_update_position; 178, argument_list | def _run_pass(self):
while True:
try:
data = self._file.read(4096)
except IOError, e:
if e.errno == errno.ESTALE:
self.active = False
return False
lines = self._buffer_extract(data)
if not lines:
if self._current_event and time.time() - self._last_activity > 1:
event = '\n'.join(self._current_event)
self._current_event.clear()
self._callback_wrapper([event])
break
self._last_activity = time.time()
if self._multiline_regex_after or self._multiline_regex_before:
events = multiline_merge(
lines,
self._current_event,
self._multiline_regex_after,
self._multiline_regex_before)
else:
events = lines
if events:
self._callback_wrapper(events)
if self._sincedb_path:
current_line_count = len(lines)
self._sincedb_update_position(lines=current_line_count)
self._sincedb_update_position() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:update_files; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 29; 5, 42; 5, 46; 5, 50; 5, 171; 5, 236; 5, 252; 6, if_statement; 6, 7; 6, 27; 7, boolean_operator:and; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:_update_time; 11, comparison_operator:<; 11, 12; 11, 24; 12, binary_operator:-; 12, 13; 12, 21; 13, call; 13, 14; 13, 15; 14, identifier:int; 15, argument_list; 15, 16; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:time; 19, identifier:time; 20, argument_list; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_update_time; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_discover_interval; 27, block; 27, 28; 28, return_statement; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:_update_time; 34, call; 34, 35; 34, 36; 35, identifier:int; 36, argument_list; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:time; 40, identifier:time; 41, argument_list; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:possible_files; 45, list:[]; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:files; 49, list:[]; 50, if_statement; 50, 51; 50, 64; 50, 133; 51, comparison_operator:>; 51, 52; 51, 63; 52, call; 52, 53; 52, 54; 53, identifier:len; 54, argument_list; 54, 55; 55, call; 55, 56; 55, 61; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:_beaver_config; 60, identifier:get; 61, argument_list; 61, 62; 62, string:'globs'; 63, integer:0; 64, block; 64, 65; 64, 71; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:extend_files; 68, attribute; 68, 69; 68, 70; 69, identifier:files; 70, identifier:extend; 71, for_statement; 71, 72; 71, 75; 71, 87; 72, pattern_list; 72, 73; 72, 74; 73, identifier:name; 74, identifier:exclude; 75, call; 75, 76; 75, 86; 76, attribute; 76, 77; 76, 85; 77, call; 77, 78; 77, 83; 78, attribute; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:_beaver_config; 82, identifier:get; 83, argument_list; 83, 84; 84, string:'globs'; 85, identifier:items; 86, argument_list; 87, block; 87, 88; 87, 107; 87, 112; 87, 122; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:globbed; 91, list_comprehension; 91, 92; 91, 100; 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:realpath; 98, argument_list; 98, 99; 99, identifier:filename; 100, for_in_clause; 100, 101; 100, 102; 101, identifier:filename; 102, call; 102, 103; 102, 104; 103, identifier:eglob; 104, argument_list; 104, 105; 104, 106; 105, identifier:name; 106, identifier:exclude; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 110; 109, identifier:extend_files; 110, argument_list; 110, 111; 111, identifier:globbed; 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:_beaver_config; 118, identifier:addglob; 119, argument_list; 119, 120; 119, 121; 120, identifier:name; 121, identifier:globbed; 122, expression_statement; 122, 123; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:_callback; 127, argument_list; 127, 128; 128, tuple; 128, 129; 128, 130; 129, string:"addglob"; 130, tuple; 130, 131; 130, 132; 131, identifier:name; 132, identifier:globbed; 133, else_clause; 133, 134; 134, block; 134, 135; 134, 141; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:append_files; 138, attribute; 138, 139; 138, 140; 139, identifier:files; 140, identifier:append; 141, for_statement; 141, 142; 141, 143; 141, 148; 142, identifier:name; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:listdir; 147, argument_list; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 152; 151, identifier:append_files; 152, argument_list; 152, 153; 153, call; 153, 154; 153, 159; 154, attribute; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:os; 157, identifier:path; 158, identifier:realpath; 159, argument_list; 159, 160; 160, call; 160, 161; 160, 166; 161, attribute; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:os; 164, identifier:path; 165, identifier:join; 166, argument_list; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:self; 169, identifier:_folder; 170, identifier:name; 171, for_statement; 171, 172; 171, 173; 171, 174; 172, identifier:absname; 173, identifier:files; 174, block; 174, 175; 175, try_statement; 175, 176; 175, 186; 175, 200; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:st; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:os; 183, identifier:stat; 184, argument_list; 184, 185; 185, identifier:absname; 186, except_clause; 186, 187; 186, 188; 186, 189; 187, identifier:EnvironmentError; 188, identifier:err; 189, block; 189, 190; 190, if_statement; 190, 191; 190, 198; 191, comparison_operator:!=; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:err; 194, identifier:errno; 195, attribute; 195, 196; 195, 197; 196, identifier:errno; 197, identifier:ENOENT; 198, block; 198, 199; 199, raise_statement; 200, else_clause; 200, 201; 201, block; 201, 202; 201, 214; 201, 220; 201, 229; 202, if_statement; 202, 203; 202, 212; 203, not_operator; 203, 204; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:stat; 207, identifier:S_ISREG; 208, argument_list; 208, 209; 209, attribute; 209, 210; 209, 211; 210, identifier:st; 211, identifier:st_mode; 212, block; 212, 213; 213, continue_statement; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:append_possible_files; 217, attribute; 217, 218; 217, 219; 218, identifier:possible_files; 219, identifier:append; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:fid; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:self; 226, identifier:get_file_id; 227, argument_list; 227, 228; 228, identifier:st; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 232; 231, identifier:append_possible_files; 232, argument_list; 232, 233; 233, tuple; 233, 234; 233, 235; 234, identifier:fid; 235, identifier:absname; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:new_files; 239, list_comprehension; 239, 240; 239, 241; 239, 246; 240, identifier:fname; 241, for_in_clause; 241, 242; 241, 245; 242, pattern_list; 242, 243; 242, 244; 243, identifier:fid; 244, identifier:fname; 245, identifier:possible_files; 246, if_clause; 246, 247; 247, comparison_operator:not; 247, 248; 247, 249; 248, identifier:fid; 249, attribute; 249, 250; 249, 251; 250, identifier:self; 251, identifier:_tails; 252, expression_statement; 252, 253; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:self; 256, identifier:watch; 257, argument_list; 257, 258; 258, identifier:new_files | def update_files(self):
if self._update_time and int(time.time()) - self._update_time < self._discover_interval:
return
self._update_time = int(time.time())
possible_files = []
files = []
if len(self._beaver_config.get('globs')) > 0:
extend_files = files.extend
for name, exclude in self._beaver_config.get('globs').items():
globbed = [os.path.realpath(filename) for filename in eglob(name, exclude)]
extend_files(globbed)
self._beaver_config.addglob(name, globbed)
self._callback(("addglob", (name, globbed)))
else:
append_files = files.append
for name in self.listdir():
append_files(os.path.realpath(os.path.join(self._folder, name)))
for absname in files:
try:
st = os.stat(absname)
except EnvironmentError, err:
if err.errno != errno.ENOENT:
raise
else:
if not stat.S_ISREG(st.st_mode):
continue
append_possible_files = possible_files.append
fid = self.get_file_id(st)
append_possible_files((fid, absname))
new_files = [fname for fid, fname in possible_files if fid not in self._tails]
self.watch(new_files) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 29; 2, function_name:parse; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 4, identifier:gctx_file_path; 5, default_parameter; 5, 6; 5, 7; 6, identifier:convert_neg_666; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:rid; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:cid; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:ridx; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:cidx; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:row_meta_only; 22, False; 23, default_parameter; 23, 24; 23, 25; 24, identifier:col_meta_only; 25, False; 26, default_parameter; 26, 27; 26, 28; 27, identifier:make_multiindex; 28, False; 29, block; 29, 30; 29, 41; 29, 78; 29, 90; 29, 100; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:full_path; 33, call; 33, 34; 33, 39; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:os; 37, identifier:path; 38, identifier:expanduser; 39, argument_list; 39, 40; 40, identifier:gctx_file_path; 41, if_statement; 41, 42; 41, 51; 42, not_operator; 42, 43; 43, call; 43, 44; 43, 49; 44, attribute; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:os; 47, identifier:path; 48, identifier:exists; 49, argument_list; 49, 50; 50, identifier:full_path; 51, block; 51, 52; 51, 56; 51, 68; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:err_msg; 55, string:"The given path to the gctx file cannot be found. full_path: {}"; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:logger; 60, identifier:error; 61, argument_list; 61, 62; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:err_msg; 65, identifier:format; 66, argument_list; 66, 67; 67, identifier:full_path; 68, raise_statement; 68, 69; 69, call; 69, 70; 69, 71; 70, identifier:Exception; 71, argument_list; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:err_msg; 75, identifier:format; 76, argument_list; 76, 77; 77, identifier:full_path; 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, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, string:"Reading GCTX: {}"; 87, identifier:format; 88, argument_list; 88, 89; 89, identifier:full_path; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:gctx_file; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:h5py; 96, identifier:File; 97, argument_list; 97, 98; 97, 99; 98, identifier:full_path; 99, string:"r"; 100, if_statement; 100, 101; 100, 102; 100, 148; 100, 196; 101, identifier:row_meta_only; 102, block; 102, 103; 102, 109; 102, 118; 102, 132; 102, 138; 102, 146; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:row_dset; 106, subscript; 106, 107; 106, 108; 107, identifier:gctx_file; 108, identifier:row_meta_group_node; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:row_meta; 112, call; 112, 113; 112, 114; 113, identifier:parse_metadata_df; 114, argument_list; 114, 115; 114, 116; 114, 117; 115, string:"row"; 116, identifier:row_dset; 117, identifier:convert_neg_666; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 123; 120, tuple_pattern; 120, 121; 120, 122; 121, identifier:sorted_ridx; 122, identifier:sorted_cidx; 123, call; 123, 124; 123, 125; 124, identifier:check_and_order_id_inputs; 125, argument_list; 125, 126; 125, 127; 125, 128; 125, 129; 125, 130; 125, 131; 126, identifier:rid; 127, identifier:ridx; 128, identifier:cid; 129, identifier:cidx; 130, identifier:row_meta; 131, None; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:gctx_file; 136, identifier:close; 137, argument_list; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:row_meta; 141, subscript; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:row_meta; 144, identifier:iloc; 145, identifier:sorted_ridx; 146, return_statement; 146, 147; 147, identifier:row_meta; 148, elif_clause; 148, 149; 148, 150; 149, identifier:col_meta_only; 150, block; 150, 151; 150, 157; 150, 166; 150, 180; 150, 186; 150, 194; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:col_dset; 154, subscript; 154, 155; 154, 156; 155, identifier:gctx_file; 156, identifier:col_meta_group_node; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:col_meta; 160, call; 160, 161; 160, 162; 161, identifier:parse_metadata_df; 162, argument_list; 162, 163; 162, 164; 162, 165; 163, string:"col"; 164, identifier:col_dset; 165, identifier:convert_neg_666; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 171; 168, tuple_pattern; 168, 169; 168, 170; 169, identifier:sorted_ridx; 170, identifier:sorted_cidx; 171, call; 171, 172; 171, 173; 172, identifier:check_and_order_id_inputs; 173, argument_list; 173, 174; 173, 175; 173, 176; 173, 177; 173, 178; 173, 179; 174, identifier:rid; 175, identifier:ridx; 176, identifier:cid; 177, identifier:cidx; 178, None; 179, identifier:col_meta; 180, expression_statement; 180, 181; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:gctx_file; 184, identifier:close; 185, argument_list; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:col_meta; 189, subscript; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:col_meta; 192, identifier:iloc; 193, identifier:sorted_cidx; 194, return_statement; 194, 195; 195, identifier:col_meta; 196, else_clause; 196, 197; 197, block; 197, 198; 197, 204; 197, 213; 197, 219; 197, 228; 197, 242; 197, 248; 197, 259; 197, 267; 197, 275; 197, 283; 197, 299; 197, 305; 197, 331; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:row_dset; 201, subscript; 201, 202; 201, 203; 202, identifier:gctx_file; 203, identifier:row_meta_group_node; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:row_meta; 207, call; 207, 208; 207, 209; 208, identifier:parse_metadata_df; 209, argument_list; 209, 210; 209, 211; 209, 212; 210, string:"row"; 211, identifier:row_dset; 212, identifier:convert_neg_666; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:col_dset; 216, subscript; 216, 217; 216, 218; 217, identifier:gctx_file; 218, identifier:col_meta_group_node; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:col_meta; 222, call; 222, 223; 222, 224; 223, identifier:parse_metadata_df; 224, argument_list; 224, 225; 224, 226; 224, 227; 225, string:"col"; 226, identifier:col_dset; 227, identifier:convert_neg_666; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 233; 230, tuple_pattern; 230, 231; 230, 232; 231, identifier:sorted_ridx; 232, identifier:sorted_cidx; 233, call; 233, 234; 233, 235; 234, identifier:check_and_order_id_inputs; 235, argument_list; 235, 236; 235, 237; 235, 238; 235, 239; 235, 240; 235, 241; 236, identifier:rid; 237, identifier:ridx; 238, identifier:cid; 239, identifier:cidx; 240, identifier:row_meta; 241, identifier:col_meta; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:data_dset; 245, subscript; 245, 246; 245, 247; 246, identifier:gctx_file; 247, identifier:data_node; 248, expression_statement; 248, 249; 249, assignment; 249, 250; 249, 251; 250, identifier:data_df; 251, call; 251, 252; 251, 253; 252, identifier:parse_data_df; 253, argument_list; 253, 254; 253, 255; 253, 256; 253, 257; 253, 258; 254, identifier:data_dset; 255, identifier:sorted_ridx; 256, identifier:sorted_cidx; 257, identifier:row_meta; 258, identifier:col_meta; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:row_meta; 262, subscript; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:row_meta; 265, identifier:iloc; 266, identifier:sorted_ridx; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:col_meta; 270, subscript; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:col_meta; 273, identifier:iloc; 274, identifier:sorted_cidx; 275, expression_statement; 275, 276; 276, assignment; 276, 277; 276, 278; 277, identifier:my_version; 278, subscript; 278, 279; 278, 282; 279, attribute; 279, 280; 279, 281; 280, identifier:gctx_file; 281, identifier:attrs; 282, identifier:version_node; 283, if_statement; 283, 284; 283, 292; 284, comparison_operator:==; 284, 285; 284, 289; 285, call; 285, 286; 285, 287; 286, identifier:type; 287, argument_list; 287, 288; 288, identifier:my_version; 289, attribute; 289, 290; 289, 291; 290, identifier:np; 291, identifier:ndarray; 292, block; 292, 293; 293, expression_statement; 293, 294; 294, assignment; 294, 295; 294, 296; 295, identifier:my_version; 296, subscript; 296, 297; 296, 298; 297, identifier:my_version; 298, integer:0; 299, expression_statement; 299, 300; 300, call; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:gctx_file; 303, identifier:close; 304, argument_list; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 308; 307, identifier:my_gctoo; 308, call; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:GCToo; 311, identifier:GCToo; 312, argument_list; 312, 313; 312, 316; 312, 319; 312, 322; 312, 325; 312, 328; 313, keyword_argument; 313, 314; 313, 315; 314, identifier:data_df; 315, identifier:data_df; 316, keyword_argument; 316, 317; 316, 318; 317, identifier:row_metadata_df; 318, identifier:row_meta; 319, keyword_argument; 319, 320; 319, 321; 320, identifier:col_metadata_df; 321, identifier:col_meta; 322, keyword_argument; 322, 323; 322, 324; 323, identifier:src; 324, identifier:full_path; 325, keyword_argument; 325, 326; 325, 327; 326, identifier:version; 327, identifier:my_version; 328, keyword_argument; 328, 329; 328, 330; 329, identifier:make_multiindex; 330, identifier:make_multiindex; 331, return_statement; 331, 332; 332, identifier:my_gctoo | def parse(gctx_file_path, convert_neg_666=True, rid=None, cid=None,
ridx=None, cidx=None, row_meta_only=False, col_meta_only=False, make_multiindex=False):
full_path = os.path.expanduser(gctx_file_path)
if not os.path.exists(full_path):
err_msg = "The given path to the gctx file cannot be found. full_path: {}"
logger.error(err_msg.format(full_path))
raise Exception(err_msg.format(full_path))
logger.info("Reading GCTX: {}".format(full_path))
gctx_file = h5py.File(full_path, "r")
if row_meta_only:
row_dset = gctx_file[row_meta_group_node]
row_meta = parse_metadata_df("row", row_dset, convert_neg_666)
(sorted_ridx, sorted_cidx) = check_and_order_id_inputs(rid, ridx, cid, cidx, row_meta, None)
gctx_file.close()
row_meta = row_meta.iloc[sorted_ridx]
return row_meta
elif col_meta_only:
col_dset = gctx_file[col_meta_group_node]
col_meta = parse_metadata_df("col", col_dset, convert_neg_666)
(sorted_ridx, sorted_cidx) = check_and_order_id_inputs(rid, ridx, cid, cidx, None, col_meta)
gctx_file.close()
col_meta = col_meta.iloc[sorted_cidx]
return col_meta
else:
row_dset = gctx_file[row_meta_group_node]
row_meta = parse_metadata_df("row", row_dset, convert_neg_666)
col_dset = gctx_file[col_meta_group_node]
col_meta = parse_metadata_df("col", col_dset, convert_neg_666)
(sorted_ridx, sorted_cidx) = check_and_order_id_inputs(rid, ridx, cid, cidx, row_meta, col_meta)
data_dset = gctx_file[data_node]
data_df = parse_data_df(data_dset, sorted_ridx, sorted_cidx, row_meta, col_meta)
row_meta = row_meta.iloc[sorted_ridx]
col_meta = col_meta.iloc[sorted_cidx]
my_version = gctx_file.attrs[version_node]
if type(my_version) == np.ndarray:
my_version = my_version[0]
gctx_file.close()
my_gctoo = GCToo.GCToo(data_df=data_df, row_metadata_df=row_meta, col_metadata_df=col_meta,
src=full_path, version=my_version, make_multiindex=make_multiindex)
return my_gctoo |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:multi_index_df_to_component_dfs; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:multi_index_df; 5, default_parameter; 5, 6; 5, 7; 6, identifier:rid; 7, string:"rid"; 8, default_parameter; 8, 9; 8, 10; 9, identifier:cid; 10, string:"cid"; 11, block; 11, 12; 11, 26; 11, 40; 11, 128; 11, 216; 11, 249; 11, 282; 11, 315; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:rids; 15, call; 15, 16; 15, 17; 16, identifier:list; 17, argument_list; 17, 18; 18, call; 18, 19; 18, 24; 19, attribute; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:multi_index_df; 22, identifier:index; 23, identifier:get_level_values; 24, argument_list; 24, 25; 25, identifier:rid; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:cids; 29, call; 29, 30; 29, 31; 30, identifier:list; 31, argument_list; 31, 32; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:multi_index_df; 36, identifier:columns; 37, identifier:get_level_values; 38, argument_list; 38, 39; 39, identifier:cid; 40, if_statement; 40, 41; 40, 50; 40, 118; 41, call; 41, 42; 41, 43; 42, identifier:isinstance; 43, argument_list; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:multi_index_df; 46, identifier:index; 47, attribute; 47, 48; 47, 49; 48, identifier:pd; 49, identifier:MultiIndex; 50, block; 50, 51; 51, if_statement; 51, 52; 51, 62; 51, 108; 52, comparison_operator:>; 52, 53; 52, 61; 53, call; 53, 54; 53, 55; 54, identifier:len; 55, argument_list; 55, 56; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:multi_index_df; 59, identifier:index; 60, identifier:names; 61, integer:1; 62, block; 62, 63; 62, 74; 62, 83; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:mi_df_index; 66, call; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:multi_index_df; 70, identifier:index; 71, identifier:droplevel; 72, argument_list; 72, 73; 73, identifier:rid; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:rhds; 77, call; 77, 78; 77, 79; 78, identifier:list; 79, argument_list; 79, 80; 80, attribute; 80, 81; 80, 82; 81, identifier:mi_df_index; 82, identifier:names; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:row_metadata; 86, attribute; 86, 87; 86, 107; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:np; 90, identifier:array; 91, argument_list; 91, 92; 92, list_comprehension; 92, 93; 92, 101; 93, attribute; 93, 94; 93, 100; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:mi_df_index; 97, identifier:get_level_values; 98, argument_list; 98, 99; 99, identifier:level; 100, identifier:values; 101, for_in_clause; 101, 102; 101, 103; 102, identifier:level; 103, call; 103, 104; 103, 105; 104, identifier:list; 105, argument_list; 105, 106; 106, identifier:rhds; 107, identifier:T; 108, else_clause; 108, 109; 109, block; 109, 110; 109, 114; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:rhds; 113, list:[]; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:row_metadata; 117, list:[]; 118, else_clause; 118, 119; 119, block; 119, 120; 119, 124; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:rhds; 123, list:[]; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:row_metadata; 127, list:[]; 128, if_statement; 128, 129; 128, 138; 128, 206; 129, call; 129, 130; 129, 131; 130, identifier:isinstance; 131, argument_list; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:multi_index_df; 134, identifier:columns; 135, attribute; 135, 136; 135, 137; 136, identifier:pd; 137, identifier:MultiIndex; 138, block; 138, 139; 139, if_statement; 139, 140; 139, 150; 139, 196; 140, comparison_operator:>; 140, 141; 140, 149; 141, call; 141, 142; 141, 143; 142, identifier:len; 143, argument_list; 143, 144; 144, attribute; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:multi_index_df; 147, identifier:columns; 148, identifier:names; 149, integer:1; 150, block; 150, 151; 150, 162; 150, 171; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:mi_df_columns; 154, call; 154, 155; 154, 160; 155, attribute; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:multi_index_df; 158, identifier:columns; 159, identifier:droplevel; 160, argument_list; 160, 161; 161, identifier:cid; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:chds; 165, call; 165, 166; 165, 167; 166, identifier:list; 167, argument_list; 167, 168; 168, attribute; 168, 169; 168, 170; 169, identifier:mi_df_columns; 170, identifier:names; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:col_metadata; 174, attribute; 174, 175; 174, 195; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:np; 178, identifier:array; 179, argument_list; 179, 180; 180, list_comprehension; 180, 181; 180, 189; 181, attribute; 181, 182; 181, 188; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:mi_df_columns; 185, identifier:get_level_values; 186, argument_list; 186, 187; 187, identifier:level; 188, identifier:values; 189, for_in_clause; 189, 190; 189, 191; 190, identifier:level; 191, call; 191, 192; 191, 193; 192, identifier:list; 193, argument_list; 193, 194; 194, identifier:chds; 195, identifier:T; 196, else_clause; 196, 197; 197, block; 197, 198; 197, 202; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:chds; 201, list:[]; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:col_metadata; 205, list:[]; 206, else_clause; 206, 207; 207, block; 207, 208; 207, 212; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:chds; 211, list:[]; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:col_metadata; 215, list:[]; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:row_metadata_df; 219, call; 219, 220; 219, 225; 220, attribute; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:pd; 223, identifier:DataFrame; 224, identifier:from_records; 225, argument_list; 225, 226; 225, 227; 225, 238; 226, identifier:row_metadata; 227, keyword_argument; 227, 228; 227, 229; 228, identifier:index; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:pd; 232, identifier:Index; 233, argument_list; 233, 234; 233, 235; 234, identifier:rids; 235, keyword_argument; 235, 236; 235, 237; 236, identifier:name; 237, string:"rid"; 238, keyword_argument; 238, 239; 238, 240; 239, identifier:columns; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:pd; 243, identifier:Index; 244, argument_list; 244, 245; 244, 246; 245, identifier:rhds; 246, keyword_argument; 246, 247; 246, 248; 247, identifier:name; 248, string:"rhd"; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:col_metadata_df; 252, call; 252, 253; 252, 258; 253, attribute; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:pd; 256, identifier:DataFrame; 257, identifier:from_records; 258, argument_list; 258, 259; 258, 260; 258, 271; 259, identifier:col_metadata; 260, keyword_argument; 260, 261; 260, 262; 261, identifier:index; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:pd; 265, identifier:Index; 266, argument_list; 266, 267; 266, 268; 267, identifier:cids; 268, keyword_argument; 268, 269; 268, 270; 269, identifier:name; 270, string:"cid"; 271, keyword_argument; 271, 272; 271, 273; 272, identifier:columns; 273, call; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:pd; 276, identifier:Index; 277, argument_list; 277, 278; 277, 279; 278, identifier:chds; 279, keyword_argument; 279, 280; 279, 281; 280, identifier:name; 281, string:"chd"; 282, expression_statement; 282, 283; 283, assignment; 283, 284; 283, 285; 284, identifier:data_df; 285, call; 285, 286; 285, 289; 286, attribute; 286, 287; 286, 288; 287, identifier:pd; 288, identifier:DataFrame; 289, argument_list; 289, 290; 289, 293; 289, 304; 290, attribute; 290, 291; 290, 292; 291, identifier:multi_index_df; 292, identifier:values; 293, keyword_argument; 293, 294; 293, 295; 294, identifier:index; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:pd; 298, identifier:Index; 299, argument_list; 299, 300; 299, 301; 300, identifier:rids; 301, keyword_argument; 301, 302; 301, 303; 302, identifier:name; 303, string:"rid"; 304, keyword_argument; 304, 305; 304, 306; 305, identifier:columns; 306, call; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:pd; 309, identifier:Index; 310, argument_list; 310, 311; 310, 312; 311, identifier:cids; 312, keyword_argument; 312, 313; 312, 314; 313, identifier:name; 314, string:"cid"; 315, return_statement; 315, 316; 316, expression_list; 316, 317; 316, 318; 316, 319; 317, identifier:data_df; 318, identifier:row_metadata_df; 319, identifier:col_metadata_df | def multi_index_df_to_component_dfs(multi_index_df, rid="rid", cid="cid"):
rids = list(multi_index_df.index.get_level_values(rid))
cids = list(multi_index_df.columns.get_level_values(cid))
if isinstance(multi_index_df.index, pd.MultiIndex):
if len(multi_index_df.index.names) > 1:
mi_df_index = multi_index_df.index.droplevel(rid)
rhds = list(mi_df_index.names)
row_metadata = np.array([mi_df_index.get_level_values(level).values for level in list(rhds)]).T
else:
rhds = []
row_metadata = []
else:
rhds = []
row_metadata = []
if isinstance(multi_index_df.columns, pd.MultiIndex):
if len(multi_index_df.columns.names) > 1:
mi_df_columns = multi_index_df.columns.droplevel(cid)
chds = list(mi_df_columns.names)
col_metadata = np.array([mi_df_columns.get_level_values(level).values for level in list(chds)]).T
else:
chds = []
col_metadata = []
else:
chds = []
col_metadata = []
row_metadata_df = pd.DataFrame.from_records(row_metadata, index=pd.Index(rids, name="rid"), columns=pd.Index(rhds, name="rhd"))
col_metadata_df = pd.DataFrame.from_records(col_metadata, index=pd.Index(cids, name="cid"), columns=pd.Index(chds, name="chd"))
data_df = pd.DataFrame(multi_index_df.values, index=pd.Index(rids, name="rid"), columns=pd.Index(cids, name="cid"))
return data_df, row_metadata_df, col_metadata_df |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 29; 2, function_name:parse; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 4, identifier:file_path; 5, default_parameter; 5, 6; 5, 7; 6, identifier:convert_neg_666; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:rid; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:cid; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:ridx; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:cidx; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:row_meta_only; 22, False; 23, default_parameter; 23, 24; 23, 25; 24, identifier:col_meta_only; 25, False; 26, default_parameter; 26, 27; 26, 28; 27, identifier:make_multiindex; 28, False; 29, block; 29, 30; 29, 130; 30, if_statement; 30, 31; 30, 37; 30, 71; 30, 112; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:file_path; 34, identifier:endswith; 35, argument_list; 35, 36; 36, string:".gct"; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:out; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:parse_gct; 44, identifier:parse; 45, argument_list; 45, 46; 45, 47; 45, 50; 45, 53; 45, 56; 45, 59; 45, 62; 45, 65; 45, 68; 46, identifier:file_path; 47, keyword_argument; 47, 48; 47, 49; 48, identifier:convert_neg_666; 49, identifier:convert_neg_666; 50, keyword_argument; 50, 51; 50, 52; 51, identifier:rid; 52, identifier:rid; 53, keyword_argument; 53, 54; 53, 55; 54, identifier:cid; 55, identifier:cid; 56, keyword_argument; 56, 57; 56, 58; 57, identifier:ridx; 58, identifier:ridx; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:cidx; 61, identifier:cidx; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:row_meta_only; 64, identifier:row_meta_only; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:col_meta_only; 67, identifier:col_meta_only; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:make_multiindex; 70, identifier:make_multiindex; 71, elif_clause; 71, 72; 71, 78; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:file_path; 75, identifier:endswith; 76, argument_list; 76, 77; 77, string:".gctx"; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:out; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:parse_gctx; 85, identifier:parse; 86, argument_list; 86, 87; 86, 88; 86, 91; 86, 94; 86, 97; 86, 100; 86, 103; 86, 106; 86, 109; 87, identifier:file_path; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:convert_neg_666; 90, identifier:convert_neg_666; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:rid; 93, identifier:rid; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:cid; 96, identifier:cid; 97, keyword_argument; 97, 98; 97, 99; 98, identifier:ridx; 99, identifier:ridx; 100, keyword_argument; 100, 101; 100, 102; 101, identifier:cidx; 102, identifier:cidx; 103, keyword_argument; 103, 104; 103, 105; 104, identifier:row_meta_only; 105, identifier:row_meta_only; 106, keyword_argument; 106, 107; 106, 108; 107, identifier:col_meta_only; 108, identifier:col_meta_only; 109, keyword_argument; 109, 110; 109, 111; 110, identifier:make_multiindex; 111, identifier:make_multiindex; 112, else_clause; 112, 113; 113, block; 113, 114; 113, 118; 113, 125; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:err_msg; 117, string:"File to parse must be .gct or .gctx!"; 118, expression_statement; 118, 119; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:logger; 122, identifier:error; 123, argument_list; 123, 124; 124, identifier:err_msg; 125, raise_statement; 125, 126; 126, call; 126, 127; 126, 128; 127, identifier:Exception; 128, argument_list; 128, 129; 129, identifier:err_msg; 130, return_statement; 130, 131; 131, identifier:out | def parse(file_path, convert_neg_666=True, rid=None, cid=None, ridx=None, cidx=None,
row_meta_only=False, col_meta_only=False, make_multiindex=False):
if file_path.endswith(".gct"):
out = parse_gct.parse(file_path, convert_neg_666=convert_neg_666,
rid=rid, cid=cid, ridx=ridx, cidx=cidx,
row_meta_only=row_meta_only, col_meta_only=col_meta_only,
make_multiindex=make_multiindex)
elif file_path.endswith(".gctx"):
out = parse_gctx.parse(file_path, convert_neg_666=convert_neg_666,
rid=rid, cid=cid, ridx=ridx, cidx=cidx,
row_meta_only=row_meta_only, col_meta_only=col_meta_only,
make_multiindex=make_multiindex)
else:
err_msg = "File to parse must be .gct or .gctx!"
logger.error(err_msg)
raise Exception(err_msg)
return out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:assemble_concatenated_meta; 3, parameters; 3, 4; 3, 5; 4, identifier:concated_meta_dfs; 5, identifier:remove_all_metadata_fields; 6, block; 6, 7; 6, 29; 6, 41; 6, 49; 6, 61; 6, 76; 6, 80; 6, 98; 7, if_statement; 7, 8; 7, 9; 8, identifier:remove_all_metadata_fields; 9, block; 9, 10; 10, for_statement; 10, 11; 10, 12; 10, 13; 11, identifier:df; 12, identifier:concated_meta_dfs; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:df; 18, identifier:drop; 19, argument_list; 19, 20; 19, 23; 19, 26; 20, attribute; 20, 21; 20, 22; 21, identifier:df; 22, identifier:columns; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:axis; 25, integer:1; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:inplace; 28, True; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:all_concated_meta_df; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:pd; 35, identifier:concat; 36, argument_list; 36, 37; 36, 38; 37, identifier:concated_meta_dfs; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:axis; 40, integer:0; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:n_rows; 44, subscript; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:all_concated_meta_df; 47, identifier:shape; 48, integer:0; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:logger; 53, identifier:debug; 54, argument_list; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, string:"all_concated_meta_df.shape[0]: {}"; 58, identifier:format; 59, argument_list; 59, 60; 60, identifier:n_rows; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:n_rows_cumulative; 64, call; 64, 65; 64, 66; 65, identifier:sum; 66, argument_list; 66, 67; 67, list_comprehension; 67, 68; 67, 73; 68, subscript; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:df; 71, identifier:shape; 72, integer:0; 73, for_in_clause; 73, 74; 73, 75; 74, identifier:df; 75, identifier:concated_meta_dfs; 76, assert_statement; 76, 77; 77, comparison_operator:==; 77, 78; 77, 79; 78, identifier:n_rows; 79, identifier:n_rows_cumulative; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:all_concated_meta_df_sorted; 83, call; 83, 84; 83, 94; 84, attribute; 84, 85; 84, 93; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:all_concated_meta_df; 88, identifier:sort_index; 89, argument_list; 89, 90; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:axis; 92, integer:0; 93, identifier:sort_index; 94, argument_list; 94, 95; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:axis; 97, integer:1; 98, return_statement; 98, 99; 99, identifier:all_concated_meta_df_sorted | def assemble_concatenated_meta(concated_meta_dfs, remove_all_metadata_fields):
if remove_all_metadata_fields:
for df in concated_meta_dfs:
df.drop(df.columns, axis=1, inplace=True)
all_concated_meta_df = pd.concat(concated_meta_dfs, axis=0)
n_rows = all_concated_meta_df.shape[0]
logger.debug("all_concated_meta_df.shape[0]: {}".format(n_rows))
n_rows_cumulative = sum([df.shape[0] for df in concated_meta_dfs])
assert n_rows == n_rows_cumulative
all_concated_meta_df_sorted = all_concated_meta_df.sort_index(axis=0).sort_index(axis=1)
return all_concated_meta_df_sorted |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:assemble_data; 3, parameters; 3, 4; 3, 5; 4, identifier:data_dfs; 5, identifier:concat_direction; 6, block; 6, 7; 6, 119; 6, 137; 7, if_statement; 7, 8; 7, 11; 7, 63; 8, comparison_operator:==; 8, 9; 8, 10; 9, identifier:concat_direction; 10, string:"horiz"; 11, block; 11, 12; 11, 24; 11, 32; 11, 44; 11, 59; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:all_data_df; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:pd; 18, identifier:concat; 19, argument_list; 19, 20; 19, 21; 20, identifier:data_dfs; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:axis; 23, integer:1; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:n_cols; 27, subscript; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:all_data_df; 30, identifier:shape; 31, integer:1; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:logger; 36, identifier:debug; 37, argument_list; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, string:"all_data_df.shape[1]: {}"; 41, identifier:format; 42, argument_list; 42, 43; 43, identifier:n_cols; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:n_cols_cumulative; 47, call; 47, 48; 47, 49; 48, identifier:sum; 49, argument_list; 49, 50; 50, list_comprehension; 50, 51; 50, 56; 51, subscript; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:df; 54, identifier:shape; 55, integer:1; 56, for_in_clause; 56, 57; 56, 58; 57, identifier:df; 58, identifier:data_dfs; 59, assert_statement; 59, 60; 60, comparison_operator:==; 60, 61; 60, 62; 61, identifier:n_cols; 62, identifier:n_cols_cumulative; 63, elif_clause; 63, 64; 63, 67; 64, comparison_operator:==; 64, 65; 64, 66; 65, identifier:concat_direction; 66, string:"vert"; 67, block; 67, 68; 67, 80; 67, 88; 67, 100; 67, 115; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:all_data_df; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:pd; 74, identifier:concat; 75, argument_list; 75, 76; 75, 77; 76, identifier:data_dfs; 77, keyword_argument; 77, 78; 77, 79; 78, identifier:axis; 79, integer:0; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:n_rows; 83, subscript; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:all_data_df; 86, identifier:shape; 87, integer:0; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:logger; 92, identifier:debug; 93, argument_list; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, string:"all_data_df.shape[0]: {}"; 97, identifier:format; 98, argument_list; 98, 99; 99, identifier:n_rows; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:n_rows_cumulative; 103, call; 103, 104; 103, 105; 104, identifier:sum; 105, argument_list; 105, 106; 106, list_comprehension; 106, 107; 106, 112; 107, subscript; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:df; 110, identifier:shape; 111, integer:0; 112, for_in_clause; 112, 113; 112, 114; 113, identifier:df; 114, identifier:data_dfs; 115, assert_statement; 115, 116; 116, comparison_operator:==; 116, 117; 116, 118; 117, identifier:n_rows; 118, identifier:n_rows_cumulative; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:all_data_df_sorted; 122, call; 122, 123; 122, 133; 123, attribute; 123, 124; 123, 132; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:all_data_df; 127, identifier:sort_index; 128, argument_list; 128, 129; 129, keyword_argument; 129, 130; 129, 131; 130, identifier:axis; 131, integer:0; 132, identifier:sort_index; 133, argument_list; 133, 134; 134, keyword_argument; 134, 135; 134, 136; 135, identifier:axis; 136, integer:1; 137, return_statement; 137, 138; 138, identifier:all_data_df_sorted | def assemble_data(data_dfs, concat_direction):
if concat_direction == "horiz":
all_data_df = pd.concat(data_dfs, axis=1)
n_cols = all_data_df.shape[1]
logger.debug("all_data_df.shape[1]: {}".format(n_cols))
n_cols_cumulative = sum([df.shape[1] for df in data_dfs])
assert n_cols == n_cols_cumulative
elif concat_direction == "vert":
all_data_df = pd.concat(data_dfs, axis=0)
n_rows = all_data_df.shape[0]
logger.debug("all_data_df.shape[0]: {}".format(n_rows))
n_rows_cumulative = sum([df.shape[0] for df in data_dfs])
assert n_rows == n_rows_cumulative
all_data_df_sorted = all_data_df.sort_index(axis=0).sort_index(axis=1)
return all_data_df_sorted |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:get_rows_to_keep; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:gctoo; 5, default_parameter; 5, 6; 5, 7; 6, identifier:rid; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:row_bool; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:ridx; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:exclude_rid; 16, None; 17, block; 17, 18; 17, 217; 17, 234; 18, if_statement; 18, 19; 18, 22; 18, 81; 18, 130; 18, 205; 19, comparison_operator:is; 19, 20; 19, 21; 20, identifier:rid; 21, None; 22, block; 22, 23; 22, 36; 22, 52; 22, 64; 23, assert_statement; 23, 24; 23, 30; 24, comparison_operator:==; 24, 25; 24, 29; 25, call; 25, 26; 25, 27; 26, identifier:type; 27, argument_list; 27, 28; 28, identifier:rid; 29, identifier:list; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, string:"rid must be a list. rid: {}"; 33, identifier:format; 34, argument_list; 34, 35; 35, identifier:rid; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:rows_to_keep; 39, list_comprehension; 39, 40; 39, 41; 39, 48; 40, identifier:gctoo_row; 41, for_in_clause; 41, 42; 41, 43; 42, identifier:gctoo_row; 43, attribute; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:gctoo; 46, identifier:data_df; 47, identifier:index; 48, if_clause; 48, 49; 49, comparison_operator:in; 49, 50; 49, 51; 50, identifier:gctoo_row; 51, identifier:rid; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:num_missing_rids; 55, binary_operator:-; 55, 56; 55, 60; 56, call; 56, 57; 56, 58; 57, identifier:len; 58, argument_list; 58, 59; 59, identifier:rid; 60, call; 60, 61; 60, 62; 61, identifier:len; 62, argument_list; 62, 63; 63, identifier:rows_to_keep; 64, if_statement; 64, 65; 64, 68; 65, comparison_operator:!=; 65, 66; 65, 67; 66, identifier:num_missing_rids; 67, integer:0; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:logger; 73, identifier:info; 74, argument_list; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, string:"{} rids were not found in the GCT."; 78, identifier:format; 79, argument_list; 79, 80; 80, identifier:num_missing_rids; 81, elif_clause; 81, 82; 81, 85; 82, comparison_operator:is; 82, 83; 82, 84; 83, identifier:row_bool; 84, None; 85, block; 85, 86; 85, 118; 86, assert_statement; 86, 87; 86, 99; 87, comparison_operator:==; 87, 88; 87, 92; 88, call; 88, 89; 88, 90; 89, identifier:len; 90, argument_list; 90, 91; 91, identifier:row_bool; 92, subscript; 92, 93; 92, 98; 93, attribute; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:gctoo; 96, identifier:data_df; 97, identifier:shape; 98, integer:0; 99, parenthesized_expression; 99, 100; 100, binary_operator:+; 100, 101; 100, 102; 101, string:"row_bool must have length equal to gctoo.data_df.shape[0]. "; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, string:"len(row_bool): {}, gctoo.data_df.shape[0]: {}"; 105, identifier:format; 106, argument_list; 106, 107; 106, 111; 107, call; 107, 108; 107, 109; 108, identifier:len; 109, argument_list; 109, 110; 110, identifier:row_bool; 111, subscript; 111, 112; 111, 117; 112, attribute; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:gctoo; 115, identifier:data_df; 116, identifier:shape; 117, integer:0; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:rows_to_keep; 121, attribute; 121, 122; 121, 129; 122, subscript; 122, 123; 122, 128; 123, attribute; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:gctoo; 126, identifier:data_df; 127, identifier:index; 128, identifier:row_bool; 129, identifier:values; 130, elif_clause; 130, 131; 130, 134; 131, comparison_operator:is; 131, 132; 131, 133; 132, identifier:ridx; 133, None; 134, block; 134, 135; 134, 161; 134, 193; 135, assert_statement; 135, 136; 135, 144; 136, comparison_operator:is; 136, 137; 136, 143; 137, call; 137, 138; 137, 139; 138, identifier:type; 139, argument_list; 139, 140; 140, subscript; 140, 141; 140, 142; 141, identifier:ridx; 142, integer:0; 143, identifier:int; 144, call; 144, 145; 144, 151; 145, attribute; 145, 146; 145, 150; 146, parenthesized_expression; 146, 147; 147, binary_operator:+; 147, 148; 147, 149; 148, string:"ridx must be a list of integers. ridx[0]: {}, "; 149, string:"type(ridx[0]): {}"; 150, identifier:format; 151, argument_list; 151, 152; 151, 155; 152, subscript; 152, 153; 152, 154; 153, identifier:ridx; 154, integer:0; 155, call; 155, 156; 155, 157; 156, identifier:type; 157, argument_list; 157, 158; 158, subscript; 158, 159; 158, 160; 159, identifier:ridx; 160, integer:0; 161, assert_statement; 161, 162; 161, 174; 162, comparison_operator:<=; 162, 163; 162, 167; 163, call; 163, 164; 163, 165; 164, identifier:max; 165, argument_list; 165, 166; 166, identifier:ridx; 167, subscript; 167, 168; 167, 173; 168, attribute; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:gctoo; 171, identifier:data_df; 172, identifier:shape; 173, integer:0; 174, call; 174, 175; 174, 181; 175, attribute; 175, 176; 175, 180; 176, parenthesized_expression; 176, 177; 177, binary_operator:+; 177, 178; 177, 179; 178, string:"ridx contains an integer larger than the number of rows in "; 179, string:"the GCToo. max(ridx): {}, gctoo.data_df.shape[0]: {}"; 180, identifier:format; 181, argument_list; 181, 182; 181, 186; 182, call; 182, 183; 182, 184; 183, identifier:max; 184, argument_list; 184, 185; 185, identifier:ridx; 186, subscript; 186, 187; 186, 192; 187, attribute; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:gctoo; 190, identifier:data_df; 191, identifier:shape; 192, integer:0; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:rows_to_keep; 196, attribute; 196, 197; 196, 204; 197, subscript; 197, 198; 197, 203; 198, attribute; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:gctoo; 201, identifier:data_df; 202, identifier:index; 203, identifier:ridx; 204, identifier:values; 205, else_clause; 205, 206; 206, block; 206, 207; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:rows_to_keep; 210, attribute; 210, 211; 210, 216; 211, attribute; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:gctoo; 214, identifier:data_df; 215, identifier:index; 216, identifier:values; 217, if_statement; 217, 218; 217, 221; 218, comparison_operator:is; 218, 219; 218, 220; 219, identifier:exclude_rid; 220, None; 221, block; 221, 222; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:rows_to_keep; 225, list_comprehension; 225, 226; 225, 227; 225, 230; 226, identifier:row_to_keep; 227, for_in_clause; 227, 228; 227, 229; 228, identifier:row_to_keep; 229, identifier:rows_to_keep; 230, if_clause; 230, 231; 231, comparison_operator:not; 231, 232; 231, 233; 232, identifier:row_to_keep; 233, identifier:exclude_rid; 234, return_statement; 234, 235; 235, identifier:rows_to_keep | def get_rows_to_keep(gctoo, rid=None, row_bool=None, ridx=None, exclude_rid=None):
if rid is not None:
assert type(rid) == list, "rid must be a list. rid: {}".format(rid)
rows_to_keep = [gctoo_row for gctoo_row in gctoo.data_df.index if gctoo_row in rid]
num_missing_rids = len(rid) - len(rows_to_keep)
if num_missing_rids != 0:
logger.info("{} rids were not found in the GCT.".format(num_missing_rids))
elif row_bool is not None:
assert len(row_bool) == gctoo.data_df.shape[0], (
"row_bool must have length equal to gctoo.data_df.shape[0]. " +
"len(row_bool): {}, gctoo.data_df.shape[0]: {}".format(
len(row_bool), gctoo.data_df.shape[0]))
rows_to_keep = gctoo.data_df.index[row_bool].values
elif ridx is not None:
assert type(ridx[0]) is int, (
"ridx must be a list of integers. ridx[0]: {}, " +
"type(ridx[0]): {}").format(ridx[0], type(ridx[0]))
assert max(ridx) <= gctoo.data_df.shape[0], (
"ridx contains an integer larger than the number of rows in " +
"the GCToo. max(ridx): {}, gctoo.data_df.shape[0]: {}").format(
max(ridx), gctoo.data_df.shape[0])
rows_to_keep = gctoo.data_df.index[ridx].values
else:
rows_to_keep = gctoo.data_df.index.values
if exclude_rid is not None:
rows_to_keep = [row_to_keep for row_to_keep in rows_to_keep if row_to_keep not in exclude_rid]
return rows_to_keep |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:get_cols_to_keep; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:gctoo; 5, default_parameter; 5, 6; 5, 7; 6, identifier:cid; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:col_bool; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:cidx; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:exclude_cid; 16, None; 17, block; 17, 18; 17, 217; 17, 234; 18, if_statement; 18, 19; 18, 22; 18, 81; 18, 130; 18, 205; 19, comparison_operator:is; 19, 20; 19, 21; 20, identifier:cid; 21, None; 22, block; 22, 23; 22, 36; 22, 52; 22, 64; 23, assert_statement; 23, 24; 23, 30; 24, comparison_operator:==; 24, 25; 24, 29; 25, call; 25, 26; 25, 27; 26, identifier:type; 27, argument_list; 27, 28; 28, identifier:cid; 29, identifier:list; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, string:"cid must be a list. cid: {}"; 33, identifier:format; 34, argument_list; 34, 35; 35, identifier:cid; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:cols_to_keep; 39, list_comprehension; 39, 40; 39, 41; 39, 48; 40, identifier:gctoo_col; 41, for_in_clause; 41, 42; 41, 43; 42, identifier:gctoo_col; 43, attribute; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:gctoo; 46, identifier:data_df; 47, identifier:columns; 48, if_clause; 48, 49; 49, comparison_operator:in; 49, 50; 49, 51; 50, identifier:gctoo_col; 51, identifier:cid; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:num_missing_cids; 55, binary_operator:-; 55, 56; 55, 60; 56, call; 56, 57; 56, 58; 57, identifier:len; 58, argument_list; 58, 59; 59, identifier:cid; 60, call; 60, 61; 60, 62; 61, identifier:len; 62, argument_list; 62, 63; 63, identifier:cols_to_keep; 64, if_statement; 64, 65; 64, 68; 65, comparison_operator:!=; 65, 66; 65, 67; 66, identifier:num_missing_cids; 67, integer:0; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:logger; 73, identifier:info; 74, argument_list; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, string:"{} cids were not found in the GCT."; 78, identifier:format; 79, argument_list; 79, 80; 80, identifier:num_missing_cids; 81, elif_clause; 81, 82; 81, 85; 82, comparison_operator:is; 82, 83; 82, 84; 83, identifier:col_bool; 84, None; 85, block; 85, 86; 85, 118; 86, assert_statement; 86, 87; 86, 99; 87, comparison_operator:==; 87, 88; 87, 92; 88, call; 88, 89; 88, 90; 89, identifier:len; 90, argument_list; 90, 91; 91, identifier:col_bool; 92, subscript; 92, 93; 92, 98; 93, attribute; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:gctoo; 96, identifier:data_df; 97, identifier:shape; 98, integer:1; 99, parenthesized_expression; 99, 100; 100, binary_operator:+; 100, 101; 100, 102; 101, string:"col_bool must have length equal to gctoo.data_df.shape[1]. "; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, string:"len(col_bool): {}, gctoo.data_df.shape[1]: {}"; 105, identifier:format; 106, argument_list; 106, 107; 106, 111; 107, call; 107, 108; 107, 109; 108, identifier:len; 109, argument_list; 109, 110; 110, identifier:col_bool; 111, subscript; 111, 112; 111, 117; 112, attribute; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:gctoo; 115, identifier:data_df; 116, identifier:shape; 117, integer:1; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:cols_to_keep; 121, attribute; 121, 122; 121, 129; 122, subscript; 122, 123; 122, 128; 123, attribute; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:gctoo; 126, identifier:data_df; 127, identifier:columns; 128, identifier:col_bool; 129, identifier:values; 130, elif_clause; 130, 131; 130, 134; 131, comparison_operator:is; 131, 132; 131, 133; 132, identifier:cidx; 133, None; 134, block; 134, 135; 134, 161; 134, 193; 135, assert_statement; 135, 136; 135, 144; 136, comparison_operator:is; 136, 137; 136, 143; 137, call; 137, 138; 137, 139; 138, identifier:type; 139, argument_list; 139, 140; 140, subscript; 140, 141; 140, 142; 141, identifier:cidx; 142, integer:0; 143, identifier:int; 144, call; 144, 145; 144, 151; 145, attribute; 145, 146; 145, 150; 146, parenthesized_expression; 146, 147; 147, binary_operator:+; 147, 148; 147, 149; 148, string:"cidx must be a list of integers. cidx[0]: {}, "; 149, string:"type(cidx[0]): {}"; 150, identifier:format; 151, argument_list; 151, 152; 151, 155; 152, subscript; 152, 153; 152, 154; 153, identifier:cidx; 154, integer:0; 155, call; 155, 156; 155, 157; 156, identifier:type; 157, argument_list; 157, 158; 158, subscript; 158, 159; 158, 160; 159, identifier:cidx; 160, integer:0; 161, assert_statement; 161, 162; 161, 174; 162, comparison_operator:<=; 162, 163; 162, 167; 163, call; 163, 164; 163, 165; 164, identifier:max; 165, argument_list; 165, 166; 166, identifier:cidx; 167, subscript; 167, 168; 167, 173; 168, attribute; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:gctoo; 171, identifier:data_df; 172, identifier:shape; 173, integer:1; 174, call; 174, 175; 174, 181; 175, attribute; 175, 176; 175, 180; 176, parenthesized_expression; 176, 177; 177, binary_operator:+; 177, 178; 177, 179; 178, string:"cidx contains an integer larger than the number of columns in "; 179, string:"the GCToo. max(cidx): {}, gctoo.data_df.shape[1]: {}"; 180, identifier:format; 181, argument_list; 181, 182; 181, 186; 182, call; 182, 183; 182, 184; 183, identifier:max; 184, argument_list; 184, 185; 185, identifier:cidx; 186, subscript; 186, 187; 186, 192; 187, attribute; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:gctoo; 190, identifier:data_df; 191, identifier:shape; 192, integer:1; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:cols_to_keep; 196, attribute; 196, 197; 196, 204; 197, subscript; 197, 198; 197, 203; 198, attribute; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:gctoo; 201, identifier:data_df; 202, identifier:columns; 203, identifier:cidx; 204, identifier:values; 205, else_clause; 205, 206; 206, block; 206, 207; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:cols_to_keep; 210, attribute; 210, 211; 210, 216; 211, attribute; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:gctoo; 214, identifier:data_df; 215, identifier:columns; 216, identifier:values; 217, if_statement; 217, 218; 217, 221; 218, comparison_operator:is; 218, 219; 218, 220; 219, identifier:exclude_cid; 220, None; 221, block; 221, 222; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:cols_to_keep; 225, list_comprehension; 225, 226; 225, 227; 225, 230; 226, identifier:col_to_keep; 227, for_in_clause; 227, 228; 227, 229; 228, identifier:col_to_keep; 229, identifier:cols_to_keep; 230, if_clause; 230, 231; 231, comparison_operator:not; 231, 232; 231, 233; 232, identifier:col_to_keep; 233, identifier:exclude_cid; 234, return_statement; 234, 235; 235, identifier:cols_to_keep | def get_cols_to_keep(gctoo, cid=None, col_bool=None, cidx=None, exclude_cid=None):
if cid is not None:
assert type(cid) == list, "cid must be a list. cid: {}".format(cid)
cols_to_keep = [gctoo_col for gctoo_col in gctoo.data_df.columns if gctoo_col in cid]
num_missing_cids = len(cid) - len(cols_to_keep)
if num_missing_cids != 0:
logger.info("{} cids were not found in the GCT.".format(num_missing_cids))
elif col_bool is not None:
assert len(col_bool) == gctoo.data_df.shape[1], (
"col_bool must have length equal to gctoo.data_df.shape[1]. " +
"len(col_bool): {}, gctoo.data_df.shape[1]: {}".format(
len(col_bool), gctoo.data_df.shape[1]))
cols_to_keep = gctoo.data_df.columns[col_bool].values
elif cidx is not None:
assert type(cidx[0]) is int, (
"cidx must be a list of integers. cidx[0]: {}, " +
"type(cidx[0]): {}").format(cidx[0], type(cidx[0]))
assert max(cidx) <= gctoo.data_df.shape[1], (
"cidx contains an integer larger than the number of columns in " +
"the GCToo. max(cidx): {}, gctoo.data_df.shape[1]: {}").format(
max(cidx), gctoo.data_df.shape[1])
cols_to_keep = gctoo.data_df.columns[cidx].values
else:
cols_to_keep = gctoo.data_df.columns.values
if exclude_cid is not None:
cols_to_keep = [col_to_keep for col_to_keep in cols_to_keep if col_to_keep not in exclude_cid]
return cols_to_keep |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:finish; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:queue_name; 5, identifier:task_id; 6, identifier:owner; 7, default_parameter; 7, 8; 7, 9; 8, identifier:error; 9, False; 10, block; 10, 11; 10, 20; 10, 49; 10, 71; 10, 83; 10, 92; 10, 104; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:task; 14, call; 14, 15; 14, 16; 15, identifier:_get_task_with_policy; 16, argument_list; 16, 17; 16, 18; 16, 19; 17, identifier:queue_name; 18, identifier:task_id; 19, identifier:owner; 20, if_statement; 20, 21; 20, 29; 21, not_operator; 21, 22; 22, comparison_operator:==; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:task; 25, identifier:status; 26, attribute; 26, 27; 26, 28; 27, identifier:WorkQueue; 28, identifier:LIVE; 29, block; 29, 30; 29, 47; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:logging; 34, identifier:warning; 35, argument_list; 35, 36; 35, 39; 35, 42; 35, 43; 35, 44; 36, concatenated_string; 36, 37; 36, 38; 37, string:'Finishing already dead task. queue=%r, task_id=%r, '; 38, string:'owner=%r, status=%r'; 39, attribute; 39, 40; 39, 41; 40, identifier:task; 41, identifier:queue_name; 42, identifier:task_id; 43, identifier:owner; 44, attribute; 44, 45; 44, 46; 45, identifier:task; 46, identifier:status; 47, return_statement; 47, 48; 48, False; 49, if_statement; 49, 50; 49, 52; 49, 61; 50, not_operator; 50, 51; 51, identifier:error; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:task; 57, identifier:status; 58, attribute; 58, 59; 58, 60; 59, identifier:WorkQueue; 60, identifier:DONE; 61, else_clause; 61, 62; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:task; 67, identifier:status; 68, attribute; 68, 69; 68, 70; 69, identifier:WorkQueue; 70, identifier:ERROR; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:task; 75, identifier:finished; 76, call; 76, 77; 76, 82; 77, attribute; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:datetime; 80, identifier:datetime; 81, identifier:utcnow; 82, argument_list; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 90; 85, attribute; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:db; 88, identifier:session; 89, identifier:add; 90, argument_list; 90, 91; 91, identifier:task; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 99; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:signals; 97, identifier:task_updated; 98, identifier:send; 99, argument_list; 99, 100; 99, 101; 100, identifier:app; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:task; 103, identifier:task; 104, return_statement; 104, 105; 105, True | def finish(queue_name, task_id, owner, error=False):
task = _get_task_with_policy(queue_name, task_id, owner)
if not task.status == WorkQueue.LIVE:
logging.warning('Finishing already dead task. queue=%r, task_id=%r, '
'owner=%r, status=%r',
task.queue_name, task_id, owner, task.status)
return False
if not error:
task.status = WorkQueue.DONE
else:
task.status = WorkQueue.ERROR
task.finished = datetime.datetime.utcnow()
db.session.add(task)
signals.task_updated.send(app, task=task)
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:send_ready_for_review; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:build_id; 5, identifier:release_name; 6, identifier:release_number; 7, block; 7, 8; 7, 21; 7, 40; 7, 49; 7, 63; 7, 86; 7, 98; 7, 117; 7, 121; 7, 152; 7, 175; 7, 185; 7, 191; 7, 210; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:build; 11, call; 11, 12; 11, 19; 12, attribute; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:models; 16, identifier:Build; 17, identifier:query; 18, identifier:get; 19, argument_list; 19, 20; 20, identifier:build_id; 21, if_statement; 21, 22; 21, 26; 22, not_operator; 22, 23; 23, attribute; 23, 24; 23, 25; 24, identifier:build; 25, identifier:send_email; 26, block; 26, 27; 26, 39; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:logging; 31, identifier:debug; 32, argument_list; 32, 33; 32, 36; 33, concatenated_string; 33, 34; 33, 35; 34, string:'Not sending ready for review email because build does not have '; 35, string:'email enabled. build_id=%r'; 36, attribute; 36, 37; 36, 38; 37, identifier:build; 38, identifier:id; 39, return_statement; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:ops; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:operations; 46, identifier:BuildOps; 47, argument_list; 47, 48; 48, identifier:build_id; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 56; 51, pattern_list; 51, 52; 51, 53; 51, 54; 51, 55; 52, identifier:release; 53, identifier:run_list; 54, identifier:stats_dict; 55, identifier:_; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:ops; 59, identifier:get_release; 60, argument_list; 60, 61; 60, 62; 61, identifier:release_name; 62, identifier:release_number; 63, if_statement; 63, 64; 63, 66; 64, not_operator; 64, 65; 65, identifier:run_list; 66, block; 66, 67; 66, 85; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:logging; 71, identifier:debug; 72, argument_list; 72, 73; 72, 76; 72, 79; 72, 82; 73, concatenated_string; 73, 74; 73, 75; 74, string:'Not sending ready for review email because there are '; 75, string:' no runs. build_id=%r, release_name=%r, release_number=%d'; 76, attribute; 76, 77; 76, 78; 77, identifier:build; 78, identifier:id; 79, attribute; 79, 80; 79, 81; 80, identifier:release; 81, identifier:name; 82, attribute; 82, 83; 82, 84; 83, identifier:release; 84, identifier:number; 85, return_statement; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:title; 89, binary_operator:%; 89, 90; 89, 91; 90, string:'%s: %s - Ready for review'; 91, tuple; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:build; 94, identifier:name; 95, attribute; 95, 96; 95, 97; 96, identifier:release; 97, identifier:name; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:email_body; 101, call; 101, 102; 101, 103; 102, identifier:render_template; 103, argument_list; 103, 104; 103, 105; 103, 108; 103, 111; 103, 114; 104, string:'email_ready_for_review.html'; 105, keyword_argument; 105, 106; 105, 107; 106, identifier:build; 107, identifier:build; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:release; 110, identifier:release; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:run_list; 113, identifier:run_list; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:stats_dict; 116, identifier:stats_dict; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:recipients; 120, list:[]; 121, if_statement; 121, 122; 121, 125; 121, 135; 122, attribute; 122, 123; 122, 124; 123, identifier:build; 124, identifier:email_alias; 125, block; 125, 126; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:recipients; 130, identifier:append; 131, argument_list; 131, 132; 132, attribute; 132, 133; 132, 134; 133, identifier:build; 134, identifier:email_alias; 135, else_clause; 135, 136; 136, block; 136, 137; 137, for_statement; 137, 138; 137, 139; 137, 142; 138, identifier:user; 139, attribute; 139, 140; 139, 141; 140, identifier:build; 141, identifier:owners; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:recipients; 147, identifier:append; 148, argument_list; 148, 149; 149, attribute; 149, 150; 149, 151; 150, identifier:user; 151, identifier:email_address; 152, if_statement; 152, 153; 152, 155; 153, not_operator; 153, 154; 154, identifier:recipients; 155, block; 155, 156; 155, 174; 156, expression_statement; 156, 157; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:logging; 160, identifier:debug; 161, argument_list; 161, 162; 161, 165; 161, 168; 161, 171; 162, concatenated_string; 162, 163; 162, 164; 163, string:'Not sending ready for review email because there are no '; 164, string:'recipients. build_id=%r, release_name=%r, release_number=%d'; 165, attribute; 165, 166; 165, 167; 166, identifier:build; 167, identifier:id; 168, attribute; 168, 169; 168, 170; 169, identifier:release; 170, identifier:name; 171, attribute; 171, 172; 171, 173; 172, identifier:release; 173, identifier:number; 174, return_statement; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:message; 178, call; 178, 179; 178, 180; 179, identifier:Message; 180, argument_list; 180, 181; 180, 182; 181, identifier:title; 182, keyword_argument; 182, 183; 182, 184; 183, identifier:recipients; 184, identifier:recipients; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:message; 189, identifier:html; 190, identifier:email_body; 191, expression_statement; 191, 192; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:logging; 195, identifier:info; 196, argument_list; 196, 197; 196, 200; 196, 203; 196, 206; 196, 209; 197, concatenated_string; 197, 198; 197, 199; 198, string:'Sending ready for review email for build_id=%r, '; 199, string:'release_name=%r, release_number=%d to %r'; 200, attribute; 200, 201; 200, 202; 201, identifier:build; 202, identifier:id; 203, attribute; 203, 204; 203, 205; 204, identifier:release; 205, identifier:name; 206, attribute; 206, 207; 206, 208; 207, identifier:release; 208, identifier:number; 209, identifier:recipients; 210, return_statement; 210, 211; 211, call; 211, 212; 211, 213; 212, identifier:render_or_send; 213, argument_list; 213, 214; 213, 215; 214, identifier:send_ready_for_review; 215, identifier:message | def send_ready_for_review(build_id, release_name, release_number):
build = models.Build.query.get(build_id)
if not build.send_email:
logging.debug(
'Not sending ready for review email because build does not have '
'email enabled. build_id=%r', build.id)
return
ops = operations.BuildOps(build_id)
release, run_list, stats_dict, _ = ops.get_release(
release_name, release_number)
if not run_list:
logging.debug(
'Not sending ready for review email because there are '
' no runs. build_id=%r, release_name=%r, release_number=%d',
build.id, release.name, release.number)
return
title = '%s: %s - Ready for review' % (build.name, release.name)
email_body = render_template(
'email_ready_for_review.html',
build=build,
release=release,
run_list=run_list,
stats_dict=stats_dict)
recipients = []
if build.email_alias:
recipients.append(build.email_alias)
else:
for user in build.owners:
recipients.append(user.email_address)
if not recipients:
logging.debug(
'Not sending ready for review email because there are no '
'recipients. build_id=%r, release_name=%r, release_number=%d',
build.id, release.name, release.number)
return
message = Message(title, recipients=recipients)
message.html = email_body
logging.info('Sending ready for review email for build_id=%r, '
'release_name=%r, release_number=%d to %r',
build.id, release.name, release.number, recipients)
return render_or_send(send_ready_for_review, message) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:claim_invitations; 3, parameters; 3, 4; 4, identifier:user; 5, block; 5, 6; 5, 20; 5, 33; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:invitation_user_id; 9, binary_operator:%; 9, 10; 9, 11; 10, string:'%s:%s'; 11, tuple; 11, 12; 11, 17; 12, attribute; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:models; 15, identifier:User; 16, identifier:EMAIL_INVITATION; 17, attribute; 17, 18; 17, 19; 18, identifier:user; 19, identifier:email_address; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:invitation_user; 23, call; 23, 24; 23, 31; 24, attribute; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:models; 28, identifier:User; 29, identifier:query; 30, identifier:get; 31, argument_list; 31, 32; 32, identifier:invitation_user_id; 33, if_statement; 33, 34; 33, 35; 34, identifier:invitation_user; 35, block; 35, 36; 35, 45; 35, 50; 35, 59; 35, 72; 35, 149; 35, 158; 35, 166; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:invited_build_list; 39, call; 39, 40; 39, 41; 40, identifier:list; 41, argument_list; 41, 42; 42, attribute; 42, 43; 42, 44; 43, identifier:invitation_user; 44, identifier:builds; 45, if_statement; 45, 46; 45, 48; 46, not_operator; 46, 47; 47, identifier:invited_build_list; 48, block; 48, 49; 49, return_statement; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 57; 52, attribute; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:db; 55, identifier:session; 56, identifier:add; 57, argument_list; 57, 58; 58, identifier:user; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:logging; 63, identifier:debug; 64, argument_list; 64, 65; 64, 66; 64, 70; 64, 71; 65, string:'Found %d build admin invitations for id=%r, user=%r'; 66, call; 66, 67; 66, 68; 67, identifier:len; 68, argument_list; 68, 69; 69, identifier:invited_build_list; 70, identifier:invitation_user_id; 71, identifier:user; 72, for_statement; 72, 73; 72, 74; 72, 75; 73, identifier:build; 74, identifier:invited_build_list; 75, block; 75, 76; 75, 85; 75, 140; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 83; 78, attribute; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:build; 81, identifier:owners; 82, identifier:remove; 83, argument_list; 83, 84; 84, identifier:invitation_user; 85, if_statement; 85, 86; 85, 95; 85, 123; 86, not_operator; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:build; 90, identifier:is_owned_by; 91, argument_list; 91, 92; 92, attribute; 92, 93; 92, 94; 93, identifier:user; 94, identifier:id; 95, block; 95, 96; 95, 105; 95, 115; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 103; 98, attribute; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:build; 101, identifier:owners; 102, identifier:append; 103, argument_list; 103, 104; 104, identifier:user; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:logging; 109, identifier:debug; 110, argument_list; 110, 111; 110, 112; 111, string:'Claiming invitation for build_id=%r'; 112, attribute; 112, 113; 112, 114; 113, identifier:build; 114, identifier:id; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 118; 117, identifier:save_admin_log; 118, argument_list; 118, 119; 118, 120; 119, identifier:build; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:invite_accepted; 122, True; 123, else_clause; 123, 124; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:logging; 129, identifier:debug; 130, argument_list; 130, 131; 130, 134; 130, 137; 131, concatenated_string; 131, 132; 131, 133; 132, string:'User already owner of build. '; 133, string:'id=%r, build_id=%r'; 134, attribute; 134, 135; 134, 136; 135, identifier:user; 136, identifier:id; 137, attribute; 137, 138; 137, 139; 138, identifier:build; 139, identifier:id; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 147; 142, attribute; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:db; 145, identifier:session; 146, identifier:add; 147, argument_list; 147, 148; 148, identifier:build; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 156; 151, attribute; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:db; 154, identifier:session; 155, identifier:delete; 156, argument_list; 156, 157; 157, identifier:invitation_user; 158, expression_statement; 158, 159; 159, call; 159, 160; 159, 165; 160, attribute; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:db; 163, identifier:session; 164, identifier:commit; 165, argument_list; 166, expression_statement; 166, 167; 167, call; 167, 168; 167, 173; 168, attribute; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:db; 171, identifier:session; 172, identifier:add; 173, argument_list; 173, 174; 174, identifier:current_user | def claim_invitations(user):
invitation_user_id = '%s:%s' % (
models.User.EMAIL_INVITATION, user.email_address)
invitation_user = models.User.query.get(invitation_user_id)
if invitation_user:
invited_build_list = list(invitation_user.builds)
if not invited_build_list:
return
db.session.add(user)
logging.debug('Found %d build admin invitations for id=%r, user=%r',
len(invited_build_list), invitation_user_id, user)
for build in invited_build_list:
build.owners.remove(invitation_user)
if not build.is_owned_by(user.id):
build.owners.append(user)
logging.debug('Claiming invitation for build_id=%r', build.id)
save_admin_log(build, invite_accepted=True)
else:
logging.debug('User already owner of build. '
'id=%r, build_id=%r', user.id, build.id)
db.session.add(build)
db.session.delete(invitation_user)
db.session.commit()
db.session.add(current_user) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_check_release_done_processing; 3, parameters; 3, 4; 4, identifier:release; 5, block; 5, 6; 5, 37; 5, 54; 5, 95; 5, 113; 5, 119; 5, 125; 5, 131; 5, 150; 5, 160; 5, 169; 6, if_statement; 6, 7; 6, 16; 7, comparison_operator:!=; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:release; 10, identifier:status; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:models; 14, identifier:Release; 15, identifier:PROCESSING; 16, block; 16, 17; 16, 35; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:logging; 21, identifier:info; 22, argument_list; 22, 23; 22, 26; 22, 29; 22, 32; 23, concatenated_string; 23, 24; 23, 25; 24, string:'Release not in processing state yet: build_id=%r, '; 25, string:'name=%r, number=%d'; 26, attribute; 26, 27; 26, 28; 27, identifier:release; 28, identifier:build_id; 29, attribute; 29, 30; 29, 31; 30, identifier:release; 31, identifier:name; 32, attribute; 32, 33; 32, 34; 33, identifier:release; 34, identifier:number; 35, return_statement; 35, 36; 36, False; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:query; 40, call; 40, 41; 40, 48; 41, attribute; 41, 42; 41, 47; 42, attribute; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:models; 45, identifier:Run; 46, identifier:query; 47, identifier:filter_by; 48, argument_list; 48, 49; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:release_id; 51, attribute; 51, 52; 51, 53; 52, identifier:release; 53, identifier:id; 54, for_statement; 54, 55; 54, 56; 54, 57; 55, identifier:run; 56, identifier:query; 57, block; 57, 58; 57, 71; 57, 83; 58, if_statement; 58, 59; 58, 68; 59, comparison_operator:==; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:run; 62, identifier:status; 63, attribute; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:models; 66, identifier:Run; 67, identifier:NEEDS_DIFF; 68, block; 68, 69; 69, return_statement; 69, 70; 70, False; 71, if_statement; 71, 72; 71, 80; 72, boolean_operator:and; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:run; 75, identifier:ref_config; 76, not_operator; 76, 77; 77, attribute; 77, 78; 77, 79; 78, identifier:run; 79, identifier:ref_image; 80, block; 80, 81; 81, return_statement; 81, 82; 82, False; 83, if_statement; 83, 84; 83, 92; 84, boolean_operator:and; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:run; 87, identifier:config; 88, not_operator; 88, 89; 89, attribute; 89, 90; 89, 91; 90, identifier:run; 91, identifier:image; 92, block; 92, 93; 93, return_statement; 93, 94; 94, False; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:logging; 99, identifier:info; 100, argument_list; 100, 101; 100, 104; 100, 107; 100, 110; 101, concatenated_string; 101, 102; 101, 103; 102, string:'Release done processing, now reviewing: build_id=%r, '; 103, string:'name=%r, number=%d'; 104, attribute; 104, 105; 104, 106; 105, identifier:release; 106, identifier:build_id; 107, attribute; 107, 108; 107, 109; 108, identifier:release; 109, identifier:name; 110, attribute; 110, 111; 110, 112; 111, identifier:release; 112, identifier:number; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:build_id; 116, attribute; 116, 117; 116, 118; 117, identifier:release; 118, identifier:build_id; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:release_name; 122, attribute; 122, 123; 122, 124; 123, identifier:release; 124, identifier:name; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:release_number; 128, attribute; 128, 129; 128, 130; 129, identifier:release; 130, identifier:number; 131, decorated_definition; 131, 132; 131, 136; 132, decorator; 132, 133; 133, attribute; 133, 134; 133, 135; 134, identifier:utils; 135, identifier:after_this_request; 136, function_definition; 136, 137; 136, 138; 136, 140; 137, function_name:send_notification_email; 138, parameters; 138, 139; 139, identifier:response; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:emails; 145, identifier:send_ready_for_review; 146, argument_list; 146, 147; 146, 148; 146, 149; 147, identifier:build_id; 148, identifier:release_name; 149, identifier:release_number; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:release; 154, identifier:status; 155, attribute; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:models; 158, identifier:Release; 159, identifier:REVIEWING; 160, expression_statement; 160, 161; 161, call; 161, 162; 161, 167; 162, attribute; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:db; 165, identifier:session; 166, identifier:add; 167, argument_list; 167, 168; 168, identifier:release; 169, return_statement; 169, 170; 170, True | def _check_release_done_processing(release):
if release.status != models.Release.PROCESSING:
logging.info('Release not in processing state yet: build_id=%r, '
'name=%r, number=%d', release.build_id, release.name,
release.number)
return False
query = models.Run.query.filter_by(release_id=release.id)
for run in query:
if run.status == models.Run.NEEDS_DIFF:
return False
if run.ref_config and not run.ref_image:
return False
if run.config and not run.image:
return False
logging.info('Release done processing, now reviewing: build_id=%r, '
'name=%r, number=%d', release.build_id, release.name,
release.number)
build_id = release.build_id
release_name = release.name
release_number = release.number
@utils.after_this_request
def send_notification_email(response):
emails.send_ready_for_review(build_id, release_name, release_number)
release.status = models.Release.REVIEWING
db.session.add(release)
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:download; 3, parameters; 4, block; 4, 5; 4, 37; 4, 51; 4, 68; 4, 81; 4, 98; 4, 112; 4, 129; 4, 146; 4, 164; 4, 187; 4, 202; 4, 229; 5, try_statement; 5, 6; 5, 16; 6, block; 6, 7; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:build; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:auth; 13, identifier:can_user_access_build; 14, argument_list; 14, 15; 15, string:'build_id'; 16, except_clause; 16, 17; 16, 18; 17, identifier:HTTPException; 18, block; 18, 19; 18, 26; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:logging; 23, identifier:debug; 24, argument_list; 24, 25; 25, string:'User access to artifact failed. Trying API key.'; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 31; 28, pattern_list; 28, 29; 28, 30; 29, identifier:_; 30, identifier:build; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:auth; 34, identifier:can_api_key_access_build; 35, argument_list; 35, 36; 36, string:'build_id'; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:sha1sum; 40, call; 40, 41; 40, 46; 41, attribute; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:request; 44, identifier:args; 45, identifier:get; 46, argument_list; 46, 47; 46, 48; 47, string:'sha1sum'; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:type; 50, identifier:str; 51, if_statement; 51, 52; 51, 54; 52, not_operator; 52, 53; 53, identifier:sha1sum; 54, block; 54, 55; 54, 63; 55, expression_statement; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:logging; 59, identifier:debug; 60, argument_list; 60, 61; 60, 62; 61, string:'Artifact sha1sum=%r not supplied'; 62, identifier:sha1sum; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 66; 65, identifier:abort; 66, argument_list; 66, 67; 67, integer:404; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:artifact; 71, call; 71, 72; 71, 79; 72, attribute; 72, 73; 72, 78; 73, attribute; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:models; 76, identifier:Artifact; 77, identifier:query; 78, identifier:get; 79, argument_list; 79, 80; 80, identifier:sha1sum; 81, if_statement; 81, 82; 81, 84; 82, not_operator; 82, 83; 83, identifier:artifact; 84, block; 84, 85; 84, 93; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:logging; 89, identifier:debug; 90, argument_list; 90, 91; 90, 92; 91, string:'Artifact sha1sum=%r does not exist'; 92, identifier:sha1sum; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 96; 95, identifier:abort; 96, argument_list; 96, 97; 97, integer:404; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:build_id; 101, call; 101, 102; 101, 107; 102, attribute; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:request; 105, identifier:args; 106, identifier:get; 107, argument_list; 107, 108; 107, 109; 108, string:'build_id'; 109, keyword_argument; 109, 110; 109, 111; 110, identifier:type; 111, identifier:int; 112, if_statement; 112, 113; 112, 115; 113, not_operator; 113, 114; 114, identifier:build_id; 115, block; 115, 116; 115, 124; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:logging; 120, identifier:debug; 121, argument_list; 121, 122; 121, 123; 122, string:'build_id missing for artifact sha1sum=%r'; 123, identifier:sha1sum; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 127; 126, identifier:abort; 127, argument_list; 127, 128; 128, integer:404; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:is_owned; 132, call; 132, 133; 132, 145; 133, attribute; 133, 134; 133, 144; 134, call; 134, 135; 134, 140; 135, attribute; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:artifact; 138, identifier:owners; 139, identifier:filter_by; 140, argument_list; 140, 141; 141, keyword_argument; 141, 142; 141, 143; 142, identifier:id; 143, identifier:build_id; 144, identifier:first; 145, argument_list; 146, if_statement; 146, 147; 146, 149; 147, not_operator; 147, 148; 148, identifier:is_owned; 149, block; 149, 150; 149, 159; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:logging; 154, identifier:debug; 155, argument_list; 155, 156; 155, 157; 155, 158; 156, string:'build_id=%r not owner of artifact sha1sum=%r'; 157, identifier:build_id; 158, identifier:sha1sum; 159, expression_statement; 159, 160; 160, call; 160, 161; 160, 162; 161, identifier:abort; 162, argument_list; 162, 163; 163, integer:403; 164, decorated_definition; 164, 165; 164, 169; 165, decorator; 165, 166; 166, attribute; 166, 167; 166, 168; 167, identifier:utils; 168, identifier:after_this_request; 169, function_definition; 169, 170; 169, 171; 169, 173; 170, function_name:no_session; 171, parameters; 171, 172; 172, identifier:response; 173, block; 173, 174; 174, if_statement; 174, 175; 174, 180; 175, comparison_operator:in; 175, 176; 175, 177; 176, string:'Set-Cookie'; 177, attribute; 177, 178; 177, 179; 178, identifier:response; 179, identifier:headers; 180, block; 180, 181; 181, delete_statement; 181, 182; 182, subscript; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:response; 185, identifier:headers; 186, string:'Set-Cookie'; 187, if_statement; 187, 188; 187, 194; 188, not_operator; 188, 189; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:utils; 192, identifier:is_production; 193, argument_list; 194, block; 194, 195; 195, expression_statement; 195, 196; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:time; 199, identifier:sleep; 200, argument_list; 200, 201; 201, float:1.5; 202, if_statement; 202, 203; 202, 215; 203, boolean_operator:and; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:request; 206, identifier:if_none_match; 207, call; 207, 208; 207, 213; 208, attribute; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:request; 211, identifier:if_none_match; 212, identifier:contains; 213, argument_list; 213, 214; 214, identifier:sha1sum; 215, block; 215, 216; 215, 227; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:response; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:flask; 222, identifier:Response; 223, argument_list; 223, 224; 224, keyword_argument; 224, 225; 224, 226; 225, identifier:status; 226, integer:304; 227, return_statement; 227, 228; 228, identifier:response; 229, return_statement; 229, 230; 230, call; 230, 231; 230, 232; 231, identifier:_get_artifact_response; 232, argument_list; 232, 233; 233, identifier:artifact | def download():
try:
build = auth.can_user_access_build('build_id')
except HTTPException:
logging.debug('User access to artifact failed. Trying API key.')
_, build = auth.can_api_key_access_build('build_id')
sha1sum = request.args.get('sha1sum', type=str)
if not sha1sum:
logging.debug('Artifact sha1sum=%r not supplied', sha1sum)
abort(404)
artifact = models.Artifact.query.get(sha1sum)
if not artifact:
logging.debug('Artifact sha1sum=%r does not exist', sha1sum)
abort(404)
build_id = request.args.get('build_id', type=int)
if not build_id:
logging.debug('build_id missing for artifact sha1sum=%r', sha1sum)
abort(404)
is_owned = artifact.owners.filter_by(id=build_id).first()
if not is_owned:
logging.debug('build_id=%r not owner of artifact sha1sum=%r',
build_id, sha1sum)
abort(403)
@utils.after_this_request
def no_session(response):
if 'Set-Cookie' in response.headers:
del response.headers['Set-Cookie']
if not utils.is_production():
time.sleep(1.5)
if request.if_none_match and request.if_none_match.contains(sha1sum):
response = flask.Response(status=304)
return response
return _get_artifact_response(artifact) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_run; 3, parameters; 3, 4; 4, identifier:run; 5, block; 5, 6; 5, 23; 6, if_statement; 6, 7; 6, 16; 7, comparison_operator:in; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:run; 10, identifier:status; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:models; 14, identifier:Run; 15, identifier:DIFF_NEEDED_STATES; 16, block; 16, 17; 17, return_statement; 17, 18; 18, tuple; 18, 19; 18, 20; 19, integer:0; 20, attribute; 20, 21; 20, 22; 21, identifier:run; 22, identifier:name; 23, return_statement; 23, 24; 24, tuple; 24, 25; 24, 26; 25, integer:1; 26, attribute; 26, 27; 26, 28; 27, identifier:run; 28, identifier:name | def sort_run(run):
if run.status in models.Run.DIFF_NEEDED_STATES:
return (0, run.name)
return (1, run.name) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:parse; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:obj; 5, default_parameter; 5, 6; 5, 7; 6, identifier:required_properties; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:additional_properties; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:ignore_optional_property_errors; 13, None; 14, block; 14, 15; 14, 45; 14, 49; 14, 138; 14, 153; 15, if_statement; 15, 16; 15, 23; 16, not_operator; 16, 17; 17, parenthesized_expression; 17, 18; 18, comparison_operator:is; 18, 19; 18, 20; 18, 21; 18, 22; 19, identifier:required_properties; 20, identifier:additional_properties; 21, identifier:ignore_optional_property_errors; 22, None; 23, block; 23, 24; 24, with_statement; 24, 25; 24, 39; 25, with_clause; 25, 26; 26, with_item; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:parsing; 29, argument_list; 29, 30; 29, 33; 29, 36; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:required_properties; 32, identifier:required_properties; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:additional_properties; 35, identifier:additional_properties; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:ignore_optional_property_errors; 38, identifier:ignore_optional_property_errors; 39, block; 39, 40; 40, return_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:parse; 43, argument_list; 43, 44; 44, identifier:obj; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:validator; 48, None; 49, if_statement; 49, 50; 49, 55; 49, 60; 49, 80; 50, call; 50, 51; 50, 52; 51, identifier:isinstance; 52, argument_list; 52, 53; 52, 54; 53, identifier:obj; 54, identifier:Validator; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:validator; 59, identifier:obj; 60, elif_clause; 60, 61; 60, 73; 61, boolean_operator:and; 61, 62; 61, 68; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:inspect; 65, identifier:isclass; 66, argument_list; 66, 67; 67, identifier:obj; 68, call; 68, 69; 68, 70; 69, identifier:issubclass; 70, argument_list; 70, 71; 70, 72; 71, identifier:obj; 72, identifier:Validator; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:validator; 77, call; 77, 78; 77, 79; 78, identifier:obj; 79, argument_list; 80, else_clause; 80, 81; 81, block; 81, 82; 82, try_statement; 82, 83; 82, 90; 82, 112; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:validator; 87, subscript; 87, 88; 87, 89; 88, identifier:_NAMED_VALIDATORS; 89, identifier:obj; 90, except_clause; 90, 91; 90, 94; 91, tuple; 91, 92; 91, 93; 92, identifier:KeyError; 93, identifier:TypeError; 94, block; 94, 95; 95, for_statement; 95, 96; 95, 97; 95, 98; 96, identifier:factory; 97, identifier:_VALIDATOR_FACTORIES; 98, block; 98, 99; 98, 106; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:validator; 102, call; 102, 103; 102, 104; 103, identifier:factory; 104, argument_list; 104, 105; 105, identifier:obj; 106, if_statement; 106, 107; 106, 110; 107, comparison_operator:is; 107, 108; 107, 109; 108, identifier:validator; 109, None; 110, block; 110, 111; 111, break_statement; 112, else_clause; 112, 113; 113, block; 113, 114; 114, if_statement; 114, 115; 114, 127; 115, boolean_operator:and; 115, 116; 115, 122; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:inspect; 119, identifier:isclass; 120, argument_list; 120, 121; 121, identifier:validator; 122, call; 122, 123; 122, 124; 123, identifier:issubclass; 124, argument_list; 124, 125; 124, 126; 125, identifier:validator; 126, identifier:Validator; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 133; 130, subscript; 130, 131; 130, 132; 131, identifier:_NAMED_VALIDATORS; 132, identifier:obj; 133, assignment; 133, 134; 133, 135; 134, identifier:validator; 135, call; 135, 136; 135, 137; 136, identifier:validator; 137, argument_list; 138, if_statement; 138, 139; 138, 145; 139, not_operator; 139, 140; 140, call; 140, 141; 140, 142; 141, identifier:isinstance; 142, argument_list; 142, 143; 142, 144; 143, identifier:validator; 144, identifier:Validator; 145, block; 145, 146; 146, raise_statement; 146, 147; 147, call; 147, 148; 147, 149; 148, identifier:SchemaError; 149, argument_list; 149, 150; 150, binary_operator:%; 150, 151; 150, 152; 151, string:"%r cannot be parsed as a Validator"; 152, identifier:obj; 153, return_statement; 153, 154; 154, identifier:validator | def parse(obj, required_properties=None, additional_properties=None,
ignore_optional_property_errors=None):
if not (required_properties is
additional_properties is
ignore_optional_property_errors is None):
with parsing(required_properties=required_properties,
additional_properties=additional_properties,
ignore_optional_property_errors=ignore_optional_property_errors):
return parse(obj)
validator = None
if isinstance(obj, Validator):
validator = obj
elif inspect.isclass(obj) and issubclass(obj, Validator):
validator = obj()
else:
try:
validator = _NAMED_VALIDATORS[obj]
except (KeyError, TypeError):
for factory in _VALIDATOR_FACTORIES:
validator = factory(obj)
if validator is not None:
break
else:
if inspect.isclass(validator) and issubclass(validator, Validator):
_NAMED_VALIDATORS[obj] = validator = validator()
if not isinstance(validator, Validator):
raise SchemaError("%r cannot be parsed as a Validator" % obj)
return validator |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:adapts; 3, parameters; 3, 4; 4, dictionary_splat_pattern; 4, 5; 5, identifier:schemas; 6, block; 6, 7; 6, 16; 6, 143; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:validate; 10, attribute; 10, 11; 10, 15; 11, call; 11, 12; 11, 13; 12, identifier:parse; 13, argument_list; 13, 14; 14, identifier:schemas; 15, identifier:validate; 16, decorated_definition; 16, 17; 16, 19; 17, decorator; 17, 18; 18, identifier:decorator; 19, function_definition; 19, 20; 19, 21; 19, 27; 20, function_name:adapting; 21, parameters; 21, 22; 21, 23; 21, 25; 22, identifier:func; 23, list_splat_pattern; 23, 24; 24, identifier:args; 25, dictionary_splat_pattern; 25, 26; 26, identifier:kwargs; 27, block; 27, 28; 27, 47; 27, 56; 27, 72; 27, 84; 27, 96; 27, 116; 27, 128; 27, 135; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:adapted; 31, call; 31, 32; 31, 33; 32, identifier:validate; 33, argument_list; 33, 34; 33, 44; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:inspect; 37, identifier:getcallargs; 38, argument_list; 38, 39; 38, 40; 38, 42; 39, identifier:func; 40, list_splat; 40, 41; 41, identifier:args; 42, dictionary_splat; 42, 43; 43, identifier:kwargs; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:adapt; 46, True; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:argspec; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:inspect; 53, identifier:getargspec; 54, argument_list; 54, 55; 55, identifier:func; 56, if_statement; 56, 57; 56, 65; 57, comparison_operator:is; 57, 58; 57, 61; 57, 64; 58, attribute; 58, 59; 58, 60; 59, identifier:argspec; 60, identifier:varargs; 61, attribute; 61, 62; 61, 63; 62, identifier:argspec; 63, identifier:keywords; 64, None; 65, block; 65, 66; 66, return_statement; 66, 67; 67, call; 67, 68; 67, 69; 68, identifier:func; 69, argument_list; 69, 70; 70, dictionary_splat; 70, 71; 71, identifier:adapted; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:adapted_varargs; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:adapted; 78, identifier:pop; 79, argument_list; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:argspec; 82, identifier:varargs; 83, tuple; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:adapted_keywords; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:adapted; 90, identifier:pop; 91, argument_list; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:argspec; 94, identifier:keywords; 95, dictionary; 96, if_statement; 96, 97; 96, 99; 97, not_operator; 97, 98; 98, identifier:adapted_varargs; 99, block; 99, 100; 99, 110; 100, if_statement; 100, 101; 100, 102; 101, identifier:adapted_keywords; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:adapted; 107, identifier:update; 108, argument_list; 108, 109; 109, identifier:adapted_keywords; 110, return_statement; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:func; 113, argument_list; 113, 114; 114, dictionary_splat; 114, 115; 115, identifier:adapted; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:adapted_posargs; 119, list_comprehension; 119, 120; 119, 123; 120, subscript; 120, 121; 120, 122; 121, identifier:adapted; 122, identifier:arg; 123, for_in_clause; 123, 124; 123, 125; 124, identifier:arg; 125, attribute; 125, 126; 125, 127; 126, identifier:argspec; 127, identifier:args; 128, expression_statement; 128, 129; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:adapted_posargs; 132, identifier:extend; 133, argument_list; 133, 134; 134, identifier:adapted_varargs; 135, return_statement; 135, 136; 136, call; 136, 137; 136, 138; 137, identifier:func; 138, argument_list; 138, 139; 138, 141; 139, list_splat; 139, 140; 140, identifier:adapted_posargs; 141, dictionary_splat; 141, 142; 142, identifier:adapted_keywords; 143, return_statement; 143, 144; 144, identifier:adapting | def adapts(**schemas):
validate = parse(schemas).validate
@decorator
def adapting(func, *args, **kwargs):
adapted = validate(inspect.getcallargs(func, *args, **kwargs), adapt=True)
argspec = inspect.getargspec(func)
if argspec.varargs is argspec.keywords is None:
return func(**adapted)
adapted_varargs = adapted.pop(argspec.varargs, ())
adapted_keywords = adapted.pop(argspec.keywords, {})
if not adapted_varargs:
if adapted_keywords:
adapted.update(adapted_keywords)
return func(**adapted)
adapted_posargs = [adapted[arg] for arg in argspec.args]
adapted_posargs.extend(adapted_varargs)
return func(*adapted_posargs, **adapted_keywords)
return adapting |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 27; 2, function_name:download; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 17; 3, 21; 3, 24; 4, identifier:self; 5, identifier:bundle_uuid; 6, identifier:replica; 7, default_parameter; 7, 8; 7, 9; 8, identifier:version; 9, string:""; 10, default_parameter; 10, 11; 10, 12; 11, identifier:download_dir; 12, string:""; 13, default_parameter; 13, 14; 13, 15; 14, identifier:metadata_files; 15, tuple; 15, 16; 16, string:'*'; 17, default_parameter; 17, 18; 17, 19; 18, identifier:data_files; 19, tuple; 19, 20; 20, string:'*'; 21, default_parameter; 21, 22; 21, 23; 22, identifier:num_retries; 23, integer:10; 24, default_parameter; 24, 25; 24, 26; 25, identifier:min_delay_seconds; 26, float:0.25; 27, block; 27, 28; 27, 32; 27, 132; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:errors; 31, integer:0; 32, with_statement; 32, 33; 32, 48; 33, with_clause; 33, 34; 34, with_item; 34, 35; 35, as_pattern; 35, 36; 35, 46; 36, call; 36, 37; 36, 42; 37, attribute; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:concurrent; 40, identifier:futures; 41, identifier:ThreadPoolExecutor; 42, argument_list; 42, 43; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:threads; 46, as_pattern_target; 46, 47; 47, identifier:executor; 48, block; 48, 49; 48, 78; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:futures_to_dss_file; 52, dictionary_comprehension; 52, 53; 52, 61; 53, pair; 53, 54; 53, 60; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:executor; 57, identifier:submit; 58, argument_list; 58, 59; 59, identifier:task; 60, identifier:dss_file; 61, for_in_clause; 61, 62; 61, 65; 62, pattern_list; 62, 63; 62, 64; 63, identifier:dss_file; 64, identifier:task; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:_download_tasks; 69, argument_list; 69, 70; 69, 71; 69, 72; 69, 73; 69, 74; 69, 75; 69, 76; 69, 77; 70, identifier:bundle_uuid; 71, identifier:replica; 72, identifier:version; 73, identifier:download_dir; 74, identifier:metadata_files; 75, identifier:data_files; 76, identifier:num_retries; 77, identifier:min_delay_seconds; 78, for_statement; 78, 79; 78, 80; 78, 88; 79, identifier:future; 80, call; 80, 81; 80, 86; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:concurrent; 84, identifier:futures; 85, identifier:as_completed; 86, argument_list; 86, 87; 87, identifier:futures_to_dss_file; 88, block; 88, 89; 88, 95; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:dss_file; 92, subscript; 92, 93; 92, 94; 93, identifier:futures_to_dss_file; 94, identifier:future; 95, try_statement; 95, 96; 95, 103; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:future; 101, identifier:result; 102, argument_list; 103, except_clause; 103, 104; 103, 108; 104, as_pattern; 104, 105; 104, 106; 105, identifier:Exception; 106, as_pattern_target; 106, 107; 107, identifier:e; 108, block; 108, 109; 108, 113; 109, expression_statement; 109, 110; 110, augmented_assignment:+=; 110, 111; 110, 112; 111, identifier:errors; 112, integer:1; 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; 118, 129; 119, string:'Failed to download file %s version %s from replica %s'; 120, attribute; 120, 121; 120, 122; 121, identifier:dss_file; 122, identifier:uuid; 123, attribute; 123, 124; 123, 125; 124, identifier:dss_file; 125, identifier:version; 126, attribute; 126, 127; 126, 128; 127, identifier:dss_file; 128, identifier:replica; 129, keyword_argument; 129, 130; 129, 131; 130, identifier:exc_info; 131, identifier:e; 132, if_statement; 132, 133; 132, 134; 133, identifier:errors; 134, block; 134, 135; 135, raise_statement; 135, 136; 136, call; 136, 137; 136, 138; 137, identifier:RuntimeError; 138, argument_list; 138, 139; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, string:'{} file(s) failed to download'; 142, identifier:format; 143, argument_list; 143, 144; 144, identifier:errors | def download(self, bundle_uuid, replica, version="", download_dir="",
metadata_files=('*',), data_files=('*',),
num_retries=10, min_delay_seconds=0.25):
errors = 0
with concurrent.futures.ThreadPoolExecutor(self.threads) as executor:
futures_to_dss_file = {executor.submit(task): dss_file
for dss_file, task in self._download_tasks(bundle_uuid,
replica,
version,
download_dir,
metadata_files,
data_files,
num_retries,
min_delay_seconds)}
for future in concurrent.futures.as_completed(futures_to_dss_file):
dss_file = futures_to_dss_file[future]
try:
future.result()
except Exception as e:
errors += 1
logger.warning('Failed to download file %s version %s from replica %s',
dss_file.uuid, dss_file.version, dss_file.replica, exc_info=e)
if errors:
raise RuntimeError('{} file(s) failed to download'.format(errors)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_do_download_file; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:self; 5, identifier:dss_file; 6, identifier:fh; 7, identifier:num_retries; 8, identifier:min_delay_seconds; 9, block; 9, 10; 9, 18; 9, 22; 9, 26; 9, 383; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:hasher; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:hashlib; 16, identifier:sha256; 17, argument_list; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:delay; 21, identifier:min_delay_seconds; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:retries_left; 25, identifier:num_retries; 26, while_statement; 26, 27; 26, 28; 27, True; 28, block; 28, 29; 29, try_statement; 29, 30; 29, 340; 30, block; 30, 31; 30, 77; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:response; 34, call; 34, 35; 34, 40; 35, attribute; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:get_file; 39, identifier:_request; 40, argument_list; 40, 41; 40, 59; 40, 62; 41, call; 41, 42; 41, 43; 42, identifier:dict; 43, argument_list; 43, 44; 43, 49; 43, 54; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:uuid; 46, attribute; 46, 47; 46, 48; 47, identifier:dss_file; 48, identifier:uuid; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:version; 51, attribute; 51, 52; 51, 53; 52, identifier:dss_file; 53, identifier:version; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:replica; 56, attribute; 56, 57; 56, 58; 57, identifier:dss_file; 58, identifier:replica; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:stream; 61, True; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:headers; 64, dictionary; 64, 65; 65, pair; 65, 66; 65, 67; 66, string:'Range'; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, string:"bytes={}-"; 70, identifier:format; 71, argument_list; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:fh; 75, identifier:tell; 76, argument_list; 77, try_statement; 77, 78; 77, 332; 78, block; 78, 79; 78, 116; 78, 127; 78, 131; 78, 143; 78, 183; 78, 187; 78, 191; 78, 281; 78, 331; 79, if_statement; 79, 80; 79, 84; 80, not_operator; 80, 81; 81, attribute; 81, 82; 81, 83; 82, identifier:response; 83, identifier:ok; 84, block; 84, 85; 84, 100; 84, 115; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:logger; 89, identifier:error; 90, argument_list; 90, 91; 90, 92; 91, string:"%s"; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, string:"File {}: GET FAILED."; 95, identifier:format; 96, argument_list; 96, 97; 97, attribute; 97, 98; 97, 99; 98, identifier:dss_file; 99, identifier:uuid; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:logger; 104, identifier:error; 105, argument_list; 105, 106; 105, 107; 106, string:"%s"; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, string:"Response: {}"; 110, identifier:format; 111, argument_list; 111, 112; 112, attribute; 112, 113; 112, 114; 113, identifier:response; 114, identifier:text; 115, break_statement; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:consume_bytes; 119, call; 119, 120; 119, 121; 120, identifier:int; 121, argument_list; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:fh; 125, identifier:tell; 126, argument_list; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:server_start; 130, integer:0; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:content_range_header; 134, call; 134, 135; 134, 140; 135, attribute; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:response; 138, identifier:headers; 139, identifier:get; 140, argument_list; 140, 141; 140, 142; 141, string:'Content-Range'; 142, None; 143, if_statement; 143, 144; 143, 147; 144, comparison_operator:is; 144, 145; 144, 146; 145, identifier:content_range_header; 146, None; 147, block; 147, 148; 147, 157; 147, 166; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:cre; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:re; 154, identifier:compile; 155, argument_list; 155, 156; 156, string:"bytes (\d+)-(\d+)"; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:mo; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:cre; 163, identifier:search; 164, argument_list; 164, 165; 165, identifier:content_range_header; 166, if_statement; 166, 167; 166, 170; 167, comparison_operator:is; 167, 168; 167, 169; 168, identifier:mo; 169, None; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:server_start; 174, call; 174, 175; 174, 176; 175, identifier:int; 176, argument_list; 176, 177; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:mo; 180, identifier:group; 181, argument_list; 181, 182; 182, integer:1; 183, expression_statement; 183, 184; 184, augmented_assignment:-=; 184, 185; 184, 186; 185, identifier:consume_bytes; 186, identifier:server_start; 187, assert_statement; 187, 188; 188, comparison_operator:>=; 188, 189; 188, 190; 189, identifier:consume_bytes; 190, integer:0; 191, if_statement; 191, 192; 191, 199; 191, 216; 192, boolean_operator:and; 192, 193; 192, 196; 193, comparison_operator:>; 193, 194; 193, 195; 194, identifier:server_start; 195, integer:0; 196, comparison_operator:==; 196, 197; 196, 198; 197, identifier:consume_bytes; 198, integer:0; 199, block; 199, 200; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:logger; 204, identifier:info; 205, argument_list; 205, 206; 205, 207; 206, string:"%s"; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, string:"File {}: Resuming at {}."; 210, identifier:format; 211, argument_list; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:dss_file; 214, identifier:uuid; 215, identifier:server_start; 216, elif_clause; 216, 217; 216, 220; 217, comparison_operator:>; 217, 218; 217, 219; 218, identifier:consume_bytes; 219, integer:0; 220, block; 220, 221; 220, 238; 221, expression_statement; 221, 222; 222, call; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:logger; 225, identifier:info; 226, argument_list; 226, 227; 226, 228; 227, string:"%s"; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, string:"File {}: Resuming at {}. Dropping {} bytes to match"; 231, identifier:format; 232, argument_list; 232, 233; 232, 236; 232, 237; 233, attribute; 233, 234; 233, 235; 234, identifier:dss_file; 235, identifier:uuid; 236, identifier:server_start; 237, identifier:consume_bytes; 238, while_statement; 238, 239; 238, 242; 239, comparison_operator:>; 239, 240; 239, 241; 240, identifier:consume_bytes; 241, integer:0; 242, block; 242, 243; 242, 253; 242, 264; 242, 271; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:bytes_to_read; 246, call; 246, 247; 246, 248; 247, identifier:min; 248, argument_list; 248, 249; 248, 250; 249, identifier:consume_bytes; 250, binary_operator:*; 250, 251; 250, 252; 251, integer:1024; 252, integer:1024; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:content; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:response; 259, identifier:iter_content; 260, argument_list; 260, 261; 261, keyword_argument; 261, 262; 261, 263; 262, identifier:chunk_size; 263, identifier:bytes_to_read; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 267; 266, identifier:chunk; 267, call; 267, 268; 267, 269; 268, identifier:next; 269, argument_list; 269, 270; 270, identifier:content; 271, if_statement; 271, 272; 271, 273; 272, identifier:chunk; 273, block; 273, 274; 274, expression_statement; 274, 275; 275, augmented_assignment:-=; 275, 276; 275, 277; 276, identifier:consume_bytes; 277, call; 277, 278; 277, 279; 278, identifier:len; 279, argument_list; 279, 280; 280, identifier:chunk; 281, for_statement; 281, 282; 281, 283; 281, 293; 282, identifier:chunk; 283, call; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:response; 286, identifier:iter_content; 287, argument_list; 287, 288; 288, keyword_argument; 288, 289; 288, 290; 289, identifier:chunk_size; 290, binary_operator:*; 290, 291; 290, 292; 291, integer:1024; 292, integer:1024; 293, block; 293, 294; 294, if_statement; 294, 295; 294, 296; 295, identifier:chunk; 296, block; 296, 297; 296, 304; 296, 311; 296, 321; 297, expression_statement; 297, 298; 298, call; 298, 299; 298, 302; 299, attribute; 299, 300; 299, 301; 300, identifier:fh; 301, identifier:write; 302, argument_list; 302, 303; 303, identifier:chunk; 304, expression_statement; 304, 305; 305, call; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:hasher; 308, identifier:update; 309, argument_list; 309, 310; 310, identifier:chunk; 311, expression_statement; 311, 312; 312, assignment; 312, 313; 312, 314; 313, identifier:retries_left; 314, call; 314, 315; 314, 316; 315, identifier:min; 316, argument_list; 316, 317; 316, 320; 317, binary_operator:+; 317, 318; 317, 319; 318, identifier:retries_left; 319, integer:1; 320, identifier:num_retries; 321, expression_statement; 321, 322; 322, assignment; 322, 323; 322, 324; 323, identifier:delay; 324, call; 324, 325; 324, 326; 325, identifier:max; 326, argument_list; 326, 327; 326, 330; 327, binary_operator:/; 327, 328; 327, 329; 328, identifier:delay; 329, integer:2; 330, identifier:min_delay_seconds; 331, break_statement; 332, finally_clause; 332, 333; 333, block; 333, 334; 334, expression_statement; 334, 335; 335, call; 335, 336; 335, 339; 336, attribute; 336, 337; 336, 338; 337, identifier:response; 338, identifier:close; 339, argument_list; 340, except_clause; 340, 341; 340, 345; 341, tuple; 341, 342; 341, 343; 341, 344; 342, identifier:ChunkedEncodingError; 343, identifier:ConnectionError; 344, identifier:ReadTimeout; 345, block; 345, 346; 345, 382; 346, if_statement; 346, 347; 346, 350; 347, comparison_operator:>; 347, 348; 347, 349; 348, identifier:retries_left; 349, integer:0; 350, block; 350, 351; 350, 366; 350, 373; 350, 377; 350, 381; 351, expression_statement; 351, 352; 352, call; 352, 353; 352, 356; 353, attribute; 353, 354; 353, 355; 354, identifier:logger; 355, identifier:info; 356, argument_list; 356, 357; 356, 358; 357, string:"%s"; 358, call; 358, 359; 358, 362; 359, attribute; 359, 360; 359, 361; 360, string:"File {}: GET FAILED. Attempting to resume."; 361, identifier:format; 362, argument_list; 362, 363; 363, attribute; 363, 364; 363, 365; 364, identifier:dss_file; 365, identifier:uuid; 366, expression_statement; 366, 367; 367, call; 367, 368; 367, 371; 368, attribute; 368, 369; 368, 370; 369, identifier:time; 370, identifier:sleep; 371, argument_list; 371, 372; 372, identifier:delay; 373, expression_statement; 373, 374; 374, augmented_assignment:*=; 374, 375; 374, 376; 375, identifier:delay; 376, integer:2; 377, expression_statement; 377, 378; 378, augmented_assignment:-=; 378, 379; 378, 380; 379, identifier:retries_left; 380, integer:1; 381, continue_statement; 382, raise_statement; 383, return_statement; 383, 384; 384, call; 384, 385; 384, 388; 385, attribute; 385, 386; 385, 387; 386, identifier:hasher; 387, identifier:hexdigest; 388, argument_list | def _do_download_file(self, dss_file, fh, num_retries, min_delay_seconds):
hasher = hashlib.sha256()
delay = min_delay_seconds
retries_left = num_retries
while True:
try:
response = self.get_file._request(
dict(uuid=dss_file.uuid, version=dss_file.version, replica=dss_file.replica),
stream=True,
headers={
'Range': "bytes={}-".format(fh.tell())
},
)
try:
if not response.ok:
logger.error("%s", "File {}: GET FAILED.".format(dss_file.uuid))
logger.error("%s", "Response: {}".format(response.text))
break
consume_bytes = int(fh.tell())
server_start = 0
content_range_header = response.headers.get('Content-Range', None)
if content_range_header is not None:
cre = re.compile("bytes (\d+)-(\d+)")
mo = cre.search(content_range_header)
if mo is not None:
server_start = int(mo.group(1))
consume_bytes -= server_start
assert consume_bytes >= 0
if server_start > 0 and consume_bytes == 0:
logger.info("%s", "File {}: Resuming at {}.".format(
dss_file.uuid, server_start))
elif consume_bytes > 0:
logger.info("%s", "File {}: Resuming at {}. Dropping {} bytes to match".format(
dss_file.uuid, server_start, consume_bytes))
while consume_bytes > 0:
bytes_to_read = min(consume_bytes, 1024*1024)
content = response.iter_content(chunk_size=bytes_to_read)
chunk = next(content)
if chunk:
consume_bytes -= len(chunk)
for chunk in response.iter_content(chunk_size=1024*1024):
if chunk:
fh.write(chunk)
hasher.update(chunk)
retries_left = min(retries_left + 1, num_retries)
delay = max(delay / 2, min_delay_seconds)
break
finally:
response.close()
except (ChunkedEncodingError, ConnectionError, ReadTimeout):
if retries_left > 0:
logger.info("%s", "File {}: GET FAILED. Attempting to resume.".format(dss_file.uuid))
time.sleep(delay)
delay *= 2
retries_left -= 1
continue
raise
return hasher.hexdigest() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:output; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:output; 6, default_parameter; 6, 7; 6, 8; 7, identifier:status; 8, None; 9, block; 9, 10; 9, 188; 10, if_statement; 10, 11; 10, 12; 11, identifier:output; 12, block; 12, 13; 12, 25; 12, 34; 12, 38; 12, 42; 12, 54; 12, 157; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:size; 16, call; 16, 17; 16, 24; 17, attribute; 17, 18; 17, 23; 18, attribute; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:cli; 22, identifier:output; 23, identifier:get_size; 24, argument_list; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:margin; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:get_output_margin; 32, argument_list; 32, 33; 33, identifier:status; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:fits; 37, True; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:buf; 41, list:[]; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:output_via_pager; 45, boolean_operator:and; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:explicit_pager; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:special; 52, identifier:is_pager_enabled; 53, argument_list; 54, for_statement; 54, 55; 54, 58; 54, 63; 55, pattern_list; 55, 56; 55, 57; 56, identifier:i; 57, identifier:line; 58, call; 58, 59; 58, 60; 59, identifier:enumerate; 60, argument_list; 60, 61; 60, 62; 61, identifier:output; 62, integer:1; 63, block; 63, 64; 63, 71; 63, 78; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:special; 68, identifier:write_tee; 69, argument_list; 69, 70; 70, identifier:line; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:special; 75, identifier:write_once; 76, argument_list; 76, 77; 77, identifier:line; 78, if_statement; 78, 79; 78, 82; 78, 148; 79, boolean_operator:or; 79, 80; 79, 81; 80, identifier:fits; 81, identifier:output_via_pager; 82, block; 82, 83; 82, 90; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:buf; 87, identifier:append; 88, argument_list; 88, 89; 89, identifier:line; 90, if_statement; 90, 91; 90, 108; 91, boolean_operator:or; 91, 92; 91, 100; 92, comparison_operator:>; 92, 93; 92, 97; 93, call; 93, 94; 93, 95; 94, identifier:len; 95, argument_list; 95, 96; 96, identifier:line; 97, attribute; 97, 98; 97, 99; 98, identifier:size; 99, identifier:columns; 100, comparison_operator:>; 100, 101; 100, 102; 101, identifier:i; 102, parenthesized_expression; 102, 103; 103, binary_operator:-; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:size; 106, identifier:rows; 107, identifier:margin; 108, block; 108, 109; 108, 113; 108, 129; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:fits; 112, False; 113, if_statement; 113, 114; 113, 124; 114, boolean_operator:and; 114, 115; 114, 119; 115, not_operator; 115, 116; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:explicit_pager; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:special; 122, identifier:is_pager_enabled; 123, argument_list; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:output_via_pager; 128, True; 129, if_statement; 129, 130; 129, 132; 130, not_operator; 130, 131; 131, identifier:output_via_pager; 132, block; 132, 133; 132, 144; 133, for_statement; 133, 134; 133, 135; 133, 136; 134, identifier:line; 135, identifier:buf; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:click; 141, identifier:secho; 142, argument_list; 142, 143; 143, identifier:line; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:buf; 147, list:[]; 148, else_clause; 148, 149; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:click; 154, identifier:secho; 155, argument_list; 155, 156; 156, identifier:line; 157, if_statement; 157, 158; 157, 159; 158, identifier:buf; 159, block; 159, 160; 160, if_statement; 160, 161; 160, 162; 160, 175; 161, identifier:output_via_pager; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:click; 167, identifier:echo_via_pager; 168, argument_list; 168, 169; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, string:"\n"; 172, identifier:join; 173, argument_list; 173, 174; 174, identifier:buf; 175, else_clause; 175, 176; 176, block; 176, 177; 177, for_statement; 177, 178; 177, 179; 177, 180; 178, identifier:line; 179, identifier:buf; 180, block; 180, 181; 181, expression_statement; 181, 182; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:click; 185, identifier:secho; 186, argument_list; 186, 187; 187, identifier:line; 188, if_statement; 188, 189; 188, 190; 189, identifier:status; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:click; 195, identifier:secho; 196, argument_list; 196, 197; 197, identifier:status | def output(self, output, status=None):
if output:
size = self.cli.output.get_size()
margin = self.get_output_margin(status)
fits = True
buf = []
output_via_pager = self.explicit_pager and special.is_pager_enabled()
for i, line in enumerate(output, 1):
special.write_tee(line)
special.write_once(line)
if fits or output_via_pager:
buf.append(line)
if len(line) > size.columns or i > (size.rows - margin):
fits = False
if not self.explicit_pager and special.is_pager_enabled():
output_via_pager = True
if not output_via_pager:
for line in buf:
click.secho(line)
buf = []
else:
click.secho(line)
if buf:
if output_via_pager:
click.echo_via_pager("\n".join(buf))
else:
for line in buf:
click.secho(line)
if status:
click.secho(status) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:find_matches; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:text; 5, identifier:collection; 6, default_parameter; 6, 7; 6, 8; 7, identifier:start_only; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:fuzzy; 11, True; 12, default_parameter; 12, 13; 12, 14; 13, identifier:casing; 14, None; 15, block; 15, 16; 15, 26; 15, 34; 15, 38; 15, 159; 15, 180; 15, 202; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:last; 19, call; 19, 20; 19, 21; 20, identifier:last_word; 21, argument_list; 21, 22; 21, 23; 22, identifier:text; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:include; 25, string:'most_punctuations'; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:text; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:last; 32, identifier:lower; 33, argument_list; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:completions; 37, list:[]; 38, if_statement; 38, 39; 38, 40; 38, 107; 39, identifier:fuzzy; 40, block; 40, 41; 40, 54; 40, 63; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:regex; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, string:'.*?'; 47, identifier:join; 48, argument_list; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:map; 51, argument_list; 51, 52; 51, 53; 52, identifier:escape; 53, identifier:text; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:pat; 57, call; 57, 58; 57, 59; 58, identifier:compile; 59, argument_list; 59, 60; 60, binary_operator:%; 60, 61; 60, 62; 61, string:'(%s)'; 62, identifier:regex; 63, for_statement; 63, 64; 63, 65; 63, 69; 64, identifier:item; 65, call; 65, 66; 65, 67; 66, identifier:sorted; 67, argument_list; 67, 68; 68, identifier:collection; 69, block; 69, 70; 69, 83; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:r; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:pat; 76, identifier:search; 77, argument_list; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:item; 81, identifier:lower; 82, argument_list; 83, if_statement; 83, 84; 83, 85; 84, identifier:r; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:completions; 90, identifier:append; 91, argument_list; 91, 92; 92, tuple; 92, 93; 92, 101; 92, 106; 93, call; 93, 94; 93, 95; 94, identifier:len; 95, argument_list; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:r; 99, identifier:group; 100, argument_list; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:r; 104, identifier:start; 105, argument_list; 106, identifier:item; 107, else_clause; 107, 108; 108, block; 108, 109; 108, 119; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:match_end_limit; 112, conditional_expression:if; 112, 113; 112, 117; 112, 118; 113, call; 113, 114; 113, 115; 114, identifier:len; 115, argument_list; 115, 116; 116, identifier:text; 117, identifier:start_only; 118, None; 119, for_statement; 119, 120; 119, 121; 119, 125; 120, identifier:item; 121, call; 121, 122; 121, 123; 122, identifier:sorted; 123, argument_list; 123, 124; 124, identifier:collection; 125, block; 125, 126; 125, 141; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:match_point; 129, call; 129, 130; 129, 137; 130, attribute; 130, 131; 130, 136; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:item; 134, identifier:lower; 135, argument_list; 136, identifier:find; 137, argument_list; 137, 138; 137, 139; 137, 140; 138, identifier:text; 139, integer:0; 140, identifier:match_end_limit; 141, if_statement; 141, 142; 141, 145; 142, comparison_operator:>=; 142, 143; 142, 144; 143, identifier:match_point; 144, integer:0; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:completions; 150, identifier:append; 151, argument_list; 151, 152; 152, tuple; 152, 153; 152, 157; 152, 158; 153, call; 153, 154; 153, 155; 154, identifier:len; 155, argument_list; 155, 156; 156, identifier:text; 157, identifier:match_point; 158, identifier:item; 159, if_statement; 159, 160; 159, 163; 160, comparison_operator:==; 160, 161; 160, 162; 161, identifier:casing; 162, string:'auto'; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:casing; 167, conditional_expression:if; 167, 168; 167, 169; 167, 179; 168, string:'lower'; 169, boolean_operator:and; 169, 170; 169, 171; 170, identifier:last; 171, call; 171, 172; 171, 178; 172, attribute; 172, 173; 172, 177; 173, subscript; 173, 174; 173, 175; 174, identifier:last; 175, unary_operator:-; 175, 176; 176, integer:1; 177, identifier:islower; 178, argument_list; 179, string:'upper'; 180, function_definition; 180, 181; 180, 182; 180, 184; 181, function_name:apply_case; 182, parameters; 182, 183; 183, identifier:kw; 184, block; 184, 185; 184, 196; 185, if_statement; 185, 186; 185, 189; 186, comparison_operator:==; 186, 187; 186, 188; 187, identifier:casing; 188, string:'upper'; 189, block; 189, 190; 190, return_statement; 190, 191; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:kw; 194, identifier:upper; 195, argument_list; 196, return_statement; 196, 197; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:kw; 200, identifier:lower; 201, argument_list; 202, return_statement; 202, 203; 203, generator_expression; 203, 204; 203, 221; 204, call; 204, 205; 204, 206; 205, identifier:Completion; 206, argument_list; 206, 207; 206, 216; 207, conditional_expression:if; 207, 208; 207, 209; 207, 212; 208, identifier:z; 209, comparison_operator:is; 209, 210; 209, 211; 210, identifier:casing; 211, None; 212, call; 212, 213; 212, 214; 213, identifier:apply_case; 214, argument_list; 214, 215; 215, identifier:z; 216, unary_operator:-; 216, 217; 217, call; 217, 218; 217, 219; 218, identifier:len; 219, argument_list; 219, 220; 220, identifier:text; 221, for_in_clause; 221, 222; 221, 226; 222, pattern_list; 222, 223; 222, 224; 222, 225; 223, identifier:x; 224, identifier:y; 225, identifier:z; 226, call; 226, 227; 226, 228; 227, identifier:sorted; 228, argument_list; 228, 229; 229, identifier:completions | def find_matches(text, collection, start_only=False, fuzzy=True, casing=None):
last = last_word(text, include='most_punctuations')
text = last.lower()
completions = []
if fuzzy:
regex = '.*?'.join(map(escape, text))
pat = compile('(%s)' % regex)
for item in sorted(collection):
r = pat.search(item.lower())
if r:
completions.append((len(r.group()), r.start(), item))
else:
match_end_limit = len(text) if start_only else None
for item in sorted(collection):
match_point = item.lower().find(text, 0, match_end_limit)
if match_point >= 0:
completions.append((len(text), match_point, item))
if casing == 'auto':
casing = 'lower' if last and last[-1].islower() else 'upper'
def apply_case(kw):
if casing == 'upper':
return kw.upper()
return kw.lower()
return (Completion(z if casing is None else apply_case(z), -len(text))
for x, y, z in sorted(completions)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:cli_bindings; 3, parameters; 4, block; 4, 5; 4, 26; 4, 71; 4, 112; 4, 169; 4, 225; 4, 281; 4, 332; 5, expression_statement; 5, 6; 6, assignment; 6, 7; 6, 8; 7, identifier:key_binding_manager; 8, call; 8, 9; 8, 10; 9, identifier:KeyBindingManager; 10, argument_list; 10, 11; 10, 14; 10, 17; 10, 20; 10, 23; 11, keyword_argument; 11, 12; 11, 13; 12, identifier:enable_open_in_editor; 13, True; 14, keyword_argument; 14, 15; 14, 16; 15, identifier:enable_system_bindings; 16, True; 17, keyword_argument; 17, 18; 17, 19; 18, identifier:enable_auto_suggest_bindings; 19, True; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:enable_search; 22, True; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:enable_abort_and_exit_bindings; 25, True; 26, decorated_definition; 26, 27; 26, 38; 27, decorator; 27, 28; 28, call; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:key_binding_manager; 32, identifier:registry; 33, identifier:add_binding; 34, argument_list; 34, 35; 35, attribute; 35, 36; 35, 37; 36, identifier:Keys; 37, identifier:F2; 38, function_definition; 38, 39; 38, 40; 38, 42; 39, function_name:_; 40, parameters; 40, 41; 41, identifier:event; 42, block; 42, 43; 42, 50; 42, 58; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:_logger; 47, identifier:debug; 48, argument_list; 48, 49; 49, string:'Detected F2 key.'; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:buf; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:event; 56, identifier:cli; 57, identifier:current_buffer; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 65; 60, attribute; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:buf; 63, identifier:completer; 64, identifier:smart_completion; 65, not_operator; 65, 66; 66, attribute; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:buf; 69, identifier:completer; 70, identifier:smart_completion; 71, decorated_definition; 71, 72; 71, 83; 72, decorator; 72, 73; 73, call; 73, 74; 73, 79; 74, attribute; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:key_binding_manager; 77, identifier:registry; 78, identifier:add_binding; 79, argument_list; 79, 80; 80, attribute; 80, 81; 80, 82; 81, identifier:Keys; 82, identifier:F3; 83, function_definition; 83, 84; 83, 85; 83, 87; 84, function_name:_; 85, parameters; 85, 86; 86, identifier:event; 87, block; 87, 88; 87, 95; 87, 103; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:_logger; 92, identifier:debug; 93, argument_list; 93, 94; 94, string:'Detected F3 key.'; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:buf; 98, attribute; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:event; 101, identifier:cli; 102, identifier:current_buffer; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:buf; 107, identifier:always_multiline; 108, not_operator; 108, 109; 109, attribute; 109, 110; 109, 111; 110, identifier:buf; 111, identifier:always_multiline; 112, decorated_definition; 112, 113; 112, 124; 113, decorator; 113, 114; 114, call; 114, 115; 114, 120; 115, attribute; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:key_binding_manager; 118, identifier:registry; 119, identifier:add_binding; 120, argument_list; 120, 121; 121, attribute; 121, 122; 121, 123; 122, identifier:Keys; 123, identifier:F4; 124, function_definition; 124, 125; 124, 126; 124, 128; 125, function_name:_; 126, parameters; 126, 127; 127, identifier:event; 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:_logger; 133, identifier:debug; 134, argument_list; 134, 135; 135, string:'Detected F4 key.'; 136, if_statement; 136, 137; 136, 146; 136, 157; 137, comparison_operator:==; 137, 138; 137, 143; 138, attribute; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:event; 141, identifier:cli; 142, identifier:editing_mode; 143, attribute; 143, 144; 143, 145; 144, identifier:EditingMode; 145, identifier:VI; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 154; 149, attribute; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:event; 152, identifier:cli; 153, identifier:editing_mode; 154, attribute; 154, 155; 154, 156; 155, identifier:EditingMode; 156, identifier:EMACS; 157, else_clause; 157, 158; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 166; 161, attribute; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:event; 164, identifier:cli; 165, identifier:editing_mode; 166, attribute; 166, 167; 166, 168; 167, identifier:EditingMode; 168, identifier:VI; 169, decorated_definition; 169, 170; 169, 181; 170, decorator; 170, 171; 171, call; 171, 172; 171, 177; 172, attribute; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:key_binding_manager; 175, identifier:registry; 176, identifier:add_binding; 177, argument_list; 177, 178; 178, attribute; 178, 179; 178, 180; 179, identifier:Keys; 180, identifier:Tab; 181, function_definition; 181, 182; 181, 183; 181, 185; 182, function_name:_; 183, parameters; 183, 184; 184, identifier:event; 185, block; 185, 186; 185, 193; 185, 201; 186, expression_statement; 186, 187; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:_logger; 190, identifier:debug; 191, argument_list; 191, 192; 192, string:'Detected <Tab> key.'; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:b; 196, attribute; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:event; 199, identifier:cli; 200, identifier:current_buffer; 201, if_statement; 201, 202; 201, 205; 201, 212; 202, attribute; 202, 203; 202, 204; 203, identifier:b; 204, identifier:complete_state; 205, block; 205, 206; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:b; 210, identifier:complete_next; 211, argument_list; 212, else_clause; 212, 213; 213, block; 213, 214; 214, expression_statement; 214, 215; 215, call; 215, 216; 215, 221; 216, attribute; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:event; 219, identifier:cli; 220, identifier:start_completion; 221, argument_list; 221, 222; 222, keyword_argument; 222, 223; 222, 224; 223, identifier:select_first; 224, True; 225, decorated_definition; 225, 226; 225, 237; 226, decorator; 226, 227; 227, call; 227, 228; 227, 233; 228, attribute; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:key_binding_manager; 231, identifier:registry; 232, identifier:add_binding; 233, argument_list; 233, 234; 234, attribute; 234, 235; 234, 236; 235, identifier:Keys; 236, identifier:ControlSpace; 237, function_definition; 237, 238; 237, 239; 237, 241; 238, function_name:_; 239, parameters; 239, 240; 240, identifier:event; 241, block; 241, 242; 241, 249; 241, 257; 242, expression_statement; 242, 243; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:_logger; 246, identifier:debug; 247, argument_list; 247, 248; 248, string:'Detected <C-Space> key.'; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:b; 252, attribute; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:event; 255, identifier:cli; 256, identifier:current_buffer; 257, if_statement; 257, 258; 257, 261; 257, 268; 258, attribute; 258, 259; 258, 260; 259, identifier:b; 260, identifier:complete_state; 261, block; 261, 262; 262, expression_statement; 262, 263; 263, call; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:b; 266, identifier:complete_next; 267, argument_list; 268, else_clause; 268, 269; 269, block; 269, 270; 270, expression_statement; 270, 271; 271, call; 271, 272; 271, 277; 272, attribute; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:event; 275, identifier:cli; 276, identifier:start_completion; 277, argument_list; 277, 278; 278, keyword_argument; 278, 279; 278, 280; 279, identifier:select_first; 280, False; 281, decorated_definition; 281, 282; 281, 298; 282, decorator; 282, 283; 283, call; 283, 284; 283, 289; 284, attribute; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:key_binding_manager; 287, identifier:registry; 288, identifier:add_binding; 289, argument_list; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:Keys; 292, identifier:ControlJ; 293, keyword_argument; 293, 294; 293, 295; 294, identifier:filter; 295, call; 295, 296; 295, 297; 296, identifier:HasSelectedCompletion; 297, argument_list; 298, function_definition; 298, 299; 298, 300; 298, 302; 299, function_name:_; 300, parameters; 300, 301; 301, identifier:event; 302, block; 302, 303; 302, 310; 302, 318; 302, 326; 303, expression_statement; 303, 304; 304, call; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:_logger; 307, identifier:debug; 308, argument_list; 308, 309; 309, string:'Detected <C-J> key.'; 310, expression_statement; 310, 311; 311, assignment; 311, 312; 311, 317; 312, attribute; 312, 313; 312, 316; 313, attribute; 313, 314; 313, 315; 314, identifier:event; 315, identifier:current_buffer; 316, identifier:complete_state; 317, None; 318, expression_statement; 318, 319; 319, assignment; 319, 320; 319, 321; 320, identifier:b; 321, attribute; 321, 322; 321, 325; 322, attribute; 322, 323; 322, 324; 323, identifier:event; 324, identifier:cli; 325, identifier:current_buffer; 326, expression_statement; 326, 327; 327, assignment; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:b; 330, identifier:complete_state; 331, None; 332, return_statement; 332, 333; 333, identifier:key_binding_manager | def cli_bindings():
key_binding_manager = KeyBindingManager(
enable_open_in_editor=True,
enable_system_bindings=True,
enable_auto_suggest_bindings=True,
enable_search=True,
enable_abort_and_exit_bindings=True)
@key_binding_manager.registry.add_binding(Keys.F2)
def _(event):
_logger.debug('Detected F2 key.')
buf = event.cli.current_buffer
buf.completer.smart_completion = not buf.completer.smart_completion
@key_binding_manager.registry.add_binding(Keys.F3)
def _(event):
_logger.debug('Detected F3 key.')
buf = event.cli.current_buffer
buf.always_multiline = not buf.always_multiline
@key_binding_manager.registry.add_binding(Keys.F4)
def _(event):
_logger.debug('Detected F4 key.')
if event.cli.editing_mode == EditingMode.VI:
event.cli.editing_mode = EditingMode.EMACS
else:
event.cli.editing_mode = EditingMode.VI
@key_binding_manager.registry.add_binding(Keys.Tab)
def _(event):
_logger.debug('Detected <Tab> key.')
b = event.cli.current_buffer
if b.complete_state:
b.complete_next()
else:
event.cli.start_completion(select_first=True)
@key_binding_manager.registry.add_binding(Keys.ControlSpace)
def _(event):
_logger.debug('Detected <C-Space> key.')
b = event.cli.current_buffer
if b.complete_state:
b.complete_next()
else:
event.cli.start_completion(select_first=False)
@key_binding_manager.registry.add_binding(Keys.ControlJ, filter=HasSelectedCompletion())
def _(event):
_logger.debug('Detected <C-J> key.')
event.current_buffer.complete_state = None
b = event.cli.current_buffer
b.complete_state = None
return key_binding_manager |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_get_thumbnail_options; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:context; 6, identifier:instance; 7, block; 7, 8; 7, 16; 7, 20; 7, 30; 7, 40; 7, 54; 7, 79; 7, 90; 7, 202; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 13; 10, pattern_list; 10, 11; 10, 12; 11, identifier:width; 12, identifier:height; 13, expression_list; 13, 14; 13, 15; 14, None; 15, None; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:subject_location; 19, False; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:placeholder_width; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:context; 26, identifier:get; 27, argument_list; 27, 28; 27, 29; 28, string:'width'; 29, None; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:placeholder_height; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:context; 36, identifier:get; 37, argument_list; 37, 38; 37, 39; 38, string:'height'; 39, None; 40, if_statement; 40, 41; 40, 46; 41, boolean_operator:and; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:instance; 44, identifier:use_autoscale; 45, identifier:placeholder_width; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:width; 50, call; 50, 51; 50, 52; 51, identifier:int; 52, argument_list; 52, 53; 53, identifier:placeholder_width; 54, if_statement; 54, 55; 54, 60; 54, 68; 55, boolean_operator:and; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:instance; 58, identifier:use_autoscale; 59, identifier:placeholder_height; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:height; 64, call; 64, 65; 64, 66; 65, identifier:int; 66, argument_list; 66, 67; 67, identifier:placeholder_height; 68, elif_clause; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:instance; 71, identifier:width; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:width; 76, attribute; 76, 77; 76, 78; 77, identifier:instance; 78, identifier:width; 79, if_statement; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:instance; 82, identifier:height; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:height; 87, attribute; 87, 88; 87, 89; 88, identifier:instance; 89, identifier:height; 90, if_statement; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:instance; 93, identifier:image; 94, block; 94, 95; 94, 110; 94, 144; 94, 178; 94, 190; 95, if_statement; 95, 96; 95, 101; 96, attribute; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:instance; 99, identifier:image; 100, identifier:subject_location; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:subject_location; 105, attribute; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:instance; 108, identifier:image; 109, identifier:subject_location; 110, if_statement; 110, 111; 110, 115; 111, boolean_operator:and; 111, 112; 111, 114; 112, not_operator; 112, 113; 113, identifier:height; 114, identifier:width; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:height; 119, call; 119, 120; 119, 121; 120, identifier:int; 121, argument_list; 121, 122; 122, binary_operator:/; 122, 123; 122, 136; 123, binary_operator:*; 123, 124; 123, 128; 124, call; 124, 125; 124, 126; 125, identifier:float; 126, argument_list; 126, 127; 127, identifier:width; 128, call; 128, 129; 128, 130; 129, identifier:float; 130, argument_list; 130, 131; 131, attribute; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:instance; 134, identifier:image; 135, identifier:height; 136, call; 136, 137; 136, 138; 137, identifier:float; 138, argument_list; 138, 139; 139, attribute; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:instance; 142, identifier:image; 143, identifier:width; 144, if_statement; 144, 145; 144, 149; 145, boolean_operator:and; 145, 146; 145, 148; 146, not_operator; 146, 147; 147, identifier:width; 148, identifier:height; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:width; 153, call; 153, 154; 153, 155; 154, identifier:int; 155, argument_list; 155, 156; 156, binary_operator:/; 156, 157; 156, 170; 157, binary_operator:*; 157, 158; 157, 162; 158, call; 158, 159; 158, 160; 159, identifier:float; 160, argument_list; 160, 161; 161, identifier:height; 162, call; 162, 163; 162, 164; 163, identifier:float; 164, argument_list; 164, 165; 165, attribute; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:instance; 168, identifier:image; 169, identifier:width; 170, call; 170, 171; 170, 172; 171, identifier:float; 172, argument_list; 172, 173; 173, attribute; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:instance; 176, identifier:image; 177, identifier:height; 178, if_statement; 178, 179; 178, 181; 179, not_operator; 179, 180; 180, identifier:width; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:width; 185, attribute; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:instance; 188, identifier:image; 189, identifier:width; 190, if_statement; 190, 191; 190, 193; 191, not_operator; 191, 192; 192, identifier:height; 193, block; 193, 194; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:height; 197, attribute; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:instance; 200, identifier:image; 201, identifier:height; 202, return_statement; 202, 203; 203, dictionary; 203, 204; 203, 209; 204, pair; 204, 205; 204, 206; 205, string:'size'; 206, tuple; 206, 207; 206, 208; 207, identifier:width; 208, identifier:height; 209, pair; 209, 210; 209, 211; 210, string:'subject_location'; 211, identifier:subject_location | def _get_thumbnail_options(self, context, instance):
width, height = None, None
subject_location = False
placeholder_width = context.get('width', None)
placeholder_height = context.get('height', None)
if instance.use_autoscale and placeholder_width:
width = int(placeholder_width)
if instance.use_autoscale and placeholder_height:
height = int(placeholder_height)
elif instance.width:
width = instance.width
if instance.height:
height = instance.height
if instance.image:
if instance.image.subject_location:
subject_location = instance.image.subject_location
if not height and width:
height = int(float(width) * float(instance.image.height) / float(instance.image.width))
if not width and height:
width = int(float(height) * float(instance.image.width) / float(instance.image.height))
if not width:
width = instance.image.width
if not height:
height = instance.image.height
return {'size': (width, height),
'subject_location': subject_location} |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:group_and_sort_statements; 3, parameters; 3, 4; 3, 5; 4, identifier:stmt_list; 5, default_parameter; 5, 6; 5, 7; 6, identifier:ev_totals; 7, None; 8, block; 8, 9; 8, 36; 8, 43; 8, 51; 8, 59; 8, 135; 8, 267; 8, 288; 9, function_definition; 9, 10; 9, 11; 9, 13; 10, function_name:_count; 11, parameters; 11, 12; 12, identifier:stmt; 13, block; 13, 14; 14, if_statement; 14, 15; 14, 18; 14, 26; 15, comparison_operator:is; 15, 16; 15, 17; 16, identifier:ev_totals; 17, None; 18, block; 18, 19; 19, return_statement; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:len; 22, argument_list; 22, 23; 23, attribute; 23, 24; 23, 25; 24, identifier:stmt; 25, identifier:evidence; 26, else_clause; 26, 27; 27, block; 27, 28; 28, return_statement; 28, 29; 29, subscript; 29, 30; 29, 31; 30, identifier:ev_totals; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:stmt; 34, identifier:get_hash; 35, argument_list; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:stmt_rows; 39, call; 39, 40; 39, 41; 40, identifier:defaultdict; 41, argument_list; 41, 42; 42, identifier:list; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:stmt_counts; 46, call; 46, 47; 46, 48; 47, identifier:defaultdict; 48, argument_list; 48, 49; 49, lambda; 49, 50; 50, integer:0; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:arg_counts; 54, call; 54, 55; 54, 56; 55, identifier:defaultdict; 56, argument_list; 56, 57; 57, lambda; 57, 58; 58, integer:0; 59, for_statement; 59, 60; 59, 63; 59, 67; 60, pattern_list; 60, 61; 60, 62; 61, identifier:key; 62, identifier:s; 63, call; 63, 64; 63, 65; 64, identifier:_get_keyed_stmts; 65, argument_list; 65, 66; 66, identifier:stmt_list; 67, block; 67, 68; 67, 77; 67, 86; 68, expression_statement; 68, 69; 69, call; 69, 70; 69, 75; 70, attribute; 70, 71; 70, 74; 71, subscript; 71, 72; 71, 73; 72, identifier:stmt_rows; 73, identifier:key; 74, identifier:append; 75, argument_list; 75, 76; 76, identifier:s; 77, expression_statement; 77, 78; 78, augmented_assignment:+=; 78, 79; 78, 82; 79, subscript; 79, 80; 79, 81; 80, identifier:stmt_counts; 81, identifier:key; 82, call; 82, 83; 82, 84; 83, identifier:_count; 84, argument_list; 84, 85; 85, identifier:s; 86, if_statement; 86, 87; 86, 92; 86, 120; 87, comparison_operator:==; 87, 88; 87, 91; 88, subscript; 88, 89; 88, 90; 89, identifier:key; 90, integer:0; 91, string:'Conversion'; 92, block; 92, 93; 92, 99; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:subj; 96, subscript; 96, 97; 96, 98; 97, identifier:key; 98, integer:1; 99, for_statement; 99, 100; 99, 101; 99, 108; 100, identifier:obj; 101, binary_operator:+; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:key; 104, integer:2; 105, subscript; 105, 106; 105, 107; 106, identifier:key; 107, integer:3; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, augmented_assignment:+=; 110, 111; 110, 116; 111, subscript; 111, 112; 111, 113; 112, identifier:arg_counts; 113, tuple; 113, 114; 113, 115; 114, identifier:subj; 115, identifier:obj; 116, call; 116, 117; 116, 118; 117, identifier:_count; 118, argument_list; 118, 119; 119, identifier:s; 120, else_clause; 120, 121; 121, block; 121, 122; 122, expression_statement; 122, 123; 123, augmented_assignment:+=; 123, 124; 123, 131; 124, subscript; 124, 125; 124, 126; 125, identifier:arg_counts; 126, subscript; 126, 127; 126, 128; 127, identifier:key; 128, slice; 128, 129; 128, 130; 129, integer:1; 130, colon; 131, call; 131, 132; 131, 133; 132, identifier:_count; 133, argument_list; 133, 134; 134, identifier:s; 135, function_definition; 135, 136; 135, 137; 135, 139; 136, function_name:process_rows; 137, parameters; 137, 138; 138, identifier:stmt_rows; 139, block; 139, 140; 140, for_statement; 140, 141; 140, 144; 140, 149; 141, pattern_list; 141, 142; 141, 143; 142, identifier:key; 143, identifier:stmts; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:stmt_rows; 147, identifier:items; 148, argument_list; 149, block; 149, 150; 149, 156; 149, 164; 149, 170; 149, 176; 149, 220; 149, 228; 149, 261; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:verb; 153, subscript; 153, 154; 153, 155; 154, identifier:key; 155, integer:0; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:inps; 159, subscript; 159, 160; 159, 161; 160, identifier:key; 161, slice; 161, 162; 161, 163; 162, integer:1; 163, colon; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:sub_count; 167, subscript; 167, 168; 167, 169; 168, identifier:stmt_counts; 169, identifier:key; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:arg_count; 173, subscript; 173, 174; 173, 175; 174, identifier:arg_counts; 175, identifier:inps; 176, if_statement; 176, 177; 176, 191; 177, boolean_operator:and; 177, 178; 177, 185; 178, boolean_operator:and; 178, 179; 178, 182; 179, comparison_operator:==; 179, 180; 179, 181; 180, identifier:verb; 181, string:'Complex'; 182, comparison_operator:==; 182, 183; 182, 184; 183, identifier:sub_count; 184, identifier:arg_count; 185, comparison_operator:<=; 185, 186; 185, 190; 186, call; 186, 187; 186, 188; 187, identifier:len; 188, argument_list; 188, 189; 189, identifier:inps; 190, integer:2; 191, block; 191, 192; 192, if_statement; 192, 193; 192, 218; 193, call; 193, 194; 193, 195; 194, identifier:all; 195, argument_list; 195, 196; 196, list_comprehension; 196, 197; 196, 215; 197, comparison_operator:>; 197, 198; 197, 214; 198, call; 198, 199; 198, 200; 199, identifier:len; 200, argument_list; 200, 201; 201, call; 201, 202; 201, 203; 202, identifier:set; 203, generator_expression; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:ag; 206, identifier:name; 207, for_in_clause; 207, 208; 207, 209; 208, identifier:ag; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:s; 212, identifier:agent_list; 213, argument_list; 214, integer:2; 215, for_in_clause; 215, 216; 215, 217; 216, identifier:s; 217, identifier:stmts; 218, block; 218, 219; 219, continue_statement; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:new_key; 223, tuple; 223, 224; 223, 225; 223, 226; 223, 227; 224, identifier:arg_count; 225, identifier:inps; 226, identifier:sub_count; 227, identifier:verb; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:stmts; 231, call; 231, 232; 231, 233; 232, identifier:sorted; 233, argument_list; 233, 234; 233, 235; 233, 258; 234, identifier:stmts; 235, keyword_argument; 235, 236; 235, 237; 236, identifier:key; 237, lambda; 237, 238; 237, 240; 238, lambda_parameters; 238, 239; 239, identifier:s; 240, binary_operator:+; 240, 241; 240, 245; 241, call; 241, 242; 241, 243; 242, identifier:_count; 243, argument_list; 243, 244; 244, identifier:s; 245, binary_operator:/; 245, 246; 245, 247; 246, integer:1; 247, parenthesized_expression; 247, 248; 248, binary_operator:+; 248, 249; 248, 250; 249, integer:1; 250, call; 250, 251; 250, 252; 251, identifier:len; 252, argument_list; 252, 253; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:s; 256, identifier:agent_list; 257, argument_list; 258, keyword_argument; 258, 259; 258, 260; 259, identifier:reverse; 260, True; 261, expression_statement; 261, 262; 262, yield; 262, 263; 263, expression_list; 263, 264; 263, 265; 263, 266; 264, identifier:new_key; 265, identifier:verb; 266, identifier:stmts; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:sorted_groups; 270, call; 270, 271; 270, 272; 271, identifier:sorted; 272, argument_list; 272, 273; 272, 277; 272, 285; 273, call; 273, 274; 273, 275; 274, identifier:process_rows; 275, argument_list; 275, 276; 276, identifier:stmt_rows; 277, keyword_argument; 277, 278; 277, 279; 278, identifier:key; 279, lambda; 279, 280; 279, 282; 280, lambda_parameters; 280, 281; 281, identifier:tpl; 282, subscript; 282, 283; 282, 284; 283, identifier:tpl; 284, integer:0; 285, keyword_argument; 285, 286; 285, 287; 286, identifier:reverse; 287, True; 288, return_statement; 288, 289; 289, identifier:sorted_groups | def group_and_sort_statements(stmt_list, ev_totals=None):
def _count(stmt):
if ev_totals is None:
return len(stmt.evidence)
else:
return ev_totals[stmt.get_hash()]
stmt_rows = defaultdict(list)
stmt_counts = defaultdict(lambda: 0)
arg_counts = defaultdict(lambda: 0)
for key, s in _get_keyed_stmts(stmt_list):
stmt_rows[key].append(s)
stmt_counts[key] += _count(s)
if key[0] == 'Conversion':
subj = key[1]
for obj in key[2] + key[3]:
arg_counts[(subj, obj)] += _count(s)
else:
arg_counts[key[1:]] += _count(s)
def process_rows(stmt_rows):
for key, stmts in stmt_rows.items():
verb = key[0]
inps = key[1:]
sub_count = stmt_counts[key]
arg_count = arg_counts[inps]
if verb == 'Complex' and sub_count == arg_count and len(inps) <= 2:
if all([len(set(ag.name for ag in s.agent_list())) > 2
for s in stmts]):
continue
new_key = (arg_count, inps, sub_count, verb)
stmts = sorted(stmts,
key=lambda s: _count(s) + 1/(1+len(s.agent_list())),
reverse=True)
yield new_key, verb, stmts
sorted_groups = sorted(process_rows(stmt_rows),
key=lambda tpl: tpl[0], reverse=True)
return sorted_groups |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:make_stmt_from_sort_key; 3, parameters; 3, 4; 3, 5; 4, identifier:key; 5, identifier:verb; 6, block; 6, 7; 6, 28; 6, 35; 6, 44; 6, 144; 7, function_definition; 7, 8; 7, 9; 7, 11; 8, function_name:make_agent; 9, parameters; 9, 10; 10, identifier:name; 11, block; 11, 12; 11, 23; 12, if_statement; 12, 13; 12, 20; 13, boolean_operator:or; 13, 14; 13, 17; 14, comparison_operator:==; 14, 15; 14, 16; 15, identifier:name; 16, string:'None'; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:name; 19, None; 20, block; 20, 21; 21, return_statement; 21, 22; 22, None; 23, return_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:Agent; 26, argument_list; 26, 27; 27, identifier:name; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:StmtClass; 31, call; 31, 32; 31, 33; 32, identifier:get_statement_by_name; 33, argument_list; 33, 34; 34, identifier:verb; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:inps; 38, call; 38, 39; 38, 40; 39, identifier:list; 40, argument_list; 40, 41; 41, subscript; 41, 42; 41, 43; 42, identifier:key; 43, integer:1; 44, if_statement; 44, 45; 44, 48; 44, 63; 44, 100; 44, 127; 45, comparison_operator:==; 45, 46; 45, 47; 46, identifier:verb; 47, string:'Complex'; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:stmt; 52, call; 52, 53; 52, 54; 53, identifier:StmtClass; 54, argument_list; 54, 55; 55, list_comprehension; 55, 56; 55, 60; 56, call; 56, 57; 56, 58; 57, identifier:make_agent; 58, argument_list; 58, 59; 59, identifier:name; 60, for_in_clause; 60, 61; 60, 62; 61, identifier:name; 62, identifier:inps; 63, elif_clause; 63, 64; 63, 67; 64, comparison_operator:==; 64, 65; 64, 66; 65, identifier:verb; 66, string:'Conversion'; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:stmt; 71, call; 71, 72; 71, 73; 72, identifier:StmtClass; 73, argument_list; 73, 74; 73, 80; 73, 90; 74, call; 74, 75; 74, 76; 75, identifier:make_agent; 76, argument_list; 76, 77; 77, subscript; 77, 78; 77, 79; 78, identifier:inps; 79, integer:0; 80, list_comprehension; 80, 81; 80, 85; 81, call; 81, 82; 81, 83; 82, identifier:make_agent; 83, argument_list; 83, 84; 84, identifier:name; 85, for_in_clause; 85, 86; 85, 87; 86, identifier:name; 87, subscript; 87, 88; 87, 89; 88, identifier:inps; 89, integer:1; 90, list_comprehension; 90, 91; 90, 95; 91, call; 91, 92; 91, 93; 92, identifier:make_agent; 93, argument_list; 93, 94; 94, identifier:name; 95, for_in_clause; 95, 96; 95, 97; 96, identifier:name; 97, subscript; 97, 98; 97, 99; 98, identifier:inps; 99, integer:2; 100, elif_clause; 100, 101; 100, 108; 101, boolean_operator:or; 101, 102; 101, 105; 102, comparison_operator:==; 102, 103; 102, 104; 103, identifier:verb; 104, string:'ActiveForm'; 105, comparison_operator:==; 105, 106; 105, 107; 106, identifier:verb; 107, string:'HasActivity'; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:stmt; 112, call; 112, 113; 112, 114; 113, identifier:StmtClass; 114, argument_list; 114, 115; 114, 121; 114, 124; 115, call; 115, 116; 115, 117; 116, identifier:make_agent; 117, argument_list; 117, 118; 118, subscript; 118, 119; 118, 120; 119, identifier:inps; 120, integer:0; 121, subscript; 121, 122; 121, 123; 122, identifier:inps; 123, integer:1; 124, subscript; 124, 125; 124, 126; 125, identifier:inps; 126, integer:2; 127, else_clause; 127, 128; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:stmt; 132, call; 132, 133; 132, 134; 133, identifier:StmtClass; 134, argument_list; 134, 135; 135, list_splat; 135, 136; 136, list_comprehension; 136, 137; 136, 141; 137, call; 137, 138; 137, 139; 138, identifier:make_agent; 139, argument_list; 139, 140; 140, identifier:name; 141, for_in_clause; 141, 142; 141, 143; 142, identifier:name; 143, identifier:inps; 144, return_statement; 144, 145; 145, identifier:stmt | def make_stmt_from_sort_key(key, verb):
def make_agent(name):
if name == 'None' or name is None:
return None
return Agent(name)
StmtClass = get_statement_by_name(verb)
inps = list(key[1])
if verb == 'Complex':
stmt = StmtClass([make_agent(name) for name in inps])
elif verb == 'Conversion':
stmt = StmtClass(make_agent(inps[0]),
[make_agent(name) for name in inps[1]],
[make_agent(name) for name in inps[2]])
elif verb == 'ActiveForm' or verb == 'HasActivity':
stmt = StmtClass(make_agent(inps[0]), inps[1], inps[2])
else:
stmt = StmtClass(*[make_agent(name) for name in inps])
return stmt |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:print_boolean_net; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:out_file; 7, None; 8, block; 8, 9; 8, 13; 8, 41; 8, 45; 8, 259; 8, 267; 8, 291; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:init_str; 12, string:''; 13, for_statement; 13, 14; 13, 15; 13, 22; 14, identifier:node_key; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:graph; 20, identifier:nodes; 21, argument_list; 22, block; 22, 23; 22, 35; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:node_name; 26, subscript; 26, 27; 26, 34; 27, subscript; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:graph; 32, identifier:node; 33, identifier:node_key; 34, string:'name'; 35, expression_statement; 35, 36; 36, augmented_assignment:+=; 36, 37; 36, 38; 37, identifier:init_str; 38, binary_operator:%; 38, 39; 38, 40; 39, string:'%s = False\n'; 40, identifier:node_name; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:rule_str; 44, string:''; 45, for_statement; 45, 46; 45, 47; 45, 54; 46, identifier:node_key; 47, call; 47, 48; 47, 53; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:graph; 52, identifier:nodes; 53, argument_list; 54, block; 54, 55; 54, 67; 54, 78; 54, 83; 54, 93; 54, 113; 54, 131; 54, 149; 54, 153; 54, 172; 54, 181; 54, 185; 54, 204; 54, 213; 54, 247; 54, 255; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:node_name; 58, subscript; 58, 59; 58, 66; 59, subscript; 59, 60; 59, 65; 60, attribute; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:graph; 64, identifier:node; 65, identifier:node_key; 66, string:'name'; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:in_edges; 70, call; 70, 71; 70, 76; 71, attribute; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:graph; 75, identifier:in_edges; 76, argument_list; 76, 77; 77, identifier:node_key; 78, if_statement; 78, 79; 78, 81; 79, not_operator; 79, 80; 80, identifier:in_edges; 81, block; 81, 82; 82, continue_statement; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:parents; 86, list_comprehension; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:e; 89, integer:0; 90, for_in_clause; 90, 91; 90, 92; 91, identifier:e; 92, identifier:in_edges; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:polarities; 96, list_comprehension; 96, 97; 96, 110; 97, subscript; 97, 98; 97, 109; 98, subscript; 98, 99; 98, 108; 99, subscript; 99, 100; 99, 105; 100, attribute; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:graph; 104, identifier:edge; 105, subscript; 105, 106; 105, 107; 106, identifier:e; 107, integer:0; 108, identifier:node_key; 109, string:'polarity'; 110, for_in_clause; 110, 111; 110, 112; 111, identifier:e; 112, identifier:in_edges; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:pos_parents; 116, list_comprehension; 116, 117; 116, 118; 116, 127; 117, identifier:par; 118, for_in_clause; 118, 119; 118, 122; 119, pattern_list; 119, 120; 119, 121; 120, identifier:par; 121, identifier:pol; 122, call; 122, 123; 122, 124; 123, identifier:zip; 124, argument_list; 124, 125; 124, 126; 125, identifier:parents; 126, identifier:polarities; 127, if_clause; 127, 128; 128, comparison_operator:==; 128, 129; 128, 130; 129, identifier:pol; 130, string:'positive'; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:neg_parents; 134, list_comprehension; 134, 135; 134, 136; 134, 145; 135, identifier:par; 136, for_in_clause; 136, 137; 136, 140; 137, pattern_list; 137, 138; 137, 139; 138, identifier:par; 139, identifier:pol; 140, call; 140, 141; 140, 142; 141, identifier:zip; 142, argument_list; 142, 143; 142, 144; 143, identifier:parents; 144, identifier:polarities; 145, if_clause; 145, 146; 146, comparison_operator:==; 146, 147; 146, 148; 147, identifier:pol; 148, string:'negative'; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:rhs_pos_parts; 152, list:[]; 153, for_statement; 153, 154; 153, 155; 153, 156; 154, identifier:par; 155, identifier:pos_parents; 156, block; 156, 157; 157, expression_statement; 157, 158; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:rhs_pos_parts; 161, identifier:append; 162, argument_list; 162, 163; 163, subscript; 163, 164; 163, 171; 164, subscript; 164, 165; 164, 170; 165, attribute; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:graph; 169, identifier:node; 170, identifier:par; 171, string:'name'; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:rhs_pos_str; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, string:' or '; 178, identifier:join; 179, argument_list; 179, 180; 180, identifier:rhs_pos_parts; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:rhs_neg_parts; 184, list:[]; 185, for_statement; 185, 186; 185, 187; 185, 188; 186, identifier:par; 187, identifier:neg_parents; 188, block; 188, 189; 189, expression_statement; 189, 190; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:rhs_neg_parts; 193, identifier:append; 194, argument_list; 194, 195; 195, subscript; 195, 196; 195, 203; 196, subscript; 196, 197; 196, 202; 197, attribute; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:self; 200, identifier:graph; 201, identifier:node; 202, identifier:par; 203, string:'name'; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:rhs_neg_str; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, string:' or '; 210, identifier:join; 211, argument_list; 211, 212; 212, identifier:rhs_neg_parts; 213, if_statement; 213, 214; 213, 215; 213, 237; 214, identifier:rhs_pos_str; 215, block; 215, 216; 216, if_statement; 216, 217; 216, 218; 216, 231; 217, identifier:rhs_neg_str; 218, block; 218, 219; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:rhs_str; 222, binary_operator:+; 222, 223; 222, 230; 223, binary_operator:+; 223, 224; 223, 229; 224, binary_operator:+; 224, 225; 224, 228; 225, binary_operator:+; 225, 226; 225, 227; 226, string:'('; 227, identifier:rhs_pos_str; 228, string:') and not ('; 229, identifier:rhs_neg_str; 230, string:')'; 231, else_clause; 231, 232; 232, block; 232, 233; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:rhs_str; 236, identifier:rhs_pos_str; 237, else_clause; 237, 238; 238, block; 238, 239; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 242; 241, identifier:rhs_str; 242, binary_operator:+; 242, 243; 242, 246; 243, binary_operator:+; 243, 244; 243, 245; 244, string:'not ('; 245, identifier:rhs_neg_str; 246, string:')'; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:node_eq; 250, binary_operator:%; 250, 251; 250, 252; 251, string:'%s* = %s\n'; 252, tuple; 252, 253; 252, 254; 253, identifier:node_name; 254, identifier:rhs_str; 255, expression_statement; 255, 256; 256, augmented_assignment:+=; 256, 257; 256, 258; 257, identifier:rule_str; 258, identifier:node_eq; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:full_str; 262, binary_operator:+; 262, 263; 262, 266; 263, binary_operator:+; 263, 264; 263, 265; 264, identifier:init_str; 265, string:'\n'; 266, identifier:rule_str; 267, if_statement; 267, 268; 267, 271; 268, comparison_operator:is; 268, 269; 268, 270; 269, identifier:out_file; 270, None; 271, block; 271, 272; 272, with_statement; 272, 273; 272, 283; 273, with_clause; 273, 274; 274, with_item; 274, 275; 275, as_pattern; 275, 276; 275, 281; 276, call; 276, 277; 276, 278; 277, identifier:open; 278, argument_list; 278, 279; 278, 280; 279, identifier:out_file; 280, string:'wt'; 281, as_pattern_target; 281, 282; 282, identifier:fh; 283, block; 283, 284; 284, expression_statement; 284, 285; 285, call; 285, 286; 285, 289; 286, attribute; 286, 287; 286, 288; 287, identifier:fh; 288, identifier:write; 289, argument_list; 289, 290; 290, identifier:full_str; 291, return_statement; 291, 292; 292, identifier:full_str | def print_boolean_net(self, out_file=None):
init_str = ''
for node_key in self.graph.nodes():
node_name = self.graph.node[node_key]['name']
init_str += '%s = False\n' % node_name
rule_str = ''
for node_key in self.graph.nodes():
node_name = self.graph.node[node_key]['name']
in_edges = self.graph.in_edges(node_key)
if not in_edges:
continue
parents = [e[0] for e in in_edges]
polarities = [self.graph.edge[e[0]][node_key]['polarity']
for e in in_edges]
pos_parents = [par for par, pol in zip(parents, polarities) if
pol == 'positive']
neg_parents = [par for par, pol in zip(parents, polarities) if
pol == 'negative']
rhs_pos_parts = []
for par in pos_parents:
rhs_pos_parts.append(self.graph.node[par]['name'])
rhs_pos_str = ' or '.join(rhs_pos_parts)
rhs_neg_parts = []
for par in neg_parents:
rhs_neg_parts.append(self.graph.node[par]['name'])
rhs_neg_str = ' or '.join(rhs_neg_parts)
if rhs_pos_str:
if rhs_neg_str:
rhs_str = '(' + rhs_pos_str + \
') and not (' + rhs_neg_str + ')'
else:
rhs_str = rhs_pos_str
else:
rhs_str = 'not (' + rhs_neg_str + ')'
node_eq = '%s* = %s\n' % (node_name, rhs_str)
rule_str += node_eq
full_str = init_str + '\n' + rule_str
if out_file is not None:
with open(out_file, 'wt') as fh:
fh.write(full_str)
return full_str |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_get_complex_agents; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:complex_id; 6, block; 6, 7; 6, 11; 6, 20; 6, 146; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:agents; 10, list:[]; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:components; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:_recursively_lookup_complex; 18, argument_list; 18, 19; 19, identifier:complex_id; 20, for_statement; 20, 21; 20, 22; 20, 23; 21, identifier:c; 22, identifier:components; 23, block; 23, 24; 23, 28; 23, 37; 23, 74; 23, 80; 23, 128; 23, 133; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:db_refs; 27, dictionary; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:name; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:uniprot_client; 34, identifier:get_gene_name; 35, argument_list; 35, 36; 36, identifier:c; 37, if_statement; 37, 38; 37, 41; 37, 48; 38, comparison_operator:is; 38, 39; 38, 40; 39, identifier:name; 40, None; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 47; 44, subscript; 44, 45; 44, 46; 45, identifier:db_refs; 46, string:'SIGNOR'; 47, identifier:c; 48, else_clause; 48, 49; 49, block; 49, 50; 49, 56; 49, 65; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 55; 52, subscript; 52, 53; 52, 54; 53, identifier:db_refs; 54, string:'UP'; 55, identifier:c; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:hgnc_id; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:hgnc_client; 62, identifier:get_hgnc_id; 63, argument_list; 63, 64; 64, identifier:name; 65, if_statement; 65, 66; 65, 67; 66, identifier:hgnc_id; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 73; 70, subscript; 70, 71; 70, 72; 71, identifier:db_refs; 72, string:'HGNC'; 73, identifier:hgnc_id; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:famplex_key; 77, tuple; 77, 78; 77, 79; 78, string:'SIGNOR'; 79, identifier:c; 80, if_statement; 80, 81; 80, 84; 80, 103; 81, comparison_operator:in; 81, 82; 81, 83; 82, identifier:famplex_key; 83, identifier:famplex_map; 84, block; 84, 85; 84, 93; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:db_refs; 89, string:'FPLX'; 90, subscript; 90, 91; 90, 92; 91, identifier:famplex_map; 92, identifier:famplex_key; 93, if_statement; 93, 94; 93, 96; 94, not_operator; 94, 95; 95, identifier:name; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:name; 100, subscript; 100, 101; 100, 102; 101, identifier:db_refs; 102, string:'FPLX'; 103, elif_clause; 103, 104; 103, 106; 104, not_operator; 104, 105; 105, identifier:name; 106, block; 106, 107; 106, 118; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:logger; 111, identifier:info; 112, argument_list; 112, 113; 113, binary_operator:+; 113, 114; 113, 117; 114, binary_operator:+; 114, 115; 114, 116; 115, string:'Have neither a Uniprot nor Famplex grounding '; 116, string:'for '; 117, identifier:c; 118, if_statement; 118, 119; 118, 121; 119, not_operator; 119, 120; 120, identifier:name; 121, block; 121, 122; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:name; 125, subscript; 125, 126; 125, 127; 126, identifier:db_refs; 127, string:'SIGNOR'; 128, assert_statement; 128, 129; 129, parenthesized_expression; 129, 130; 130, comparison_operator:is; 130, 131; 130, 132; 131, identifier:name; 132, None; 133, expression_statement; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:agents; 137, identifier:append; 138, argument_list; 138, 139; 139, call; 139, 140; 139, 141; 140, identifier:Agent; 141, argument_list; 141, 142; 141, 143; 142, identifier:name; 143, keyword_argument; 143, 144; 143, 145; 144, identifier:db_refs; 145, identifier:db_refs; 146, return_statement; 146, 147; 147, identifier:agents | def _get_complex_agents(self, complex_id):
agents = []
components = self._recursively_lookup_complex(complex_id)
for c in components:
db_refs = {}
name = uniprot_client.get_gene_name(c)
if name is None:
db_refs['SIGNOR'] = c
else:
db_refs['UP'] = c
hgnc_id = hgnc_client.get_hgnc_id(name)
if hgnc_id:
db_refs['HGNC'] = hgnc_id
famplex_key = ('SIGNOR', c)
if famplex_key in famplex_map:
db_refs['FPLX'] = famplex_map[famplex_key]
if not name:
name = db_refs['FPLX']
elif not name:
logger.info('Have neither a Uniprot nor Famplex grounding ' + \
'for ' + c)
if not name:
name = db_refs['SIGNOR']
assert(name is not None)
agents.append(Agent(name, db_refs=db_refs))
return agents |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_args; 3, parameters; 3, 4; 4, identifier:node; 5, block; 5, 6; 5, 10; 5, 40; 5, 81; 5, 162; 5, 171; 5, 192; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:arg_roles; 9, dictionary; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:args; 13, binary_operator:+; 13, 14; 13, 20; 13, 21; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:node; 17, identifier:findall; 18, argument_list; 18, 19; 19, string:'arg'; 20, line_continuation:\; 21, list:[node.find('arg1'), node.find('arg2'), node.find('arg3')]; 21, 22; 21, 28; 21, 34; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:node; 25, identifier:find; 26, argument_list; 26, 27; 27, string:'arg1'; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:node; 31, identifier:find; 32, argument_list; 32, 33; 33, string:'arg2'; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:node; 37, identifier:find; 38, argument_list; 38, 39; 39, string:'arg3'; 40, for_statement; 40, 41; 40, 42; 40, 43; 41, identifier:arg; 42, identifier:args; 43, block; 43, 44; 44, if_statement; 44, 45; 44, 48; 45, comparison_operator:is; 45, 46; 45, 47; 46, identifier:arg; 47, None; 48, block; 48, 49; 48, 60; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:id; 52, call; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:arg; 56, identifier:attrib; 57, identifier:get; 58, argument_list; 58, 59; 59, string:'id'; 60, if_statement; 60, 61; 60, 64; 61, comparison_operator:is; 61, 62; 61, 63; 62, identifier:id; 63, None; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 74; 67, subscript; 67, 68; 67, 69; 68, identifier:arg_roles; 69, subscript; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:arg; 72, identifier:attrib; 73, string:'role'; 74, tuple; 74, 75; 74, 80; 75, subscript; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:arg; 78, identifier:attrib; 79, string:'id'; 80, identifier:arg; 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:node; 86, identifier:find; 87, argument_list; 87, 88; 88, string:'features'; 89, None; 90, block; 90, 91; 90, 100; 90, 123; 90, 139; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:inevents; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:node; 97, identifier:findall; 98, argument_list; 98, 99; 99, string:'features/inevent'; 100, for_statement; 100, 101; 100, 102; 100, 103; 101, identifier:inevent; 102, identifier:inevents; 103, block; 103, 104; 104, if_statement; 104, 105; 104, 110; 105, comparison_operator:in; 105, 106; 105, 107; 106, string:'id'; 107, attribute; 107, 108; 107, 109; 108, identifier:inevent; 109, identifier:attrib; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 116; 113, subscript; 113, 114; 113, 115; 114, identifier:arg_roles; 115, string:'inevent'; 116, tuple; 116, 117; 116, 122; 117, subscript; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:inevent; 120, identifier:attrib; 121, string:'id'; 122, identifier:inevent; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:ptms; 126, binary_operator:+; 126, 127; 126, 133; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:node; 130, identifier:findall; 131, argument_list; 131, 132; 132, string:'features/ptm'; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:node; 136, identifier:findall; 137, argument_list; 137, 138; 138, string:'features/no-ptm'; 139, for_statement; 139, 140; 139, 141; 139, 142; 140, identifier:ptm; 141, identifier:ptms; 142, block; 142, 143; 143, if_statement; 143, 144; 143, 149; 144, comparison_operator:in; 144, 145; 144, 146; 145, string:'id'; 146, attribute; 146, 147; 146, 148; 147, identifier:inevent; 148, identifier:attrib; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 155; 152, subscript; 152, 153; 152, 154; 153, identifier:arg_roles; 154, string:'ptm'; 155, tuple; 155, 156; 155, 161; 156, subscript; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:inevent; 159, identifier:attrib; 160, string:'id'; 161, identifier:ptm; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:aw; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:node; 168, identifier:find; 169, argument_list; 169, 170; 170, string:'assoc-with'; 171, if_statement; 171, 172; 171, 175; 172, comparison_operator:is; 172, 173; 172, 174; 173, identifier:aw; 174, None; 175, block; 175, 176; 175, 184; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:aw_id; 179, subscript; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:aw; 182, identifier:attrib; 183, string:'id'; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 189; 186, subscript; 186, 187; 186, 188; 187, identifier:arg_roles; 188, string:'assoc-with'; 189, tuple; 189, 190; 189, 191; 190, identifier:aw_id; 191, identifier:aw; 192, return_statement; 192, 193; 193, identifier:arg_roles | def get_args(node):
arg_roles = {}
args = node.findall('arg') + \
[node.find('arg1'), node.find('arg2'), node.find('arg3')]
for arg in args:
if arg is not None:
id = arg.attrib.get('id')
if id is not None:
arg_roles[arg.attrib['role']] = (arg.attrib['id'], arg)
if node.find('features') is not None:
inevents = node.findall('features/inevent')
for inevent in inevents:
if 'id' in inevent.attrib:
arg_roles['inevent'] = (inevent.attrib['id'], inevent)
ptms = node.findall('features/ptm') + node.findall('features/no-ptm')
for ptm in ptms:
if 'id' in inevent.attrib:
arg_roles['ptm'] = (inevent.attrib['id'], ptm)
aw = node.find('assoc-with')
if aw is not None:
aw_id = aw.attrib['id']
arg_roles['assoc-with'] = (aw_id, aw)
return arg_roles |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:map_statements; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, for_statement; 6, 7; 6, 8; 6, 11; 7, identifier:stmt; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:statements; 11, block; 11, 12; 12, for_statement; 12, 13; 12, 14; 12, 19; 13, identifier:agent; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:stmt; 17, identifier:agent_list; 18, argument_list; 19, block; 19, 20; 19, 26; 19, 30; 19, 71; 20, if_statement; 20, 21; 20, 24; 21, comparison_operator:is; 21, 22; 21, 23; 22, identifier:agent; 23, None; 24, block; 24, 25; 25, continue_statement; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:all_mappings; 29, list:[]; 30, for_statement; 30, 31; 30, 34; 30, 41; 31, pattern_list; 31, 32; 31, 33; 32, identifier:db_name; 33, identifier:db_id; 34, call; 34, 35; 34, 40; 35, attribute; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:agent; 38, identifier:db_refs; 39, identifier:items; 40, argument_list; 41, block; 41, 42; 41, 57; 41, 67; 42, if_statement; 42, 43; 42, 48; 43, call; 43, 44; 43, 45; 44, identifier:isinstance; 45, argument_list; 45, 46; 45, 47; 46, identifier:db_id; 47, identifier:list; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:db_id; 52, subscript; 52, 53; 52, 56; 53, subscript; 53, 54; 53, 55; 54, identifier:db_id; 55, integer:0; 56, integer:0; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:mappings; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:_map_id; 64, argument_list; 64, 65; 64, 66; 65, identifier:db_name; 66, identifier:db_id; 67, expression_statement; 67, 68; 68, augmented_assignment:+=; 68, 69; 68, 70; 69, identifier:all_mappings; 70, identifier:mappings; 71, for_statement; 71, 72; 71, 77; 71, 78; 72, pattern_list; 72, 73; 72, 74; 72, 75; 72, 76; 73, identifier:map_db_name; 74, identifier:map_db_id; 75, identifier:score; 76, identifier:orig_db_name; 77, identifier:all_mappings; 78, block; 78, 79; 78, 87; 79, if_statement; 79, 80; 79, 85; 80, comparison_operator:in; 80, 81; 80, 82; 81, identifier:map_db_name; 82, attribute; 82, 83; 82, 84; 83, identifier:agent; 84, identifier:db_refs; 85, block; 85, 86; 86, continue_statement; 87, if_statement; 87, 88; 87, 91; 87, 127; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:scored; 91, block; 91, 92; 91, 113; 92, try_statement; 92, 93; 92, 106; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:orig_score; 97, subscript; 97, 98; 97, 105; 98, subscript; 98, 99; 98, 104; 99, subscript; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:agent; 102, identifier:db_refs; 103, identifier:orig_db_name; 104, integer:0; 105, integer:1; 106, except_clause; 106, 107; 106, 108; 107, identifier:Exception; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:orig_score; 112, float:1.0; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 120; 114, 121; 115, subscript; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:agent; 118, identifier:db_refs; 119, identifier:map_db_name; 120, line_continuation:\; 121, list:[(map_db_id, score * orig_score)]; 121, 122; 122, tuple; 122, 123; 122, 124; 123, identifier:map_db_id; 124, binary_operator:*; 124, 125; 124, 126; 125, identifier:score; 126, identifier:orig_score; 127, else_clause; 127, 128; 128, block; 128, 129; 129, if_statement; 129, 130; 129, 135; 129, 147; 130, comparison_operator:in; 130, 131; 130, 132; 131, identifier:map_db_name; 132, tuple; 132, 133; 132, 134; 133, string:'UN'; 134, string:'HUME'; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 143; 138, subscript; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:agent; 141, identifier:db_refs; 142, identifier:map_db_name; 143, list:[(map_db_id, 1.0)]; 143, 144; 144, tuple; 144, 145; 144, 146; 145, identifier:map_db_id; 146, float:1.0; 147, else_clause; 147, 148; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 156; 151, subscript; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:agent; 154, identifier:db_refs; 155, identifier:map_db_name; 156, identifier:map_db_id | def map_statements(self):
for stmt in self.statements:
for agent in stmt.agent_list():
if agent is None:
continue
all_mappings = []
for db_name, db_id in agent.db_refs.items():
if isinstance(db_id, list):
db_id = db_id[0][0]
mappings = self._map_id(db_name, db_id)
all_mappings += mappings
for map_db_name, map_db_id, score, orig_db_name in all_mappings:
if map_db_name in agent.db_refs:
continue
if self.scored:
try:
orig_score = agent.db_refs[orig_db_name][0][1]
except Exception:
orig_score = 1.0
agent.db_refs[map_db_name] = \
[(map_db_id, score * orig_score)]
else:
if map_db_name in ('UN', 'HUME'):
agent.db_refs[map_db_name] = [(map_db_id, 1.0)]
else:
agent.db_refs[map_db_name] = map_db_id |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:agent_texts_with_grounding; 3, parameters; 3, 4; 4, identifier:stmts; 5, block; 5, 6; 5, 13; 5, 44; 5, 61; 5, 68; 5, 89; 5, 108; 5, 112; 5, 249; 5, 266; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:allag; 9, call; 9, 10; 9, 11; 10, identifier:all_agents; 11, argument_list; 11, 12; 12, identifier:stmts; 13, for_statement; 13, 14; 13, 15; 13, 16; 14, identifier:ag; 15, identifier:allag; 16, block; 16, 17; 16, 28; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:pfam_def; 20, call; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:ag; 24, identifier:db_refs; 25, identifier:get; 26, argument_list; 26, 27; 27, string:'PFAM-DEF'; 28, if_statement; 28, 29; 28, 32; 29, comparison_operator:is; 29, 30; 29, 31; 30, identifier:pfam_def; 31, None; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 40; 35, subscript; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:ag; 38, identifier:db_refs; 39, string:'PFAM-DEF'; 40, call; 40, 41; 40, 42; 41, identifier:tuple; 42, argument_list; 42, 43; 43, identifier:pfam_def; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:refs; 47, list_comprehension; 47, 48; 47, 58; 48, call; 48, 49; 48, 50; 49, identifier:tuple; 50, argument_list; 50, 51; 51, call; 51, 52; 51, 57; 52, attribute; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:ag; 55, identifier:db_refs; 56, identifier:items; 57, argument_list; 58, for_in_clause; 58, 59; 58, 60; 59, identifier:ag; 60, identifier:allag; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:refs_counter; 64, call; 64, 65; 64, 66; 65, identifier:Counter; 66, argument_list; 66, 67; 67, identifier:refs; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:refs_counter_dict; 71, list_comprehension; 71, 72; 71, 82; 72, tuple; 72, 73; 72, 79; 73, call; 73, 74; 73, 75; 74, identifier:dict; 75, argument_list; 75, 76; 76, subscript; 76, 77; 76, 78; 77, identifier:entry; 78, integer:0; 79, subscript; 79, 80; 79, 81; 80, identifier:entry; 81, integer:1; 82, for_in_clause; 82, 83; 82, 84; 83, identifier:entry; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:refs_counter; 87, identifier:items; 88, argument_list; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:refs_counter_dict; 93, identifier:sort; 94, argument_list; 94, 95; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:key; 97, lambda; 97, 98; 97, 100; 98, lambda_parameters; 98, 99; 99, identifier:x; 100, call; 100, 101; 100, 106; 101, attribute; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:x; 104, integer:0; 105, identifier:get; 106, argument_list; 106, 107; 107, string:'TEXT'; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:grouped_by_text; 111, list:[]; 112, for_statement; 112, 113; 112, 116; 112, 133; 113, pattern_list; 113, 114; 113, 115; 114, identifier:k; 115, identifier:g; 116, call; 116, 117; 116, 118; 117, identifier:groupby; 118, argument_list; 118, 119; 118, 120; 119, identifier:refs_counter_dict; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:key; 122, lambda; 122, 123; 122, 125; 123, lambda_parameters; 123, 124; 124, identifier:x; 125, call; 125, 126; 125, 131; 126, attribute; 126, 127; 126, 130; 127, subscript; 127, 128; 127, 129; 128, identifier:x; 129, integer:0; 130, identifier:get; 131, argument_list; 131, 132; 132, string:'TEXT'; 133, block; 133, 134; 133, 138; 133, 143; 133, 147; 133, 208; 133, 232; 133, 239; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:total; 137, integer:0; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:entry; 141, list:[k]; 141, 142; 142, identifier:k; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:db_ref_list; 146, list:[]; 147, for_statement; 147, 148; 147, 151; 147, 152; 148, pattern_list; 148, 149; 148, 150; 149, identifier:db_refs; 150, identifier:count; 151, identifier:g; 152, block; 152, 153; 152, 176; 152, 204; 153, if_statement; 153, 154; 153, 165; 154, comparison_operator:==; 154, 155; 154, 163; 155, call; 155, 156; 155, 157; 156, identifier:list; 157, argument_list; 157, 158; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:db_refs; 161, identifier:keys; 162, argument_list; 163, list:['TEXT']; 163, 164; 164, string:'TEXT'; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:db_ref_list; 170, identifier:append; 171, argument_list; 171, 172; 172, tuple; 172, 173; 172, 174; 172, 175; 173, None; 174, None; 175, identifier:count; 176, for_statement; 176, 177; 176, 180; 176, 185; 177, pattern_list; 177, 178; 177, 179; 178, identifier:db; 179, identifier:db_id; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:db_refs; 183, identifier:items; 184, argument_list; 185, block; 185, 186; 186, if_statement; 186, 187; 186, 190; 186, 192; 187, comparison_operator:==; 187, 188; 187, 189; 188, identifier:db; 189, string:'TEXT'; 190, block; 190, 191; 191, continue_statement; 192, else_clause; 192, 193; 193, block; 193, 194; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:db_ref_list; 198, identifier:append; 199, argument_list; 199, 200; 200, tuple; 200, 201; 200, 202; 200, 203; 201, identifier:db; 202, identifier:db_id; 203, identifier:count; 204, expression_statement; 204, 205; 205, augmented_assignment:+=; 205, 206; 205, 207; 206, identifier:total; 207, identifier:count; 208, expression_statement; 208, 209; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:entry; 212, identifier:append; 213, argument_list; 213, 214; 214, call; 214, 215; 214, 216; 215, identifier:tuple; 216, argument_list; 216, 217; 217, call; 217, 218; 217, 219; 218, identifier:sorted; 219, argument_list; 219, 220; 219, 221; 219, 229; 220, identifier:db_ref_list; 221, keyword_argument; 221, 222; 221, 223; 222, identifier:key; 223, lambda; 223, 224; 223, 226; 224, lambda_parameters; 224, 225; 225, identifier:x; 226, subscript; 226, 227; 226, 228; 227, identifier:x; 228, integer:2; 229, keyword_argument; 229, 230; 229, 231; 230, identifier:reverse; 231, True; 232, expression_statement; 232, 233; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:entry; 236, identifier:append; 237, argument_list; 237, 238; 238, identifier:total; 239, expression_statement; 239, 240; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:grouped_by_text; 243, identifier:append; 244, argument_list; 244, 245; 245, call; 245, 246; 245, 247; 246, identifier:tuple; 247, argument_list; 247, 248; 248, identifier:entry; 249, expression_statement; 249, 250; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:grouped_by_text; 253, identifier:sort; 254, argument_list; 254, 255; 254, 263; 255, keyword_argument; 255, 256; 255, 257; 256, identifier:key; 257, lambda; 257, 258; 257, 260; 258, lambda_parameters; 258, 259; 259, identifier:x; 260, subscript; 260, 261; 260, 262; 261, identifier:x; 262, integer:2; 263, keyword_argument; 263, 264; 263, 265; 264, identifier:reverse; 265, True; 266, return_statement; 266, 267; 267, identifier:grouped_by_text | def agent_texts_with_grounding(stmts):
allag = all_agents(stmts)
for ag in allag:
pfam_def = ag.db_refs.get('PFAM-DEF')
if pfam_def is not None:
ag.db_refs['PFAM-DEF'] = tuple(pfam_def)
refs = [tuple(ag.db_refs.items()) for ag in allag]
refs_counter = Counter(refs)
refs_counter_dict = [(dict(entry[0]), entry[1])
for entry in refs_counter.items()]
refs_counter_dict.sort(key=lambda x: x[0].get('TEXT'))
grouped_by_text = []
for k, g in groupby(refs_counter_dict, key=lambda x: x[0].get('TEXT')):
total = 0
entry = [k]
db_ref_list = []
for db_refs, count in g:
if list(db_refs.keys()) == ['TEXT']:
db_ref_list.append((None, None, count))
for db, db_id in db_refs.items():
if db == 'TEXT':
continue
else:
db_ref_list.append((db, db_id, count))
total += count
entry.append(tuple(sorted(db_ref_list, key=lambda x: x[2],
reverse=True)))
entry.append(total)
grouped_by_text.append(tuple(entry))
grouped_by_text.sort(key=lambda x: x[2], reverse=True)
return grouped_by_text |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:ungrounded_texts; 3, parameters; 3, 4; 4, identifier:stmts; 5, block; 5, 6; 5, 43; 5, 50; 5, 58; 5, 76; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:ungrounded; 9, list_comprehension; 9, 10; 9, 15; 9, 18; 9, 25; 10, subscript; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:ag; 13, identifier:db_refs; 14, string:'TEXT'; 15, for_in_clause; 15, 16; 15, 17; 16, identifier:s; 17, identifier:stmts; 18, for_in_clause; 18, 19; 18, 20; 19, identifier:ag; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:s; 23, identifier:agent_list; 24, argument_list; 25, if_clause; 25, 26; 26, boolean_operator:and; 26, 27; 26, 30; 27, comparison_operator:is; 27, 28; 27, 29; 28, identifier:ag; 29, None; 30, comparison_operator:==; 30, 31; 30, 41; 31, call; 31, 32; 31, 33; 32, identifier:list; 33, argument_list; 33, 34; 34, call; 34, 35; 34, 40; 35, attribute; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:ag; 38, identifier:db_refs; 39, identifier:keys; 40, argument_list; 41, list:['TEXT']; 41, 42; 42, string:'TEXT'; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:ungroundc; 46, call; 46, 47; 46, 48; 47, identifier:Counter; 48, argument_list; 48, 49; 49, identifier:ungrounded; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:ungroundc; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:ungroundc; 56, identifier:items; 57, argument_list; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:ungroundc; 61, call; 61, 62; 61, 63; 62, identifier:sorted; 63, argument_list; 63, 64; 63, 65; 63, 73; 64, identifier:ungroundc; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:key; 67, lambda; 67, 68; 67, 70; 68, lambda_parameters; 68, 69; 69, identifier:x; 70, subscript; 70, 71; 70, 72; 71, identifier:x; 72, integer:1; 73, keyword_argument; 73, 74; 73, 75; 74, identifier:reverse; 75, True; 76, return_statement; 76, 77; 77, identifier:ungroundc | def ungrounded_texts(stmts):
ungrounded = [ag.db_refs['TEXT']
for s in stmts
for ag in s.agent_list()
if ag is not None and list(ag.db_refs.keys()) == ['TEXT']]
ungroundc = Counter(ungrounded)
ungroundc = ungroundc.items()
ungroundc = sorted(ungroundc, key=lambda x: x[1], reverse=True)
return ungroundc |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:protein_map_from_twg; 3, parameters; 3, 4; 4, identifier:twg; 5, block; 5, 6; 5, 10; 5, 14; 5, 18; 5, 25; 5, 141; 5, 150; 5, 159; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:protein_map; 9, dictionary; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:unmatched; 13, integer:0; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:matched; 17, integer:0; 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:'Building grounding map for human proteins'; 25, for_statement; 25, 26; 25, 30; 25, 31; 26, pattern_list; 26, 27; 26, 28; 26, 29; 27, identifier:agent_text; 28, identifier:grounding_list; 29, identifier:_; 30, identifier:twg; 31, block; 31, 32; 31, 44; 31, 60; 32, if_statement; 32, 33; 32, 42; 33, comparison_operator:not; 33, 34; 33, 35; 34, string:'UP'; 35, list_comprehension; 35, 36; 35, 39; 36, subscript; 36, 37; 36, 38; 37, identifier:entry; 38, integer:0; 39, for_in_clause; 39, 40; 39, 41; 40, identifier:entry; 41, identifier:grounding_list; 42, block; 42, 43; 43, continue_statement; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:uniprot_ids; 47, list_comprehension; 47, 48; 47, 51; 47, 54; 48, subscript; 48, 49; 48, 50; 49, identifier:entry; 50, integer:1; 51, for_in_clause; 51, 52; 51, 53; 52, identifier:entry; 53, identifier:grounding_list; 54, if_clause; 54, 55; 55, comparison_operator:==; 55, 56; 55, 59; 56, subscript; 56, 57; 56, 58; 57, identifier:entry; 58, integer:0; 59, string:'UP'; 60, for_statement; 60, 61; 60, 62; 60, 63; 61, identifier:uniprot_id; 62, identifier:uniprot_ids; 63, block; 63, 64; 63, 73; 63, 87; 63, 96; 63, 106; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:mnemonic; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:uniprot_client; 70, identifier:get_mnemonic; 71, argument_list; 71, 72; 72, identifier:uniprot_id; 73, if_statement; 73, 74; 73, 85; 74, boolean_operator:or; 74, 75; 74, 78; 75, comparison_operator:is; 75, 76; 75, 77; 76, identifier:mnemonic; 77, None; 78, not_operator; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:mnemonic; 82, identifier:endswith; 83, argument_list; 83, 84; 84, string:'_HUMAN'; 85, block; 85, 86; 86, continue_statement; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:gene_name; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:uniprot_client; 93, identifier:get_gene_name; 94, argument_list; 94, 95; 95, identifier:uniprot_id; 96, if_statement; 96, 97; 96, 100; 97, comparison_operator:is; 97, 98; 97, 99; 98, identifier:gene_name; 99, None; 100, block; 100, 101; 100, 105; 101, expression_statement; 101, 102; 102, augmented_assignment:+=; 102, 103; 102, 104; 103, identifier:unmatched; 104, integer:1; 105, continue_statement; 106, if_statement; 106, 107; 106, 118; 106, 135; 107, comparison_operator:==; 107, 108; 107, 113; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:agent_text; 111, identifier:upper; 112, argument_list; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:gene_name; 116, identifier:upper; 117, argument_list; 118, block; 118, 119; 118, 123; 119, expression_statement; 119, 120; 120, augmented_assignment:+=; 120, 121; 120, 122; 121, identifier:matched; 122, integer:1; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:protein_map; 127, identifier:agent_text; 128, dictionary; 128, 129; 128, 132; 129, pair; 129, 130; 129, 131; 130, string:'TEXT'; 131, identifier:agent_text; 132, pair; 132, 133; 132, 134; 133, string:'UP'; 134, identifier:uniprot_id; 135, else_clause; 135, 136; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, augmented_assignment:+=; 138, 139; 138, 140; 139, identifier:unmatched; 140, integer:1; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:logger; 145, identifier:info; 146, argument_list; 146, 147; 147, binary_operator:%; 147, 148; 147, 149; 148, string:'Exact matches for %d proteins'; 149, identifier:matched; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:logger; 154, identifier:info; 155, argument_list; 155, 156; 156, binary_operator:%; 156, 157; 156, 158; 157, string:'No match (or no gene name) for %d proteins'; 158, identifier:unmatched; 159, return_statement; 159, 160; 160, identifier:protein_map | def protein_map_from_twg(twg):
protein_map = {}
unmatched = 0
matched = 0
logger.info('Building grounding map for human proteins')
for agent_text, grounding_list, _ in twg:
if 'UP' not in [entry[0] for entry in grounding_list]:
continue
uniprot_ids = [entry[1] for entry in grounding_list
if entry[0] == 'UP']
for uniprot_id in uniprot_ids:
mnemonic = uniprot_client.get_mnemonic(uniprot_id)
if mnemonic is None or not mnemonic.endswith('_HUMAN'):
continue
gene_name = uniprot_client.get_gene_name(uniprot_id)
if gene_name is None:
unmatched += 1
continue
if agent_text.upper() == gene_name.upper():
matched += 1
protein_map[agent_text] = {'TEXT': agent_text,
'UP': uniprot_id}
else:
unmatched += 1
logger.info('Exact matches for %d proteins' % matched)
logger.info('No match (or no gene name) for %d proteins' % unmatched)
return protein_map |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:save_sentences; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:twg; 5, identifier:stmts; 6, identifier:filename; 7, default_parameter; 7, 8; 7, 9; 8, identifier:agent_limit; 9, integer:300; 10, block; 10, 11; 10, 15; 10, 25; 10, 29; 10, 38; 10, 74; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:sentences; 14, list:[]; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:unmapped_texts; 18, list_comprehension; 18, 19; 18, 22; 19, subscript; 19, 20; 19, 21; 20, identifier:t; 21, integer:0; 22, for_in_clause; 22, 23; 22, 24; 23, identifier:t; 24, identifier:twg; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:counter; 28, integer:0; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:logger; 33, identifier:info; 34, argument_list; 34, 35; 35, binary_operator:%; 35, 36; 35, 37; 36, string:'Getting sentences for top %d unmapped agent texts.'; 37, identifier:agent_limit; 38, for_statement; 38, 39; 38, 40; 38, 41; 39, identifier:text; 40, identifier:unmapped_texts; 41, block; 41, 42; 41, 50; 41, 64; 41, 68; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:agent_sentences; 45, call; 45, 46; 45, 47; 46, identifier:get_sentences_for_agent; 47, argument_list; 47, 48; 47, 49; 48, identifier:text; 49, identifier:stmts; 50, expression_statement; 50, 51; 51, augmented_assignment:+=; 51, 52; 51, 53; 52, identifier:sentences; 53, call; 53, 54; 53, 55; 54, identifier:map; 55, argument_list; 55, 56; 55, 63; 56, lambda; 56, 57; 56, 59; 57, lambda_parameters; 57, 58; 58, identifier:tup; 59, binary_operator:+; 59, 60; 59, 62; 60, tuple; 60, 61; 61, identifier:text; 62, identifier:tup; 63, identifier:agent_sentences; 64, expression_statement; 64, 65; 65, augmented_assignment:+=; 65, 66; 65, 67; 66, identifier:counter; 67, integer:1; 68, if_statement; 68, 69; 68, 72; 69, comparison_operator:>=; 69, 70; 69, 71; 70, identifier:counter; 71, identifier:agent_limit; 72, block; 72, 73; 73, break_statement; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:write_unicode_csv; 77, argument_list; 77, 78; 77, 79; 77, 80; 77, 83; 77, 86; 77, 91; 78, identifier:filename; 79, identifier:sentences; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:delimiter; 82, string:','; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:quotechar; 85, string:'"'; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:quoting; 88, attribute; 88, 89; 88, 90; 89, identifier:csv; 90, identifier:QUOTE_MINIMAL; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:lineterminator; 93, string:'\r\n' | def save_sentences(twg, stmts, filename, agent_limit=300):
sentences = []
unmapped_texts = [t[0] for t in twg]
counter = 0
logger.info('Getting sentences for top %d unmapped agent texts.' %
agent_limit)
for text in unmapped_texts:
agent_sentences = get_sentences_for_agent(text, stmts)
sentences += map(lambda tup: (text,) + tup, agent_sentences)
counter += 1
if counter >= agent_limit:
break
write_unicode_csv(filename, sentences, delimiter=',', quotechar='"',
quoting=csv.QUOTE_MINIMAL, lineterminator='\r\n') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_get_text_for_grounding; 3, parameters; 3, 4; 3, 5; 4, identifier:stmt; 5, identifier:agent_text; 6, block; 6, 7; 6, 11; 6, 103; 6, 150; 6, 174; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:text; 10, None; 11, try_statement; 11, 12; 11, 90; 12, block; 12, 13; 12, 21; 12, 28; 12, 38; 12, 59; 12, 68; 12, 75; 12, 85; 13, import_from_statement; 13, 14; 13, 18; 13, 19; 14, dotted_name; 14, 15; 14, 16; 14, 17; 15, identifier:indra_db; 16, identifier:util; 17, identifier:content_scripts; 18, line_continuation:\; 19, dotted_name; 19, 20; 20, identifier:get_text_content_from_text_refs; 21, import_from_statement; 21, 22; 21, 26; 22, dotted_name; 22, 23; 22, 24; 22, 25; 23, identifier:indra; 24, identifier:literature; 25, identifier:deft_tools; 26, dotted_name; 26, 27; 27, identifier:universal_extract_text; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:refs; 31, attribute; 31, 32; 31, 37; 32, subscript; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:stmt; 35, identifier:evidence; 36, integer:0; 37, identifier:text_refs; 38, if_statement; 38, 39; 38, 46; 39, attribute; 39, 40; 39, 45; 40, subscript; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:stmt; 43, identifier:evidence; 44, integer:0; 45, identifier:pmid; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 52; 49, subscript; 49, 50; 49, 51; 50, identifier:refs; 51, string:'PMID'; 52, attribute; 52, 53; 52, 58; 53, subscript; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:stmt; 56, identifier:evidence; 57, integer:0; 58, identifier:pmid; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:logger; 63, identifier:info; 64, argument_list; 64, 65; 65, binary_operator:%; 65, 66; 65, 67; 66, string:'Obtaining text for disambiguation with refs: %s'; 67, identifier:refs; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:content; 71, call; 71, 72; 71, 73; 72, identifier:get_text_content_from_text_refs; 73, argument_list; 73, 74; 74, identifier:refs; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:text; 78, call; 78, 79; 78, 80; 79, identifier:universal_extract_text; 80, argument_list; 80, 81; 80, 82; 81, identifier:content; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:contains; 84, identifier:agent_text; 85, if_statement; 85, 86; 85, 87; 86, identifier:text; 87, block; 87, 88; 88, return_statement; 88, 89; 89, identifier:text; 90, except_clause; 90, 91; 90, 95; 91, as_pattern; 91, 92; 91, 93; 92, identifier:Exception; 93, as_pattern_target; 93, 94; 94, identifier:e; 95, block; 95, 96; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:logger; 100, identifier:info; 101, argument_list; 101, 102; 102, string:'Could not get text for disambiguation from DB.'; 103, if_statement; 103, 104; 103, 107; 104, comparison_operator:is; 104, 105; 104, 106; 105, identifier:text; 106, None; 107, block; 107, 108; 107, 114; 107, 124; 108, import_from_statement; 108, 109; 108, 112; 109, dotted_name; 109, 110; 109, 111; 110, identifier:indra; 111, identifier:literature; 112, dotted_name; 112, 113; 113, identifier:pubmed_client; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:pmid; 117, attribute; 117, 118; 117, 123; 118, subscript; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:stmt; 121, identifier:evidence; 122, integer:0; 123, identifier:pmid; 124, if_statement; 124, 125; 124, 126; 125, identifier:pmid; 126, block; 126, 127; 126, 136; 126, 145; 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:'Obtaining abstract for disambiguation for PMID%s'; 135, identifier:pmid; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:text; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:pubmed_client; 142, identifier:get_abstract; 143, argument_list; 143, 144; 144, identifier:pmid; 145, if_statement; 145, 146; 145, 147; 146, identifier:text; 147, block; 147, 148; 148, return_statement; 148, 149; 149, identifier:text; 150, if_statement; 150, 151; 150, 154; 151, comparison_operator:is; 151, 152; 151, 153; 152, identifier:text; 153, None; 154, block; 154, 155; 154, 162; 154, 172; 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, string:'Falling back on sentence-based disambiguation'; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:text; 165, attribute; 165, 166; 165, 171; 166, subscript; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:stmt; 169, identifier:evidence; 170, integer:0; 171, identifier:text; 172, return_statement; 172, 173; 173, identifier:text; 174, return_statement; 174, 175; 175, None | def _get_text_for_grounding(stmt, agent_text):
text = None
try:
from indra_db.util.content_scripts \
import get_text_content_from_text_refs
from indra.literature.deft_tools import universal_extract_text
refs = stmt.evidence[0].text_refs
if stmt.evidence[0].pmid:
refs['PMID'] = stmt.evidence[0].pmid
logger.info('Obtaining text for disambiguation with refs: %s' %
refs)
content = get_text_content_from_text_refs(refs)
text = universal_extract_text(content, contains=agent_text)
if text:
return text
except Exception as e:
logger.info('Could not get text for disambiguation from DB.')
if text is None:
from indra.literature import pubmed_client
pmid = stmt.evidence[0].pmid
if pmid:
logger.info('Obtaining abstract for disambiguation for PMID%s' %
pmid)
text = pubmed_client.get_abstract(pmid)
if text:
return text
if text is None:
logger.info('Falling back on sentence-based disambiguation')
text = stmt.evidence[0].text
return text
return None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:map_agents_for_stmt; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:stmt; 6, default_parameter; 6, 7; 6, 8; 7, identifier:do_rename; 8, True; 9, block; 9, 10; 9, 17; 9, 25; 9, 144; 9, 151; 9, 187; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:mapped_stmt; 13, call; 13, 14; 13, 15; 14, identifier:deepcopy; 15, argument_list; 15, 16; 16, identifier:stmt; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:agent_list; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:mapped_stmt; 23, identifier:agent_list; 24, argument_list; 25, for_statement; 25, 26; 25, 29; 25, 33; 26, pattern_list; 26, 27; 26, 28; 27, identifier:idx; 28, identifier:agent; 29, call; 29, 30; 29, 31; 30, identifier:enumerate; 31, argument_list; 31, 32; 32, identifier:agent_list; 33, block; 33, 34; 33, 40; 33, 51; 33, 57; 33, 69; 33, 111; 33, 116; 33, 138; 34, if_statement; 34, 35; 34, 38; 35, comparison_operator:is; 35, 36; 35, 37; 36, identifier:agent; 37, None; 38, block; 38, 39; 39, continue_statement; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:agent_txt; 43, call; 43, 44; 43, 49; 44, attribute; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:agent; 47, identifier:db_refs; 48, identifier:get; 49, argument_list; 49, 50; 50, string:'TEXT'; 51, if_statement; 51, 52; 51, 55; 52, comparison_operator:is; 52, 53; 52, 54; 53, identifier:agent_txt; 54, None; 55, block; 55, 56; 56, continue_statement; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 62; 59, pattern_list; 59, 60; 59, 61; 60, identifier:new_agent; 61, identifier:maps_to_none; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:map_agent; 66, argument_list; 66, 67; 66, 68; 67, identifier:agent; 68, identifier:do_rename; 69, if_statement; 69, 70; 69, 77; 70, boolean_operator:and; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:use_deft; 74, comparison_operator:in; 74, 75; 74, 76; 75, identifier:agent_txt; 76, identifier:deft_disambiguators; 77, block; 77, 78; 78, try_statement; 78, 79; 78, 89; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, call; 81, 82; 81, 83; 82, identifier:run_deft_disambiguation; 83, argument_list; 83, 84; 83, 85; 83, 86; 83, 87; 83, 88; 84, identifier:mapped_stmt; 85, identifier:agent_list; 86, identifier:idx; 87, identifier:new_agent; 88, identifier:agent_txt; 89, except_clause; 89, 90; 89, 94; 90, as_pattern; 90, 91; 90, 92; 91, identifier:Exception; 92, as_pattern_target; 92, 93; 93, identifier:e; 94, block; 94, 95; 94, 104; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:logger; 99, identifier:error; 100, argument_list; 100, 101; 101, concatenated_string; 101, 102; 101, 103; 102, string:'There was an error during Deft'; 103, string:' disambiguation.'; 104, expression_statement; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:logger; 108, identifier:error; 109, argument_list; 109, 110; 110, identifier:e; 111, if_statement; 111, 112; 111, 113; 112, identifier:maps_to_none; 113, block; 113, 114; 114, return_statement; 114, 115; 115, None; 116, if_statement; 116, 117; 116, 129; 117, boolean_operator:and; 117, 118; 117, 121; 118, comparison_operator:is; 118, 119; 118, 120; 119, identifier:new_agent; 120, None; 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:new_agent; 127, identifier:bound_conditions; 128, integer:0; 129, block; 129, 130; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:new_agent; 134, identifier:bound_conditions; 135, attribute; 135, 136; 135, 137; 136, identifier:agent; 137, identifier:bound_conditions; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 143; 140, subscript; 140, 141; 140, 142; 141, identifier:agent_list; 142, identifier:idx; 143, identifier:new_agent; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:mapped_stmt; 148, identifier:set_agent_list; 149, argument_list; 149, 150; 150, identifier:agent_list; 151, for_statement; 151, 152; 151, 153; 151, 154; 152, identifier:agent; 153, identifier:agent_list; 154, block; 154, 155; 155, if_statement; 155, 156; 155, 159; 156, comparison_operator:is; 156, 157; 156, 158; 157, identifier:agent; 158, None; 159, block; 159, 160; 160, for_statement; 160, 161; 160, 162; 160, 165; 161, identifier:bc; 162, attribute; 162, 163; 162, 164; 163, identifier:agent; 164, identifier:bound_conditions; 165, block; 165, 166; 165, 182; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 173; 168, pattern_list; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:bc; 171, identifier:agent; 172, identifier:maps_to_none; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:self; 176, identifier:map_agent; 177, argument_list; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:bc; 180, identifier:agent; 181, identifier:do_rename; 182, if_statement; 182, 183; 182, 184; 183, identifier:maps_to_none; 184, block; 184, 185; 185, return_statement; 185, 186; 186, None; 187, return_statement; 187, 188; 188, identifier:mapped_stmt | def map_agents_for_stmt(self, stmt, do_rename=True):
mapped_stmt = deepcopy(stmt)
agent_list = mapped_stmt.agent_list()
for idx, agent in enumerate(agent_list):
if agent is None:
continue
agent_txt = agent.db_refs.get('TEXT')
if agent_txt is None:
continue
new_agent, maps_to_none = self.map_agent(agent, do_rename)
if self.use_deft and agent_txt in deft_disambiguators:
try:
run_deft_disambiguation(mapped_stmt, agent_list, idx,
new_agent, agent_txt)
except Exception as e:
logger.error('There was an error during Deft'
' disambiguation.')
logger.error(e)
if maps_to_none:
return None
if new_agent is not None and len(new_agent.bound_conditions) == 0:
new_agent.bound_conditions = agent.bound_conditions
agent_list[idx] = new_agent
mapped_stmt.set_agent_list(agent_list)
for agent in agent_list:
if agent is not None:
for bc in agent.bound_conditions:
bc.agent, maps_to_none = self.map_agent(bc.agent,
do_rename)
if maps_to_none:
return None
return mapped_stmt |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:map_agent; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:agent; 6, identifier:do_rename; 7, block; 7, 8; 7, 19; 7, 30; 7, 49; 7, 74; 7, 103; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:agent_text; 11, call; 11, 12; 11, 17; 12, attribute; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:agent; 15, identifier:db_refs; 16, identifier:get; 17, argument_list; 17, 18; 18, string:'TEXT'; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:mapped_to_agent_json; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:agent_map; 27, identifier:get; 28, argument_list; 28, 29; 29, identifier:agent_text; 30, if_statement; 30, 31; 30, 32; 31, identifier:mapped_to_agent_json; 32, block; 32, 33; 32, 45; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 34, 37; 35, identifier:mapped_to_agent; 36, line_continuation:\; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:Agent; 40, identifier:_from_json; 41, argument_list; 41, 42; 42, subscript; 42, 43; 42, 44; 43, identifier:mapped_to_agent_json; 44, string:'agent'; 45, return_statement; 45, 46; 46, expression_list; 46, 47; 46, 48; 47, identifier:mapped_to_agent; 48, False; 49, if_statement; 49, 50; 49, 59; 49, 68; 50, comparison_operator:in; 50, 51; 50, 52; 51, identifier:agent_text; 52, call; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:gm; 57, identifier:keys; 58, argument_list; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:map_db_refs; 63, subscript; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:gm; 67, identifier:agent_text; 68, else_clause; 68, 69; 69, block; 69, 70; 70, return_statement; 70, 71; 71, expression_list; 71, 72; 71, 73; 72, identifier:agent; 73, False; 74, if_statement; 74, 75; 74, 78; 74, 92; 75, comparison_operator:is; 75, 76; 75, 77; 76, identifier:map_db_refs; 77, None; 78, block; 78, 79; 78, 88; 79, expression_statement; 79, 80; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:logger; 83, identifier:debug; 84, argument_list; 84, 85; 85, binary_operator:%; 85, 86; 85, 87; 86, string:"Skipping %s"; 87, identifier:agent_text; 88, return_statement; 88, 89; 89, expression_list; 89, 90; 89, 91; 90, None; 91, True; 92, else_clause; 92, 93; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:update_agent_db_refs; 99, argument_list; 99, 100; 99, 101; 99, 102; 100, identifier:agent; 101, identifier:agent_text; 102, identifier:do_rename; 103, return_statement; 103, 104; 104, expression_list; 104, 105; 104, 106; 105, identifier:agent; 106, False | def map_agent(self, agent, do_rename):
agent_text = agent.db_refs.get('TEXT')
mapped_to_agent_json = self.agent_map.get(agent_text)
if mapped_to_agent_json:
mapped_to_agent = \
Agent._from_json(mapped_to_agent_json['agent'])
return mapped_to_agent, False
if agent_text in self.gm.keys():
map_db_refs = self.gm[agent_text]
else:
return agent, False
if map_db_refs is None:
logger.debug("Skipping %s" % agent_text)
return None, True
else:
self.update_agent_db_refs(agent, agent_text, do_rename)
return agent, False |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:rename_agents; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:stmts; 6, block; 6, 7; 6, 14; 6, 118; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:mapped_stmts; 10, call; 10, 11; 10, 12; 11, identifier:deepcopy; 12, argument_list; 12, 13; 13, identifier:stmts; 14, for_statement; 14, 15; 14, 18; 14, 22; 15, pattern_list; 15, 16; 15, 17; 16, identifier:_; 17, identifier:stmt; 18, call; 18, 19; 18, 20; 19, identifier:enumerate; 20, argument_list; 20, 21; 21, identifier:mapped_stmts; 22, block; 22, 23; 23, for_statement; 23, 24; 23, 25; 23, 30; 24, identifier:agent; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:stmt; 28, identifier:agent_list; 29, argument_list; 30, block; 30, 31; 30, 37; 31, if_statement; 31, 32; 31, 35; 32, comparison_operator:is; 32, 33; 32, 34; 33, identifier:agent; 34, None; 35, block; 35, 36; 36, continue_statement; 37, if_statement; 37, 38; 37, 46; 37, 60; 38, call; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:agent; 42, identifier:db_refs; 43, identifier:get; 44, argument_list; 44, 45; 45, string:'FPLX'; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:agent; 51, identifier:name; 52, call; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:agent; 56, identifier:db_refs; 57, identifier:get; 58, argument_list; 58, 59; 59, string:'FPLX'; 60, elif_clause; 60, 61; 60, 69; 61, call; 61, 62; 61, 67; 62, attribute; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:agent; 65, identifier:db_refs; 66, identifier:get; 67, argument_list; 67, 68; 68, string:'UP'; 69, block; 69, 70; 69, 89; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:gene_name; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:uniprot_client; 76, identifier:get_gene_name; 77, argument_list; 77, 78; 77, 86; 78, call; 78, 79; 78, 84; 79, attribute; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:agent; 82, identifier:db_refs; 83, identifier:get; 84, argument_list; 84, 85; 85, string:'UP'; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:web_fallback; 88, False; 89, if_statement; 89, 90; 89, 91; 90, identifier:gene_name; 91, block; 91, 92; 91, 98; 91, 107; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:agent; 96, identifier:name; 97, identifier:gene_name; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:hgnc_id; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:hgnc_client; 104, identifier:get_hgnc_id; 105, argument_list; 105, 106; 106, identifier:gene_name; 107, if_statement; 107, 108; 107, 109; 108, identifier:hgnc_id; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 117; 112, subscript; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:agent; 115, identifier:db_refs; 116, string:'HGNC'; 117, identifier:hgnc_id; 118, return_statement; 118, 119; 119, identifier:mapped_stmts | def rename_agents(self, stmts):
mapped_stmts = deepcopy(stmts)
for _, stmt in enumerate(mapped_stmts):
for agent in stmt.agent_list():
if agent is None:
continue
if agent.db_refs.get('FPLX'):
agent.name = agent.db_refs.get('FPLX')
elif agent.db_refs.get('UP'):
gene_name = uniprot_client.get_gene_name(
agent.db_refs.get('UP'),
web_fallback=False)
if gene_name:
agent.name = gene_name
hgnc_id = hgnc_client.get_hgnc_id(gene_name)
if hgnc_id:
agent.db_refs['HGNC'] = hgnc_id
return mapped_stmts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_ptms; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:ptm_df; 6, block; 6, 7; 6, 14; 7, expression_statement; 7, 8; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:logger; 11, identifier:info; 12, argument_list; 12, 13; 13, string:'Processing PTMs...'; 14, for_statement; 14, 15; 14, 18; 14, 23; 15, pattern_list; 15, 16; 15, 17; 16, identifier:ix; 17, identifier:row; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:ptm_df; 21, identifier:iterrows; 22, argument_list; 23, block; 23, 24; 23, 32; 23, 38; 23, 54; 23, 60; 23, 69; 23, 78; 23, 87; 23, 96; 23, 120; 23, 122; 23, 124; 23, 137; 23, 159; 23, 172; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:ptm_class; 27, subscript; 27, 28; 27, 29; 28, identifier:_ptm_map; 29, subscript; 29, 30; 29, 31; 30, identifier:row; 31, string:'MOD_TYPE'; 32, if_statement; 32, 33; 32, 36; 33, comparison_operator:is; 33, 34; 33, 35; 34, identifier:ptm_class; 35, None; 36, block; 36, 37; 37, continue_statement; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:sub_ag; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:_make_agent; 45, argument_list; 45, 46; 45, 49; 46, subscript; 46, 47; 46, 48; 47, identifier:row; 48, string:'HPRD_ID'; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:refseq_id; 51, subscript; 51, 52; 51, 53; 52, identifier:row; 53, string:'REFSEQ_PROTEIN'; 54, if_statement; 54, 55; 54, 58; 55, comparison_operator:is; 55, 56; 55, 57; 56, identifier:sub_ag; 57, None; 58, block; 58, 59; 59, continue_statement; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:enz_id; 63, call; 63, 64; 63, 65; 64, identifier:_nan_to_none; 65, argument_list; 65, 66; 66, subscript; 66, 67; 66, 68; 67, identifier:row; 68, string:'ENZ_HPRD_ID'; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:enz_ag; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:_make_agent; 76, argument_list; 76, 77; 77, identifier:enz_id; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:res; 81, call; 81, 82; 81, 83; 82, identifier:_nan_to_none; 83, argument_list; 83, 84; 84, subscript; 84, 85; 84, 86; 85, identifier:row; 86, string:'RESIDUE'; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:pos; 90, call; 90, 91; 90, 92; 91, identifier:_nan_to_none; 92, argument_list; 92, 93; 93, subscript; 93, 94; 93, 95; 94, identifier:row; 95, string:'POSITION'; 96, if_statement; 96, 97; 96, 104; 97, boolean_operator:and; 97, 98; 97, 101; 98, comparison_operator:is; 98, 99; 98, 100; 99, identifier:pos; 100, None; 101, comparison_operator:in; 101, 102; 101, 103; 102, string:';'; 103, identifier:pos; 104, block; 104, 105; 104, 116; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 110; 107, pattern_list; 107, 108; 107, 109; 108, identifier:pos; 109, identifier:dash; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:pos; 113, identifier:split; 114, argument_list; 114, 115; 115, string:';'; 116, assert_statement; 116, 117; 117, comparison_operator:==; 117, 118; 117, 119; 118, identifier:dash; 119, string:'-'; 120, assert_statement; 120, 121; 121, identifier:res; 122, assert_statement; 122, 123; 123, identifier:pos; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:motif_dict; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:_get_seq_motif; 131, argument_list; 131, 132; 131, 135; 131, 136; 132, subscript; 132, 133; 132, 134; 133, identifier:row; 134, string:'REFSEQ_PROTEIN'; 135, identifier:res; 136, identifier:pos; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:ev_list; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:_get_evidence; 144, argument_list; 144, 145; 144, 148; 144, 151; 144, 154; 144, 157; 144, 158; 145, subscript; 145, 146; 145, 147; 146, identifier:row; 147, string:'HPRD_ID'; 148, subscript; 148, 149; 148, 150; 149, identifier:row; 150, string:'HPRD_ISOFORM'; 151, subscript; 151, 152; 151, 153; 152, identifier:row; 153, string:'PMIDS'; 154, subscript; 154, 155; 154, 156; 155, identifier:row; 156, string:'EVIDENCE'; 157, string:'ptms'; 158, identifier:motif_dict; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:stmt; 162, call; 162, 163; 162, 164; 163, identifier:ptm_class; 164, argument_list; 164, 165; 164, 166; 164, 167; 164, 168; 164, 169; 165, identifier:enz_ag; 166, identifier:sub_ag; 167, identifier:res; 168, identifier:pos; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:evidence; 171, identifier:ev_list; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 179; 174, attribute; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:statements; 178, identifier:append; 179, argument_list; 179, 180; 180, identifier:stmt | def get_ptms(self, ptm_df):
logger.info('Processing PTMs...')
for ix, row in ptm_df.iterrows():
ptm_class = _ptm_map[row['MOD_TYPE']]
if ptm_class is None:
continue
sub_ag = self._make_agent(row['HPRD_ID'],
refseq_id=row['REFSEQ_PROTEIN'])
if sub_ag is None:
continue
enz_id = _nan_to_none(row['ENZ_HPRD_ID'])
enz_ag = self._make_agent(enz_id)
res = _nan_to_none(row['RESIDUE'])
pos = _nan_to_none(row['POSITION'])
if pos is not None and ';' in pos:
pos, dash = pos.split(';')
assert dash == '-'
assert res
assert pos
motif_dict = self._get_seq_motif(row['REFSEQ_PROTEIN'], res, pos)
ev_list = self._get_evidence(
row['HPRD_ID'], row['HPRD_ISOFORM'], row['PMIDS'],
row['EVIDENCE'], 'ptms', motif_dict)
stmt = ptm_class(enz_ag, sub_ag, res, pos, evidence=ev_list)
self.statements.append(stmt) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:_process_interaction; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, identifier:self; 5, identifier:source_id; 6, identifier:interaction; 7, identifier:text; 8, identifier:pmid; 9, identifier:extra_annotations; 10, block; 10, 11; 10, 21; 10, 28; 10, 35; 10, 44; 10, 53; 10, 60; 10, 76; 10, 82; 10, 88; 10, 112; 10, 116; 10, 139; 10, 148; 10, 152; 10, 197; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:verb; 14, call; 14, 15; 14, 20; 15, attribute; 15, 16; 15, 19; 16, subscript; 16, 17; 16, 18; 17, identifier:interaction; 18, integer:0; 19, identifier:lower; 20, argument_list; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:subj; 24, subscript; 24, 25; 24, 26; 25, identifier:interaction; 26, unary_operator:-; 26, 27; 27, integer:2; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:obj; 31, subscript; 31, 32; 31, 33; 32, identifier:interaction; 33, unary_operator:-; 33, 34; 34, integer:1; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:subj; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:_make_agent; 42, argument_list; 42, 43; 43, identifier:subj; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:obj; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:_make_agent; 51, argument_list; 51, 52; 52, identifier:obj; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:annotations; 56, call; 56, 57; 56, 58; 57, identifier:deepcopy; 58, argument_list; 58, 59; 59, identifier:extra_annotations; 60, if_statement; 60, 61; 60, 64; 61, comparison_operator:in; 61, 62; 61, 63; 62, string:'interaction'; 63, identifier:extra_annotations; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:logger; 69, identifier:warning; 70, argument_list; 70, 71; 71, binary_operator:+; 71, 72; 71, 75; 72, binary_operator:+; 72, 73; 72, 74; 73, string:"'interaction' key of extra_annotations ignored"; 74, string:" since this is reserved for storing the raw ISI "; 75, string:"input."; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 81; 78, subscript; 78, 79; 78, 80; 79, identifier:annotations; 80, string:'source_id'; 81, identifier:source_id; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, subscript; 84, 85; 84, 86; 85, identifier:annotations; 86, string:'interaction'; 87, identifier:interaction; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:ev; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:ist; 94, identifier:Evidence; 95, argument_list; 95, 96; 95, 99; 95, 102; 95, 109; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:source_api; 98, string:'isi'; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:pmid; 101, identifier:pmid; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:text; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:text; 107, identifier:rstrip; 108, argument_list; 109, keyword_argument; 109, 110; 109, 111; 110, identifier:annotations; 111, identifier:annotations; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:cataylst_specified; 115, False; 116, if_statement; 116, 117; 116, 123; 117, comparison_operator:==; 117, 118; 117, 122; 118, call; 118, 119; 118, 120; 119, identifier:len; 120, argument_list; 120, 121; 121, identifier:interaction; 122, integer:4; 123, block; 123, 124; 123, 130; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:catalyst; 127, subscript; 127, 128; 127, 129; 128, identifier:interaction; 129, integer:1; 130, if_statement; 130, 131; 130, 134; 131, comparison_operator:is; 131, 132; 131, 133; 132, identifier:catalyst; 133, None; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:cataylst_specified; 138, True; 139, expression_statement; 139, 140; 140, call; 140, 141; 140, 146; 141, attribute; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:self; 144, identifier:verbs; 145, identifier:add; 146, argument_list; 146, 147; 147, identifier:verb; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:statement; 151, None; 152, if_statement; 152, 153; 152, 156; 153, comparison_operator:in; 153, 154; 153, 155; 154, identifier:verb; 155, identifier:verb_to_statement_type; 156, block; 156, 157; 156, 163; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:statement_class; 160, subscript; 160, 161; 160, 162; 161, identifier:verb_to_statement_type; 162, identifier:verb; 163, if_statement; 163, 164; 163, 169; 163, 184; 164, comparison_operator:==; 164, 165; 164, 166; 165, identifier:statement_class; 166, attribute; 166, 167; 166, 168; 167, identifier:ist; 168, identifier:Complex; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:statement; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:ist; 176, identifier:Complex; 177, argument_list; 177, 178; 177, 181; 178, list:[subj, obj]; 178, 179; 178, 180; 179, identifier:subj; 180, identifier:obj; 181, keyword_argument; 181, 182; 181, 183; 182, identifier:evidence; 183, identifier:ev; 184, else_clause; 184, 185; 185, block; 185, 186; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:statement; 189, call; 189, 190; 189, 191; 190, identifier:statement_class; 191, argument_list; 191, 192; 191, 193; 191, 194; 192, identifier:subj; 193, identifier:obj; 194, keyword_argument; 194, 195; 194, 196; 195, identifier:evidence; 196, identifier:ev; 197, if_statement; 197, 198; 197, 201; 198, comparison_operator:is; 198, 199; 198, 200; 199, identifier:statement; 200, None; 201, block; 201, 202; 201, 206; 201, 309; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:already_have; 205, False; 206, if_statement; 206, 207; 206, 215; 207, comparison_operator:==; 207, 208; 207, 212; 208, call; 208, 209; 208, 210; 209, identifier:type; 210, argument_list; 210, 211; 211, identifier:statement; 212, attribute; 212, 213; 212, 214; 213, identifier:ist; 214, identifier:Complex; 215, block; 215, 216; 216, for_statement; 216, 217; 216, 218; 216, 221; 217, identifier:old_s; 218, attribute; 218, 219; 218, 220; 219, identifier:self; 220, identifier:statements; 221, block; 221, 222; 221, 232; 221, 242; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:old_id; 225, attribute; 225, 226; 225, 231; 226, subscript; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:statement; 229, identifier:evidence; 230, integer:0; 231, identifier:source_id; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 235; 234, identifier:new_id; 235, attribute; 235, 236; 235, 241; 236, subscript; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:old_s; 239, identifier:evidence; 240, integer:0; 241, identifier:source_id; 242, if_statement; 242, 243; 242, 255; 243, boolean_operator:and; 243, 244; 243, 252; 244, comparison_operator:==; 244, 245; 244, 249; 245, call; 245, 246; 245, 247; 246, identifier:type; 247, argument_list; 247, 248; 248, identifier:old_s; 249, attribute; 249, 250; 249, 251; 250, identifier:ist; 251, identifier:Complex; 252, comparison_operator:==; 252, 253; 252, 254; 253, identifier:old_id; 254, identifier:new_id; 255, block; 255, 256; 255, 271; 255, 278; 255, 292; 255, 299; 256, expression_statement; 256, 257; 257, assignment; 257, 258; 257, 259; 257, 260; 258, identifier:old_statement_members; 259, line_continuation:\; 260, list_comprehension; 260, 261; 260, 266; 261, subscript; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:m; 264, identifier:db_refs; 265, string:'TEXT'; 266, for_in_clause; 266, 267; 266, 268; 267, identifier:m; 268, attribute; 268, 269; 268, 270; 269, identifier:old_s; 270, identifier:members; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:old_statement_members; 274, call; 274, 275; 274, 276; 275, identifier:sorted; 276, argument_list; 276, 277; 277, identifier:old_statement_members; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 281; 280, identifier:new_statement_members; 281, list_comprehension; 281, 282; 281, 287; 282, subscript; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:m; 285, identifier:db_refs; 286, string:'TEXT'; 287, for_in_clause; 287, 288; 287, 289; 288, identifier:m; 289, attribute; 289, 290; 289, 291; 290, identifier:statement; 291, identifier:members; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 295; 294, identifier:new_statement_members; 295, call; 295, 296; 295, 297; 296, identifier:sorted; 297, argument_list; 297, 298; 298, identifier:new_statement_members; 299, if_statement; 299, 300; 299, 303; 300, comparison_operator:==; 300, 301; 300, 302; 301, identifier:old_statement_members; 302, identifier:new_statement_members; 303, block; 303, 304; 303, 308; 304, expression_statement; 304, 305; 305, assignment; 305, 306; 305, 307; 306, identifier:already_have; 307, True; 308, break_statement; 309, if_statement; 309, 310; 309, 312; 310, not_operator; 310, 311; 311, identifier:already_have; 312, block; 312, 313; 313, expression_statement; 313, 314; 314, call; 314, 315; 314, 320; 315, attribute; 315, 316; 315, 319; 316, attribute; 316, 317; 316, 318; 317, identifier:self; 318, identifier:statements; 319, identifier:append; 320, argument_list; 320, 321; 321, identifier:statement | def _process_interaction(self, source_id, interaction, text, pmid,
extra_annotations):
verb = interaction[0].lower()
subj = interaction[-2]
obj = interaction[-1]
subj = self._make_agent(subj)
obj = self._make_agent(obj)
annotations = deepcopy(extra_annotations)
if 'interaction' in extra_annotations:
logger.warning("'interaction' key of extra_annotations ignored" +
" since this is reserved for storing the raw ISI " +
"input.")
annotations['source_id'] = source_id
annotations['interaction'] = interaction
ev = ist.Evidence(source_api='isi',
pmid=pmid,
text=text.rstrip(),
annotations=annotations)
cataylst_specified = False
if len(interaction) == 4:
catalyst = interaction[1]
if catalyst is not None:
cataylst_specified = True
self.verbs.add(verb)
statement = None
if verb in verb_to_statement_type:
statement_class = verb_to_statement_type[verb]
if statement_class == ist.Complex:
statement = ist.Complex([subj, obj], evidence=ev)
else:
statement = statement_class(subj, obj, evidence=ev)
if statement is not None:
already_have = False
if type(statement) == ist.Complex:
for old_s in self.statements:
old_id = statement.evidence[0].source_id
new_id = old_s.evidence[0].source_id
if type(old_s) == ist.Complex and old_id == new_id:
old_statement_members = \
[m.db_refs['TEXT'] for m in old_s.members]
old_statement_members = sorted(old_statement_members)
new_statement_members = [m.db_refs['TEXT']
for m in statement.members]
new_statement_members = sorted(new_statement_members)
if old_statement_members == new_statement_members:
already_have = True
break
if not already_have:
self.statements.append(statement) |
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, 14; 5, 21; 5, 33; 5, 48; 5, 52; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:p; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:pb; 12, identifier:controlsExpressionWithTemplateReac; 13, argument_list; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:s; 17, call; 17, 18; 17, 19; 18, identifier:_bpp; 19, argument_list; 19, 20; 20, string:'Searcher'; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:res; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:s; 27, identifier:searchPlain; 28, argument_list; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:model; 32, identifier:p; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:res_array; 36, list_comprehension; 36, 37; 36, 41; 37, call; 37, 38; 37, 39; 38, identifier:_match_to_array; 39, argument_list; 39, 40; 40, identifier:m; 41, for_in_clause; 41, 42; 41, 43; 42, identifier:m; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:res; 46, identifier:toArray; 47, argument_list; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:stmts; 51, list:[]; 52, for_statement; 52, 53; 52, 54; 52, 55; 53, identifier:res; 54, identifier:res_array; 55, block; 55, 56; 55, 58; 55, 69; 55, 75; 55, 84; 55, 90; 55, 98; 55, 126; 55, 138; 55, 158; 55, 164; 55, 172; 55, 183; 55, 192; 56, expression_statement; 56, 57; 57, string:'''
controller_er = res[p.indexOf('controller ER')]
generic_controller_er = res[p.indexOf('generic controller ER')]
controller_simple_pe = res[p.indexOf('controller simple PE')]
controller_pe = res[p.indexOf('controller PE')]
control = res[p.indexOf('Control')]
conversion = res[p.indexOf('Conversion')]
input_pe = res[p.indexOf('input PE')]
input_simple_pe = res[p.indexOf('input simple PE')]
changed_generic_er = res[p.indexOf('changed generic ER')]
output_pe = res[p.indexOf('output PE')]
output_simple_pe = res[p.indexOf('output simple PE')]
changed_er = res[p.indexOf('changed ER')]
'''; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:controller; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:_get_agents_from_entity; 65, argument_list; 65, 66; 66, subscript; 66, 67; 66, 68; 67, identifier:res; 68, integer:2; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:controlled_pe; 72, subscript; 72, 73; 72, 74; 73, identifier:res; 74, integer:6; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:controlled; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:_get_agents_from_entity; 82, argument_list; 82, 83; 83, identifier:controlled_pe; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:conversion; 87, subscript; 87, 88; 87, 89; 88, identifier:res; 89, integer:5; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:direction; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:conversion; 96, identifier:getTemplateDirection; 97, argument_list; 98, if_statement; 98, 99; 98, 102; 99, comparison_operator:is; 99, 100; 99, 101; 100, identifier:direction; 101, None; 102, block; 102, 103; 102, 111; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:direction; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:direction; 109, identifier:name; 110, argument_list; 111, if_statement; 111, 112; 111, 115; 112, comparison_operator:!=; 112, 113; 112, 114; 113, identifier:direction; 114, string:'FORWARD'; 115, block; 115, 116; 115, 125; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:logger; 120, identifier:warning; 121, argument_list; 121, 122; 122, binary_operator:%; 122, 123; 122, 124; 123, string:'Unhandled conversion direction %s'; 124, identifier:direction; 125, continue_statement; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:int_type; 129, call; 129, 130; 129, 137; 130, attribute; 130, 131; 130, 136; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:conversion; 134, identifier:getInteractionType; 135, argument_list; 136, identifier:toArray; 137, argument_list; 138, if_statement; 138, 139; 138, 140; 139, identifier:int_type; 140, block; 140, 141; 141, for_statement; 141, 142; 141, 143; 141, 144; 142, identifier:it; 143, identifier:int_type; 144, block; 144, 145; 145, for_statement; 145, 146; 145, 147; 145, 156; 146, identifier:term; 147, call; 147, 148; 147, 155; 148, attribute; 148, 149; 148, 154; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:it; 152, identifier:getTerm; 153, argument_list; 154, identifier:toArray; 155, argument_list; 156, block; 156, 157; 157, pass_statement; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:control; 161, subscript; 161, 162; 161, 163; 162, identifier:res; 163, integer:4; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:control_type; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:control; 170, identifier:getControlType; 171, argument_list; 172, if_statement; 172, 173; 172, 174; 173, identifier:control_type; 174, block; 174, 175; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:control_type; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:control_type; 181, identifier:name; 182, argument_list; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:ev; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:self; 189, identifier:_get_evidence; 190, argument_list; 190, 191; 191, identifier:control; 192, for_statement; 192, 193; 192, 196; 192, 209; 193, pattern_list; 193, 194; 193, 195; 194, identifier:subj; 195, identifier:obj; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:itertools; 199, identifier:product; 200, argument_list; 200, 201; 200, 205; 201, call; 201, 202; 201, 203; 202, identifier:_listify; 203, argument_list; 203, 204; 204, identifier:controller; 205, call; 205, 206; 205, 207; 206, identifier:_listify; 207, argument_list; 207, 208; 208, identifier:controlled; 209, block; 209, 210; 209, 218; 209, 224; 209, 268; 209, 278; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:subj_act; 213, call; 213, 214; 213, 215; 214, identifier:ActivityCondition; 215, argument_list; 215, 216; 215, 217; 216, string:'transcription'; 217, True; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:subj; 222, identifier:activity; 223, identifier:subj_act; 224, if_statement; 224, 225; 224, 228; 224, 240; 224, 256; 225, comparison_operator:==; 225, 226; 225, 227; 226, identifier:control_type; 227, string:'ACTIVATION'; 228, block; 228, 229; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:st; 232, call; 232, 233; 232, 234; 233, identifier:IncreaseAmount; 234, argument_list; 234, 235; 234, 236; 234, 237; 235, identifier:subj; 236, identifier:obj; 237, keyword_argument; 237, 238; 237, 239; 238, identifier:evidence; 239, identifier:ev; 240, elif_clause; 240, 241; 240, 244; 241, comparison_operator:==; 241, 242; 241, 243; 242, identifier:control_type; 243, string:'INHIBITION'; 244, block; 244, 245; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:st; 248, call; 248, 249; 248, 250; 249, identifier:DecreaseAmount; 250, argument_list; 250, 251; 250, 252; 250, 253; 251, identifier:subj; 252, identifier:obj; 253, keyword_argument; 253, 254; 253, 255; 254, identifier:evidence; 255, identifier:ev; 256, else_clause; 256, 257; 257, block; 257, 258; 257, 267; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:logger; 262, identifier:warning; 263, argument_list; 263, 264; 264, binary_operator:%; 264, 265; 264, 266; 265, string:'Unhandled control type %s'; 266, identifier:control_type; 267, continue_statement; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:st_dec; 271, call; 271, 272; 271, 273; 272, identifier:decode_obj; 273, argument_list; 273, 274; 273, 275; 274, identifier:st; 275, keyword_argument; 275, 276; 275, 277; 276, identifier:encoding; 277, string:'utf-8'; 278, expression_statement; 278, 279; 279, call; 279, 280; 279, 285; 280, attribute; 280, 281; 280, 284; 281, attribute; 281, 282; 281, 283; 282, identifier:self; 283, identifier:statements; 284, identifier:append; 285, argument_list; 285, 286; 286, identifier:st_dec | def get_regulate_amounts(self):
p = pb.controlsExpressionWithTemplateReac()
s = _bpp('Searcher')
res = s.searchPlain(self.model, p)
res_array = [_match_to_array(m) for m in res.toArray()]
stmts = []
for res in res_array:
'''
controller_er = res[p.indexOf('controller ER')]
generic_controller_er = res[p.indexOf('generic controller ER')]
controller_simple_pe = res[p.indexOf('controller simple PE')]
controller_pe = res[p.indexOf('controller PE')]
control = res[p.indexOf('Control')]
conversion = res[p.indexOf('Conversion')]
input_pe = res[p.indexOf('input PE')]
input_simple_pe = res[p.indexOf('input simple PE')]
changed_generic_er = res[p.indexOf('changed generic ER')]
output_pe = res[p.indexOf('output PE')]
output_simple_pe = res[p.indexOf('output simple PE')]
changed_er = res[p.indexOf('changed ER')]
'''
controller = self._get_agents_from_entity(res[2])
controlled_pe = res[6]
controlled = self._get_agents_from_entity(controlled_pe)
conversion = res[5]
direction = conversion.getTemplateDirection()
if direction is not None:
direction = direction.name()
if direction != 'FORWARD':
logger.warning('Unhandled conversion direction %s' %
direction)
continue
int_type = conversion.getInteractionType().toArray()
if int_type:
for it in int_type:
for term in it.getTerm().toArray():
pass
control = res[4]
control_type = control.getControlType()
if control_type:
control_type = control_type.name()
ev = self._get_evidence(control)
for subj, obj in itertools.product(_listify(controller),
_listify(controlled)):
subj_act = ActivityCondition('transcription', True)
subj.activity = subj_act
if control_type == 'ACTIVATION':
st = IncreaseAmount(subj, obj, evidence=ev)
elif control_type == 'INHIBITION':
st = DecreaseAmount(subj, obj, evidence=ev)
else:
logger.warning('Unhandled control type %s' % control_type)
continue
st_dec = decode_obj(st, encoding='utf-8')
self.statements.append(st_dec) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_gef; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 5, 21; 5, 33; 5, 48; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:p; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:_gef_gap_base; 13, argument_list; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:s; 17, call; 17, 18; 17, 19; 18, identifier:_bpp; 19, argument_list; 19, 20; 20, string:'Searcher'; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:res; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:s; 27, identifier:searchPlain; 28, argument_list; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:model; 32, identifier:p; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:res_array; 36, list_comprehension; 36, 37; 36, 41; 37, call; 37, 38; 37, 39; 38, identifier:_match_to_array; 39, argument_list; 39, 40; 40, identifier:m; 41, for_in_clause; 41, 42; 41, 43; 42, identifier:m; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:res; 46, identifier:toArray; 47, argument_list; 48, for_statement; 48, 49; 48, 50; 48, 51; 49, identifier:r; 50, identifier:res_array; 51, block; 51, 52; 51, 63; 51, 74; 51, 85; 51, 96; 51, 107; 51, 118; 51, 129; 51, 136; 51, 145; 51, 154; 51, 162; 51, 171; 51, 175; 51, 196; 51, 200; 51, 221; 51, 229; 51, 238; 51, 247; 51, 256; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:controller_pe; 55, subscript; 55, 56; 55, 57; 56, identifier:r; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:p; 60, identifier:indexOf; 61, argument_list; 61, 62; 62, string:'controller PE'; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:input_pe; 66, subscript; 66, 67; 66, 68; 67, identifier:r; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:p; 71, identifier:indexOf; 72, argument_list; 72, 73; 73, string:'input PE'; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:input_spe; 77, subscript; 77, 78; 77, 79; 78, identifier:r; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:p; 82, identifier:indexOf; 83, argument_list; 83, 84; 84, string:'input simple PE'; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:output_pe; 88, subscript; 88, 89; 88, 90; 89, identifier:r; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:p; 93, identifier:indexOf; 94, argument_list; 94, 95; 95, string:'output PE'; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:output_spe; 99, subscript; 99, 100; 99, 101; 100, identifier:r; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:p; 104, identifier:indexOf; 105, argument_list; 105, 106; 106, string:'output simple PE'; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:reaction; 110, subscript; 110, 111; 110, 112; 111, identifier:r; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:p; 115, identifier:indexOf; 116, argument_list; 116, 117; 117, string:'Conversion'; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:control; 121, subscript; 121, 122; 121, 123; 122, identifier:r; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:p; 126, identifier:indexOf; 127, argument_list; 127, 128; 128, string:'Control'; 129, if_statement; 129, 130; 129, 134; 130, call; 130, 131; 130, 132; 131, identifier:_is_complex; 132, argument_list; 132, 133; 133, identifier:controller_pe; 134, block; 134, 135; 135, continue_statement; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:members_in; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:self; 142, identifier:_get_complex_members; 143, argument_list; 143, 144; 144, identifier:input_pe; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:members_out; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:_get_complex_members; 152, argument_list; 152, 153; 153, identifier:output_pe; 154, if_statement; 154, 155; 154, 160; 155, not_operator; 155, 156; 156, parenthesized_expression; 156, 157; 157, boolean_operator:and; 157, 158; 157, 159; 158, identifier:members_in; 159, identifier:members_out; 160, block; 160, 161; 161, continue_statement; 162, if_statement; 162, 163; 162, 169; 163, comparison_operator:!=; 163, 164; 163, 168; 164, call; 164, 165; 164, 166; 165, identifier:len; 166, argument_list; 166, 167; 167, identifier:members_out; 168, integer:2; 169, block; 169, 170; 170, continue_statement; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:gdp_in; 174, False; 175, for_statement; 175, 176; 175, 177; 175, 178; 176, identifier:member; 177, identifier:members_in; 178, block; 178, 179; 179, if_statement; 179, 180; 179, 191; 180, boolean_operator:and; 180, 181; 180, 186; 181, call; 181, 182; 181, 183; 182, identifier:isinstance; 183, argument_list; 183, 184; 183, 185; 184, identifier:member; 185, identifier:Agent; 186, comparison_operator:==; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:member; 189, identifier:name; 190, string:'GDP'; 191, block; 191, 192; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:gdp_in; 195, True; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:gtp_out; 199, False; 200, for_statement; 200, 201; 200, 202; 200, 203; 201, identifier:member; 202, identifier:members_out; 203, block; 203, 204; 204, if_statement; 204, 205; 204, 216; 205, boolean_operator:and; 205, 206; 205, 211; 206, call; 206, 207; 206, 208; 207, identifier:isinstance; 208, argument_list; 208, 209; 208, 210; 209, identifier:member; 210, identifier:Agent; 211, comparison_operator:==; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:member; 214, identifier:name; 215, string:'GTP'; 216, block; 216, 217; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:gtp_out; 220, True; 221, if_statement; 221, 222; 221, 227; 222, not_operator; 222, 223; 223, parenthesized_expression; 223, 224; 224, boolean_operator:and; 224, 225; 224, 226; 225, identifier:gdp_in; 226, identifier:gtp_out; 227, block; 227, 228; 228, continue_statement; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:ras_list; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:self; 235, identifier:_get_agents_from_entity; 236, argument_list; 236, 237; 237, identifier:input_spe; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:gef_list; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:self; 244, identifier:_get_agents_from_entity; 245, argument_list; 245, 246; 246, identifier:controller_pe; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:ev; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:self; 253, identifier:_get_evidence; 254, argument_list; 254, 255; 255, identifier:control; 256, for_statement; 256, 257; 256, 260; 256, 273; 257, pattern_list; 257, 258; 257, 259; 258, identifier:gef; 259, identifier:ras; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:itertools; 263, identifier:product; 264, argument_list; 264, 265; 264, 269; 265, call; 265, 266; 265, 267; 266, identifier:_listify; 267, argument_list; 267, 268; 268, identifier:gef_list; 269, call; 269, 270; 269, 271; 270, identifier:_listify; 271, argument_list; 271, 272; 272, identifier:ras_list; 273, block; 273, 274; 273, 285; 273, 295; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 277; 276, identifier:st; 277, call; 277, 278; 277, 279; 278, identifier:Gef; 279, argument_list; 279, 280; 279, 281; 279, 282; 280, identifier:gef; 281, identifier:ras; 282, keyword_argument; 282, 283; 282, 284; 283, identifier:evidence; 284, identifier:ev; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:st_dec; 288, call; 288, 289; 288, 290; 289, identifier:decode_obj; 290, argument_list; 290, 291; 290, 292; 291, identifier:st; 292, keyword_argument; 292, 293; 292, 294; 293, identifier:encoding; 294, string:'utf-8'; 295, expression_statement; 295, 296; 296, call; 296, 297; 296, 302; 297, attribute; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:self; 300, identifier:statements; 301, identifier:append; 302, argument_list; 302, 303; 303, identifier:st_dec | def get_gef(self):
p = self._gef_gap_base()
s = _bpp('Searcher')
res = s.searchPlain(self.model, p)
res_array = [_match_to_array(m) for m in res.toArray()]
for r in res_array:
controller_pe = r[p.indexOf('controller PE')]
input_pe = r[p.indexOf('input PE')]
input_spe = r[p.indexOf('input simple PE')]
output_pe = r[p.indexOf('output PE')]
output_spe = r[p.indexOf('output simple PE')]
reaction = r[p.indexOf('Conversion')]
control = r[p.indexOf('Control')]
if _is_complex(controller_pe):
continue
members_in = self._get_complex_members(input_pe)
members_out = self._get_complex_members(output_pe)
if not (members_in and members_out):
continue
if len(members_out) != 2:
continue
gdp_in = False
for member in members_in:
if isinstance(member, Agent) and member.name == 'GDP':
gdp_in = True
gtp_out = False
for member in members_out:
if isinstance(member, Agent) and member.name == 'GTP':
gtp_out = True
if not (gdp_in and gtp_out):
continue
ras_list = self._get_agents_from_entity(input_spe)
gef_list = self._get_agents_from_entity(controller_pe)
ev = self._get_evidence(control)
for gef, ras in itertools.product(_listify(gef_list),
_listify(ras_list)):
st = Gef(gef, ras, evidence=ev)
st_dec = decode_obj(st, encoding='utf-8')
self.statements.append(st_dec) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_gap; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 5, 21; 5, 33; 5, 48; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:p; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:_gef_gap_base; 13, argument_list; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:s; 17, call; 17, 18; 17, 19; 18, identifier:_bpp; 19, argument_list; 19, 20; 20, string:'Searcher'; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:res; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:s; 27, identifier:searchPlain; 28, argument_list; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:model; 32, identifier:p; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:res_array; 36, list_comprehension; 36, 37; 36, 41; 37, call; 37, 38; 37, 39; 38, identifier:_match_to_array; 39, argument_list; 39, 40; 40, identifier:m; 41, for_in_clause; 41, 42; 41, 43; 42, identifier:m; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:res; 46, identifier:toArray; 47, argument_list; 48, for_statement; 48, 49; 48, 50; 48, 51; 49, identifier:r; 50, identifier:res_array; 51, block; 51, 52; 51, 63; 51, 74; 51, 85; 51, 96; 51, 107; 51, 118; 51, 129; 51, 136; 51, 145; 51, 154; 51, 162; 51, 171; 51, 175; 51, 196; 51, 200; 51, 221; 51, 229; 51, 238; 51, 247; 51, 256; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:controller_pe; 55, subscript; 55, 56; 55, 57; 56, identifier:r; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:p; 60, identifier:indexOf; 61, argument_list; 61, 62; 62, string:'controller PE'; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:input_pe; 66, subscript; 66, 67; 66, 68; 67, identifier:r; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:p; 71, identifier:indexOf; 72, argument_list; 72, 73; 73, string:'input PE'; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:input_spe; 77, subscript; 77, 78; 77, 79; 78, identifier:r; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:p; 82, identifier:indexOf; 83, argument_list; 83, 84; 84, string:'input simple PE'; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:output_pe; 88, subscript; 88, 89; 88, 90; 89, identifier:r; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:p; 93, identifier:indexOf; 94, argument_list; 94, 95; 95, string:'output PE'; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:output_spe; 99, subscript; 99, 100; 99, 101; 100, identifier:r; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:p; 104, identifier:indexOf; 105, argument_list; 105, 106; 106, string:'output simple PE'; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:reaction; 110, subscript; 110, 111; 110, 112; 111, identifier:r; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:p; 115, identifier:indexOf; 116, argument_list; 116, 117; 117, string:'Conversion'; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:control; 121, subscript; 121, 122; 121, 123; 122, identifier:r; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:p; 126, identifier:indexOf; 127, argument_list; 127, 128; 128, string:'Control'; 129, if_statement; 129, 130; 129, 134; 130, call; 130, 131; 130, 132; 131, identifier:_is_complex; 132, argument_list; 132, 133; 133, identifier:controller_pe; 134, block; 134, 135; 135, continue_statement; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:members_in; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:self; 142, identifier:_get_complex_members; 143, argument_list; 143, 144; 144, identifier:input_pe; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:members_out; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:_get_complex_members; 152, argument_list; 152, 153; 153, identifier:output_pe; 154, if_statement; 154, 155; 154, 160; 155, not_operator; 155, 156; 156, parenthesized_expression; 156, 157; 157, boolean_operator:and; 157, 158; 157, 159; 158, identifier:members_in; 159, identifier:members_out; 160, block; 160, 161; 161, continue_statement; 162, if_statement; 162, 163; 162, 169; 163, comparison_operator:!=; 163, 164; 163, 168; 164, call; 164, 165; 164, 166; 165, identifier:len; 166, argument_list; 166, 167; 167, identifier:members_out; 168, integer:2; 169, block; 169, 170; 170, continue_statement; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:gtp_in; 174, False; 175, for_statement; 175, 176; 175, 177; 175, 178; 176, identifier:member; 177, identifier:members_in; 178, block; 178, 179; 179, if_statement; 179, 180; 179, 191; 180, boolean_operator:and; 180, 181; 180, 186; 181, call; 181, 182; 181, 183; 182, identifier:isinstance; 183, argument_list; 183, 184; 183, 185; 184, identifier:member; 185, identifier:Agent; 186, comparison_operator:==; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:member; 189, identifier:name; 190, string:'GTP'; 191, block; 191, 192; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:gtp_in; 195, True; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:gdp_out; 199, False; 200, for_statement; 200, 201; 200, 202; 200, 203; 201, identifier:member; 202, identifier:members_out; 203, block; 203, 204; 204, if_statement; 204, 205; 204, 216; 205, boolean_operator:and; 205, 206; 205, 211; 206, call; 206, 207; 206, 208; 207, identifier:isinstance; 208, argument_list; 208, 209; 208, 210; 209, identifier:member; 210, identifier:Agent; 211, comparison_operator:==; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:member; 214, identifier:name; 215, string:'GDP'; 216, block; 216, 217; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:gdp_out; 220, True; 221, if_statement; 221, 222; 221, 227; 222, not_operator; 222, 223; 223, parenthesized_expression; 223, 224; 224, boolean_operator:and; 224, 225; 224, 226; 225, identifier:gtp_in; 226, identifier:gdp_out; 227, block; 227, 228; 228, continue_statement; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:ras_list; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:self; 235, identifier:_get_agents_from_entity; 236, argument_list; 236, 237; 237, identifier:input_spe; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:gap_list; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:self; 244, identifier:_get_agents_from_entity; 245, argument_list; 245, 246; 246, identifier:controller_pe; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:ev; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:self; 253, identifier:_get_evidence; 254, argument_list; 254, 255; 255, identifier:control; 256, for_statement; 256, 257; 256, 260; 256, 273; 257, pattern_list; 257, 258; 257, 259; 258, identifier:gap; 259, identifier:ras; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:itertools; 263, identifier:product; 264, argument_list; 264, 265; 264, 269; 265, call; 265, 266; 265, 267; 266, identifier:_listify; 267, argument_list; 267, 268; 268, identifier:gap_list; 269, call; 269, 270; 269, 271; 270, identifier:_listify; 271, argument_list; 271, 272; 272, identifier:ras_list; 273, block; 273, 274; 273, 285; 273, 295; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 277; 276, identifier:st; 277, call; 277, 278; 277, 279; 278, identifier:Gap; 279, argument_list; 279, 280; 279, 281; 279, 282; 280, identifier:gap; 281, identifier:ras; 282, keyword_argument; 282, 283; 282, 284; 283, identifier:evidence; 284, identifier:ev; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:st_dec; 288, call; 288, 289; 288, 290; 289, identifier:decode_obj; 290, argument_list; 290, 291; 290, 292; 291, identifier:st; 292, keyword_argument; 292, 293; 292, 294; 293, identifier:encoding; 294, string:'utf-8'; 295, expression_statement; 295, 296; 296, call; 296, 297; 296, 302; 297, attribute; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:self; 300, identifier:statements; 301, identifier:append; 302, argument_list; 302, 303; 303, identifier:st_dec | def get_gap(self):
p = self._gef_gap_base()
s = _bpp('Searcher')
res = s.searchPlain(self.model, p)
res_array = [_match_to_array(m) for m in res.toArray()]
for r in res_array:
controller_pe = r[p.indexOf('controller PE')]
input_pe = r[p.indexOf('input PE')]
input_spe = r[p.indexOf('input simple PE')]
output_pe = r[p.indexOf('output PE')]
output_spe = r[p.indexOf('output simple PE')]
reaction = r[p.indexOf('Conversion')]
control = r[p.indexOf('Control')]
if _is_complex(controller_pe):
continue
members_in = self._get_complex_members(input_pe)
members_out = self._get_complex_members(output_pe)
if not (members_in and members_out):
continue
if len(members_out) != 2:
continue
gtp_in = False
for member in members_in:
if isinstance(member, Agent) and member.name == 'GTP':
gtp_in = True
gdp_out = False
for member in members_out:
if isinstance(member, Agent) and member.name == 'GDP':
gdp_out = True
if not (gtp_in and gdp_out):
continue
ras_list = self._get_agents_from_entity(input_spe)
gap_list = self._get_agents_from_entity(controller_pe)
ev = self._get_evidence(control)
for gap, ras in itertools.product(_listify(gap_list),
_listify(ras_list)):
st = Gap(gap, ras, evidence=ev)
st_dec = decode_obj(st, encoding='utf-8')
self.statements.append(st_dec) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_get_generic_modification; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:mod_class; 6, block; 6, 7; 6, 13; 6, 40; 6, 48; 6, 56; 6, 69; 6, 76; 6, 88; 6, 103; 6, 107; 6, 377; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:mod_type; 10, subscript; 10, 11; 10, 12; 11, identifier:modclass_to_modtype; 12, identifier:mod_class; 13, if_statement; 13, 14; 13, 19; 13, 32; 14, call; 14, 15; 14, 16; 15, identifier:issubclass; 16, argument_list; 16, 17; 16, 18; 17, identifier:mod_class; 18, identifier:RemoveModification; 19, block; 19, 20; 19, 26; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:mod_gain_const; 23, attribute; 23, 24; 23, 25; 24, identifier:mcct; 25, identifier:LOSS; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:mod_type; 29, subscript; 29, 30; 29, 31; 30, identifier:modtype_to_inverse; 31, identifier:mod_type; 32, else_clause; 32, 33; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:mod_gain_const; 37, attribute; 37, 38; 37, 39; 38, identifier:mcct; 39, identifier:GAIN; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:mod_filter; 43, subscript; 43, 44; 43, 45; 44, identifier:mod_type; 45, slice; 45, 46; 45, 47; 46, colon; 47, integer:5; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:p; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:BiopaxProcessor; 54, identifier:_construct_modification_pattern; 55, argument_list; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:p; 60, identifier:add; 61, argument_list; 61, 62; 61, 67; 61, 68; 62, call; 62, 63; 62, 64; 63, identifier:mcc; 64, argument_list; 64, 65; 64, 66; 65, identifier:mod_gain_const; 66, identifier:mod_filter; 67, string:"input simple PE"; 68, string:"output simple PE"; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:s; 72, call; 72, 73; 72, 74; 73, identifier:_bpp; 74, argument_list; 74, 75; 75, string:'Searcher'; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:res; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:s; 82, identifier:searchPlain; 83, argument_list; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:model; 87, identifier:p; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:res_array; 91, list_comprehension; 91, 92; 91, 96; 92, call; 92, 93; 92, 94; 93, identifier:_match_to_array; 94, argument_list; 94, 95; 95, identifier:m; 96, for_in_clause; 96, 97; 96, 98; 97, identifier:m; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:res; 101, identifier:toArray; 102, argument_list; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:stmts; 106, list:[]; 107, for_statement; 107, 108; 107, 109; 107, 110; 108, identifier:r; 109, identifier:res_array; 110, block; 110, 111; 110, 122; 110, 133; 110, 144; 110, 155; 110, 166; 110, 177; 110, 185; 110, 193; 110, 221; 110, 230; 110, 235; 110, 237; 110, 249; 110, 258; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:controller_pe; 114, subscript; 114, 115; 114, 116; 115, identifier:r; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:p; 119, identifier:indexOf; 120, argument_list; 120, 121; 121, string:'controller PE'; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:input_pe; 125, subscript; 125, 126; 125, 127; 126, identifier:r; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:p; 130, identifier:indexOf; 131, argument_list; 131, 132; 132, string:'input PE'; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:input_spe; 136, subscript; 136, 137; 136, 138; 137, identifier:r; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:p; 141, identifier:indexOf; 142, argument_list; 142, 143; 143, string:'input simple PE'; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:output_spe; 147, subscript; 147, 148; 147, 149; 148, identifier:r; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:p; 152, identifier:indexOf; 153, argument_list; 153, 154; 154, string:'output simple PE'; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:reaction; 158, subscript; 158, 159; 158, 160; 159, identifier:r; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:p; 163, identifier:indexOf; 164, argument_list; 164, 165; 165, string:'Conversion'; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:control; 169, subscript; 169, 170; 169, 171; 170, identifier:r; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:p; 174, identifier:indexOf; 175, argument_list; 175, 176; 176, string:'Control'; 177, if_statement; 177, 178; 177, 183; 178, not_operator; 178, 179; 179, call; 179, 180; 179, 181; 180, identifier:_is_catalysis; 181, argument_list; 181, 182; 182, identifier:control; 183, block; 183, 184; 184, continue_statement; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:cat_dir; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:control; 191, identifier:getCatalysisDirection; 192, argument_list; 193, if_statement; 193, 194; 193, 205; 194, boolean_operator:and; 194, 195; 194, 198; 195, comparison_operator:is; 195, 196; 195, 197; 196, identifier:cat_dir; 197, None; 198, comparison_operator:!=; 198, 199; 198, 204; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:cat_dir; 202, identifier:name; 203, argument_list; 204, string:'LEFT_TO_RIGHT'; 205, block; 205, 206; 205, 220; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:logger; 210, identifier:debug; 211, argument_list; 211, 212; 212, binary_operator:%; 212, 213; 212, 214; 212, 215; 213, string:'Unexpected catalysis direction: %s.'; 214, line_continuation:\; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:control; 218, identifier:getCatalysisDirection; 219, argument_list; 220, continue_statement; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:enzs; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:BiopaxProcessor; 227, identifier:_get_primary_controller; 228, argument_list; 228, 229; 229, identifier:controller_pe; 230, if_statement; 230, 231; 230, 233; 231, not_operator; 231, 232; 232, identifier:enzs; 233, block; 233, 234; 234, continue_statement; 235, expression_statement; 235, 236; 236, string:'''
if _is_complex(input_pe):
sub_members_in = self._get_complex_members(input_pe)
sub_members_out = self._get_complex_members(output_pe)
logger.info('Cannot handle complex substrates.')
continue
'''; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:subs; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:BiopaxProcessor; 243, identifier:_get_agents_from_entity; 244, argument_list; 244, 245; 244, 246; 245, identifier:input_spe; 246, keyword_argument; 246, 247; 246, 248; 247, identifier:expand_pe; 248, False; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:ev; 252, call; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:self; 255, identifier:_get_evidence; 256, argument_list; 256, 257; 257, identifier:control; 258, for_statement; 258, 259; 258, 262; 258, 275; 259, pattern_list; 259, 260; 259, 261; 260, identifier:enz; 261, identifier:sub; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:itertools; 265, identifier:product; 266, argument_list; 266, 267; 266, 271; 267, call; 267, 268; 267, 269; 268, identifier:_listify; 269, argument_list; 269, 270; 270, identifier:enzs; 271, call; 271, 272; 271, 273; 272, identifier:_listify; 273, argument_list; 273, 274; 274, identifier:subs; 275, block; 275, 276; 275, 286; 275, 296; 275, 306; 275, 331; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 277, 280; 278, identifier:mod_in; 279, line_continuation:\; 280, call; 280, 281; 280, 284; 281, attribute; 281, 282; 281, 283; 282, identifier:BiopaxProcessor; 283, identifier:_get_entity_mods; 284, argument_list; 284, 285; 285, identifier:input_spe; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 287, 290; 288, identifier:mod_out; 289, line_continuation:\; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:BiopaxProcessor; 293, identifier:_get_entity_mods; 294, argument_list; 294, 295; 295, identifier:output_spe; 296, expression_statement; 296, 297; 297, assignment; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:sub; 300, identifier:mods; 301, call; 301, 302; 301, 303; 302, identifier:_get_mod_intersection; 303, argument_list; 303, 304; 303, 305; 304, identifier:mod_in; 305, identifier:mod_out; 306, if_statement; 306, 307; 306, 312; 306, 321; 307, call; 307, 308; 307, 309; 308, identifier:issubclass; 309, argument_list; 309, 310; 309, 311; 310, identifier:mod_class; 311, identifier:AddModification; 312, block; 312, 313; 313, expression_statement; 313, 314; 314, assignment; 314, 315; 314, 316; 315, identifier:gained_mods; 316, call; 316, 317; 316, 318; 317, identifier:_get_mod_difference; 318, argument_list; 318, 319; 318, 320; 319, identifier:mod_out; 320, identifier:mod_in; 321, else_clause; 321, 322; 322, block; 322, 323; 323, expression_statement; 323, 324; 324, assignment; 324, 325; 324, 326; 325, identifier:gained_mods; 326, call; 326, 327; 326, 328; 327, identifier:_get_mod_difference; 328, argument_list; 328, 329; 328, 330; 329, identifier:mod_in; 330, identifier:mod_out; 331, for_statement; 331, 332; 331, 333; 331, 334; 332, identifier:mod; 333, identifier:gained_mods; 334, block; 334, 335; 334, 347; 334, 364; 335, if_statement; 335, 336; 335, 345; 336, comparison_operator:not; 336, 337; 336, 340; 337, attribute; 337, 338; 337, 339; 338, identifier:mod; 339, identifier:mod_type; 340, tuple; 340, 341; 340, 342; 341, identifier:mod_type; 342, subscript; 342, 343; 342, 344; 343, identifier:modtype_to_inverse; 344, identifier:mod_type; 345, block; 345, 346; 346, continue_statement; 347, expression_statement; 347, 348; 348, assignment; 348, 349; 348, 350; 349, identifier:stmt; 350, call; 350, 351; 350, 352; 351, identifier:mod_class; 352, argument_list; 352, 353; 352, 354; 352, 355; 352, 358; 352, 361; 353, identifier:enz; 354, identifier:sub; 355, attribute; 355, 356; 355, 357; 356, identifier:mod; 357, identifier:residue; 358, attribute; 358, 359; 358, 360; 359, identifier:mod; 360, identifier:position; 361, keyword_argument; 361, 362; 361, 363; 362, identifier:evidence; 363, identifier:ev; 364, expression_statement; 364, 365; 365, call; 365, 366; 365, 369; 366, attribute; 366, 367; 366, 368; 367, identifier:stmts; 368, identifier:append; 369, argument_list; 369, 370; 370, call; 370, 371; 370, 372; 371, identifier:decode_obj; 372, argument_list; 372, 373; 372, 374; 373, identifier:stmt; 374, keyword_argument; 374, 375; 374, 376; 375, identifier:encoding; 376, string:'utf-8'; 377, return_statement; 377, 378; 378, identifier:stmts | def _get_generic_modification(self, mod_class):
mod_type = modclass_to_modtype[mod_class]
if issubclass(mod_class, RemoveModification):
mod_gain_const = mcct.LOSS
mod_type = modtype_to_inverse[mod_type]
else:
mod_gain_const = mcct.GAIN
mod_filter = mod_type[:5]
p = BiopaxProcessor._construct_modification_pattern()
p.add(mcc(mod_gain_const, mod_filter),
"input simple PE", "output simple PE")
s = _bpp('Searcher')
res = s.searchPlain(self.model, p)
res_array = [_match_to_array(m) for m in res.toArray()]
stmts = []
for r in res_array:
controller_pe = r[p.indexOf('controller PE')]
input_pe = r[p.indexOf('input PE')]
input_spe = r[p.indexOf('input simple PE')]
output_spe = r[p.indexOf('output simple PE')]
reaction = r[p.indexOf('Conversion')]
control = r[p.indexOf('Control')]
if not _is_catalysis(control):
continue
cat_dir = control.getCatalysisDirection()
if cat_dir is not None and cat_dir.name() != 'LEFT_TO_RIGHT':
logger.debug('Unexpected catalysis direction: %s.' % \
control.getCatalysisDirection())
continue
enzs = BiopaxProcessor._get_primary_controller(controller_pe)
if not enzs:
continue
'''
if _is_complex(input_pe):
sub_members_in = self._get_complex_members(input_pe)
sub_members_out = self._get_complex_members(output_pe)
logger.info('Cannot handle complex substrates.')
continue
'''
subs = BiopaxProcessor._get_agents_from_entity(input_spe,
expand_pe=False)
ev = self._get_evidence(control)
for enz, sub in itertools.product(_listify(enzs), _listify(subs)):
mod_in = \
BiopaxProcessor._get_entity_mods(input_spe)
mod_out = \
BiopaxProcessor._get_entity_mods(output_spe)
sub.mods = _get_mod_intersection(mod_in, mod_out)
if issubclass(mod_class, AddModification):
gained_mods = _get_mod_difference(mod_out, mod_in)
else:
gained_mods = _get_mod_difference(mod_in, mod_out)
for mod in gained_mods:
if mod.mod_type not in (mod_type,
modtype_to_inverse[mod_type]):
continue
stmt = mod_class(enz, sub, mod.residue, mod.position,
evidence=ev)
stmts.append(decode_obj(stmt, encoding='utf-8'))
return stmts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_extract_mod_from_feature; 3, parameters; 3, 4; 4, identifier:mf; 5, block; 5, 6; 5, 14; 5, 21; 5, 33; 5, 37; 5, 76; 5, 96; 5, 102; 5, 110; 5, 207; 5, 217; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:mf_type; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:mf; 12, identifier:getModificationType; 13, argument_list; 14, if_statement; 14, 15; 14, 18; 15, comparison_operator:is; 15, 16; 15, 17; 16, identifier:mf_type; 17, None; 18, block; 18, 19; 19, return_statement; 19, 20; 20, None; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:mf_type_terms; 24, call; 24, 25; 24, 32; 25, attribute; 25, 26; 25, 31; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:mf_type; 29, identifier:getTerm; 30, argument_list; 31, identifier:toArray; 32, argument_list; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:known_mf_type; 36, None; 37, for_statement; 37, 38; 37, 39; 37, 40; 38, identifier:t; 39, identifier:mf_type_terms; 40, block; 40, 41; 40, 57; 40, 66; 41, if_statement; 41, 42; 41, 48; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:t; 45, identifier:startswith; 46, argument_list; 46, 47; 47, string:'MOD_RES '; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:t; 52, subscript; 52, 53; 52, 54; 53, identifier:t; 54, slice; 54, 55; 54, 56; 55, integer:8; 56, colon; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:mf_type_indra; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:_mftype_dict; 63, identifier:get; 64, argument_list; 64, 65; 65, identifier:t; 66, if_statement; 66, 67; 66, 70; 67, comparison_operator:is; 67, 68; 67, 69; 68, identifier:mf_type_indra; 69, None; 70, block; 70, 71; 70, 75; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:known_mf_type; 74, identifier:mf_type_indra; 75, break_statement; 76, if_statement; 76, 77; 76, 79; 77, not_operator; 77, 78; 78, identifier:known_mf_type; 79, block; 79, 80; 79, 94; 80, expression_statement; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:logger; 84, identifier:debug; 85, argument_list; 85, 86; 86, binary_operator:%; 86, 87; 86, 88; 87, string:'Skipping modification with unknown terms: %s'; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, string:', '; 91, identifier:join; 92, argument_list; 92, 93; 93, identifier:mf_type_terms; 94, return_statement; 94, 95; 95, None; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 101; 98, pattern_list; 98, 99; 98, 100; 99, identifier:mod_type; 100, identifier:residue; 101, identifier:known_mf_type; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:mf_pos; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:mf; 108, identifier:getFeatureLocation; 109, argument_list; 110, if_statement; 110, 111; 110, 114; 110, 201; 111, comparison_operator:is; 111, 112; 111, 113; 112, identifier:mf_pos; 113, None; 114, block; 114, 115; 115, if_statement; 115, 116; 115, 126; 115, 131; 116, not_operator; 116, 117; 117, comparison_operator:==; 117, 118; 117, 125; 118, call; 118, 119; 118, 124; 119, attribute; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:mf_pos; 122, identifier:modelInterface; 123, identifier:getName; 124, argument_list; 125, string:'org.biopax.paxtools.model.level3.SequenceSite'; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:mod_pos; 130, None; 131, else_clause; 131, 132; 132, block; 132, 133; 132, 144; 132, 152; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:mf_site; 136, call; 136, 137; 136, 138; 137, identifier:cast; 138, argument_list; 138, 139; 138, 143; 139, call; 139, 140; 139, 141; 140, identifier:_bp; 141, argument_list; 141, 142; 142, string:'SequenceSite'; 143, identifier:mf_pos; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:mf_pos_status; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:mf_site; 150, identifier:getPositionStatus; 151, argument_list; 152, if_statement; 152, 153; 152, 156; 152, 161; 152, 185; 153, comparison_operator:is; 153, 154; 153, 155; 154, identifier:mf_pos_status; 155, None; 156, block; 156, 157; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:mod_pos; 160, None; 161, elif_clause; 161, 162; 161, 171; 162, boolean_operator:and; 162, 163; 162, 164; 163, identifier:mf_pos_status; 164, comparison_operator:!=; 164, 165; 164, 170; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:mf_pos_status; 168, identifier:toString; 169, argument_list; 170, string:'EQUAL'; 171, block; 171, 172; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:logger; 176, identifier:debug; 177, argument_list; 177, 178; 178, binary_operator:%; 178, 179; 178, 180; 179, string:'Modification site position is %s'; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:mf_pos_status; 183, identifier:toString; 184, argument_list; 185, else_clause; 185, 186; 186, block; 186, 187; 186, 195; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:mod_pos; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:mf_site; 193, identifier:getSequencePosition; 194, argument_list; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:mod_pos; 198, binary_operator:%; 198, 199; 198, 200; 199, string:'%s'; 200, identifier:mod_pos; 201, else_clause; 201, 202; 202, block; 202, 203; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:mod_pos; 206, None; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:mc; 210, call; 210, 211; 210, 212; 211, identifier:ModCondition; 212, argument_list; 212, 213; 212, 214; 212, 215; 212, 216; 213, identifier:mod_type; 214, identifier:residue; 215, identifier:mod_pos; 216, True; 217, return_statement; 217, 218; 218, identifier:mc | def _extract_mod_from_feature(mf):
mf_type = mf.getModificationType()
if mf_type is None:
return None
mf_type_terms = mf_type.getTerm().toArray()
known_mf_type = None
for t in mf_type_terms:
if t.startswith('MOD_RES '):
t = t[8:]
mf_type_indra = _mftype_dict.get(t)
if mf_type_indra is not None:
known_mf_type = mf_type_indra
break
if not known_mf_type:
logger.debug('Skipping modification with unknown terms: %s' %
', '.join(mf_type_terms))
return None
mod_type, residue = known_mf_type
mf_pos = mf.getFeatureLocation()
if mf_pos is not None:
if not mf_pos.modelInterface.getName() == \
'org.biopax.paxtools.model.level3.SequenceSite':
mod_pos = None
else:
mf_site = cast(_bp('SequenceSite'), mf_pos)
mf_pos_status = mf_site.getPositionStatus()
if mf_pos_status is None:
mod_pos = None
elif mf_pos_status and mf_pos_status.toString() != 'EQUAL':
logger.debug('Modification site position is %s' %
mf_pos_status.toString())
else:
mod_pos = mf_site.getSequencePosition()
mod_pos = '%s' % mod_pos
else:
mod_pos = None
mc = ModCondition(mod_type, residue, mod_pos, True)
return mc |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_activations; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 17; 5, 28; 5, 39; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:act_events; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:tree; 14, identifier:findall; 15, argument_list; 15, 16; 16, string:"EVENT/[type='ONT::ACTIVATE']"; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:inact_events; 20, call; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:tree; 25, identifier:findall; 26, argument_list; 26, 27; 27, string:"EVENT/[type='ONT::DEACTIVATE']"; 28, expression_statement; 28, 29; 29, augmented_assignment:+=; 29, 30; 29, 31; 30, identifier:inact_events; 31, call; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:tree; 36, identifier:findall; 37, argument_list; 37, 38; 38, string:"EVENT/[type='ONT::INHIBIT']"; 39, for_statement; 39, 40; 39, 41; 39, 45; 40, identifier:event; 41, parenthesized_expression; 41, 42; 42, binary_operator:+; 42, 43; 42, 44; 43, identifier:act_events; 44, identifier:inact_events; 45, block; 45, 46; 45, 54; 45, 62; 45, 71; 45, 77; 45, 88; 45, 101; 45, 111; 45, 117; 45, 126; 45, 139; 45, 150; 45, 163; 45, 173; 45, 186; 45, 190; 45, 255; 45, 264; 45, 273; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:event_id; 49, subscript; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:event; 52, identifier:attrib; 53, string:'id'; 54, if_statement; 54, 55; 54, 60; 55, comparison_operator:in; 55, 56; 55, 57; 56, identifier:event_id; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:_static_events; 60, block; 60, 61; 61, continue_statement; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:agent; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:event; 68, identifier:find; 69, argument_list; 69, 70; 70, string:".//*[@role=':AGENT']"; 71, if_statement; 71, 72; 71, 75; 72, comparison_operator:is; 72, 73; 72, 74; 73, identifier:agent; 74, None; 75, block; 75, 76; 76, continue_statement; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:agent_id; 80, call; 80, 81; 80, 86; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:agent; 84, identifier:attrib; 85, identifier:get; 86, argument_list; 86, 87; 87, string:'id'; 88, if_statement; 88, 89; 88, 92; 89, comparison_operator:is; 89, 90; 89, 91; 90, identifier:agent_id; 91, None; 92, block; 92, 93; 92, 100; 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:'Skipping activation with missing activator agent'; 100, continue_statement; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:activator_agent; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:_get_agent_by_id; 108, argument_list; 108, 109; 108, 110; 109, identifier:agent_id; 110, identifier:event_id; 111, if_statement; 111, 112; 111, 115; 112, comparison_operator:is; 112, 113; 112, 114; 113, identifier:activator_agent; 114, None; 115, block; 115, 116; 116, continue_statement; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:affected; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:event; 123, identifier:find; 124, argument_list; 124, 125; 125, string:".//*[@role=':AFFECTED']"; 126, if_statement; 126, 127; 126, 130; 127, comparison_operator:is; 127, 128; 127, 129; 128, identifier:affected; 129, None; 130, block; 130, 131; 130, 138; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:logger; 135, identifier:debug; 136, argument_list; 136, 137; 137, string:'Skipping activation with missing affected agent'; 138, continue_statement; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:affected_id; 142, call; 142, 143; 142, 148; 143, attribute; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:affected; 146, identifier:attrib; 147, identifier:get; 148, argument_list; 148, 149; 149, string:'id'; 150, if_statement; 150, 151; 150, 154; 151, comparison_operator:is; 151, 152; 151, 153; 152, identifier:affected_id; 153, None; 154, block; 154, 155; 154, 162; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:logger; 159, identifier:debug; 160, argument_list; 160, 161; 161, string:'Skipping activation with missing affected agent'; 162, continue_statement; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:affected_agent; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:self; 169, identifier:_get_agent_by_id; 170, argument_list; 170, 171; 170, 172; 171, identifier:affected_id; 172, identifier:event_id; 173, if_statement; 173, 174; 173, 177; 174, comparison_operator:is; 174, 175; 174, 176; 175, identifier:affected_agent; 176, None; 177, block; 177, 178; 177, 185; 178, expression_statement; 178, 179; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:logger; 182, identifier:debug; 183, argument_list; 183, 184; 184, string:'Skipping activation with missing affected agent'; 185, continue_statement; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:is_activation; 189, True; 190, if_statement; 190, 191; 190, 196; 190, 209; 190, 232; 191, call; 191, 192; 191, 193; 192, identifier:_is_type; 193, argument_list; 193, 194; 193, 195; 194, identifier:event; 195, string:'ONT::ACTIVATE'; 196, block; 196, 197; 197, expression_statement; 197, 198; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:self; 201, identifier:_add_extracted; 202, argument_list; 202, 203; 202, 204; 203, string:'ONT::ACTIVATE'; 204, subscript; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:event; 207, identifier:attrib; 208, string:'id'; 209, elif_clause; 209, 210; 209, 215; 210, call; 210, 211; 210, 212; 211, identifier:_is_type; 212, argument_list; 212, 213; 212, 214; 213, identifier:event; 214, string:'ONT::INHIBIT'; 215, block; 215, 216; 215, 220; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:is_activation; 219, False; 220, expression_statement; 220, 221; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:self; 224, identifier:_add_extracted; 225, argument_list; 225, 226; 225, 227; 226, string:'ONT::INHIBIT'; 227, subscript; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:event; 230, identifier:attrib; 231, string:'id'; 232, elif_clause; 232, 233; 232, 238; 233, call; 233, 234; 233, 235; 234, identifier:_is_type; 235, argument_list; 235, 236; 235, 237; 236, identifier:event; 237, string:'ONT::DEACTIVATE'; 238, block; 238, 239; 238, 243; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 242; 241, identifier:is_activation; 242, False; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:self; 247, identifier:_add_extracted; 248, argument_list; 248, 249; 248, 250; 249, string:'ONT::DEACTIVATE'; 250, subscript; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:event; 253, identifier:attrib; 254, string:'id'; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:ev; 258, call; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:self; 261, identifier:_get_evidence; 262, argument_list; 262, 263; 263, identifier:event; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 267; 266, identifier:location; 267, call; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, identifier:self; 270, identifier:_get_event_location; 271, argument_list; 271, 272; 272, identifier:event; 273, for_statement; 273, 274; 273, 277; 273, 283; 274, pattern_list; 274, 275; 274, 276; 275, identifier:a1; 276, identifier:a2; 277, call; 277, 278; 277, 279; 278, identifier:_agent_list_product; 279, argument_list; 279, 280; 280, tuple; 280, 281; 280, 282; 281, identifier:activator_agent; 282, identifier:affected_agent; 283, block; 283, 284; 283, 319; 283, 325; 284, if_statement; 284, 285; 284, 286; 284, 302; 285, identifier:is_activation; 286, block; 286, 287; 287, expression_statement; 287, 288; 288, assignment; 288, 289; 288, 290; 289, identifier:st; 290, call; 290, 291; 290, 292; 291, identifier:Activation; 292, argument_list; 292, 293; 292, 294; 292, 295; 293, identifier:a1; 294, identifier:a2; 295, keyword_argument; 295, 296; 295, 297; 296, identifier:evidence; 297, list:[deepcopy(ev)]; 297, 298; 298, call; 298, 299; 298, 300; 299, identifier:deepcopy; 300, argument_list; 300, 301; 301, identifier:ev; 302, else_clause; 302, 303; 303, block; 303, 304; 304, expression_statement; 304, 305; 305, assignment; 305, 306; 305, 307; 306, identifier:st; 307, call; 307, 308; 307, 309; 308, identifier:Inhibition; 309, argument_list; 309, 310; 309, 311; 309, 312; 310, identifier:a1; 311, identifier:a2; 312, keyword_argument; 312, 313; 312, 314; 313, identifier:evidence; 314, list:[deepcopy(ev)]; 314, 315; 315, call; 315, 316; 315, 317; 316, identifier:deepcopy; 317, argument_list; 317, 318; 318, identifier:ev; 319, expression_statement; 319, 320; 320, call; 320, 321; 320, 322; 321, identifier:_stmt_location_to_agents; 322, argument_list; 322, 323; 322, 324; 323, identifier:st; 324, identifier:location; 325, expression_statement; 325, 326; 326, call; 326, 327; 326, 332; 327, attribute; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:self; 330, identifier:statements; 331, identifier:append; 332, argument_list; 332, 333; 333, identifier:st | def get_activations(self):
act_events = self.tree.findall("EVENT/[type='ONT::ACTIVATE']")
inact_events = self.tree.findall("EVENT/[type='ONT::DEACTIVATE']")
inact_events += self.tree.findall("EVENT/[type='ONT::INHIBIT']")
for event in (act_events + inact_events):
event_id = event.attrib['id']
if event_id in self._static_events:
continue
agent = event.find(".//*[@role=':AGENT']")
if agent is None:
continue
agent_id = agent.attrib.get('id')
if agent_id is None:
logger.debug(
'Skipping activation with missing activator agent')
continue
activator_agent = self._get_agent_by_id(agent_id, event_id)
if activator_agent is None:
continue
affected = event.find(".//*[@role=':AFFECTED']")
if affected is None:
logger.debug(
'Skipping activation with missing affected agent')
continue
affected_id = affected.attrib.get('id')
if affected_id is None:
logger.debug(
'Skipping activation with missing affected agent')
continue
affected_agent = self._get_agent_by_id(affected_id, event_id)
if affected_agent is None:
logger.debug(
'Skipping activation with missing affected agent')
continue
is_activation = True
if _is_type(event, 'ONT::ACTIVATE'):
self._add_extracted('ONT::ACTIVATE', event.attrib['id'])
elif _is_type(event, 'ONT::INHIBIT'):
is_activation = False
self._add_extracted('ONT::INHIBIT', event.attrib['id'])
elif _is_type(event, 'ONT::DEACTIVATE'):
is_activation = False
self._add_extracted('ONT::DEACTIVATE', event.attrib['id'])
ev = self._get_evidence(event)
location = self._get_event_location(event)
for a1, a2 in _agent_list_product((activator_agent,
affected_agent)):
if is_activation:
st = Activation(a1, a2, evidence=[deepcopy(ev)])
else:
st = Inhibition(a1, a2, evidence=[deepcopy(ev)])
_stmt_location_to_agents(st, location)
self.statements.append(st) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_activations_causal; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 17; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:ccs; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:tree; 14, identifier:findall; 15, argument_list; 15, 16; 16, string:"CC/[type='ONT::CAUSE']"; 17, for_statement; 17, 18; 17, 19; 17, 20; 18, identifier:cc; 19, identifier:ccs; 20, block; 20, 21; 20, 30; 20, 39; 20, 49; 20, 60; 20, 73; 20, 84; 20, 97; 20, 107; 20, 116; 20, 129; 20, 139; 20, 145; 20, 154; 20, 160; 20, 169; 20, 177; 20, 186; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:factor; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:cc; 27, identifier:find; 28, argument_list; 28, 29; 29, string:"arg/[@role=':FACTOR']"; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:outcome; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:cc; 36, identifier:find; 37, argument_list; 37, 38; 38, string:"arg/[@role=':OUTCOME']"; 39, if_statement; 39, 40; 39, 47; 40, boolean_operator:or; 40, 41; 40, 44; 41, comparison_operator:is; 41, 42; 41, 43; 42, identifier:factor; 43, None; 44, comparison_operator:is; 44, 45; 44, 46; 45, identifier:outcome; 46, None; 47, block; 47, 48; 48, continue_statement; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:factor_id; 52, call; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:factor; 56, identifier:attrib; 57, identifier:get; 58, argument_list; 58, 59; 59, string:'id'; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:factor_term; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:tree; 68, identifier:find; 69, argument_list; 69, 70; 70, binary_operator:%; 70, 71; 70, 72; 71, string:"TERM/[@id='%s']"; 72, identifier:factor_id; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:outcome_id; 76, call; 76, 77; 76, 82; 77, attribute; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:outcome; 80, identifier:attrib; 81, identifier:get; 82, argument_list; 82, 83; 83, string:'id'; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:outcome_event; 87, call; 87, 88; 87, 93; 88, attribute; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:tree; 92, identifier:find; 93, argument_list; 93, 94; 94, binary_operator:%; 94, 95; 94, 96; 95, string:"EVENT/[@id='%s']"; 96, identifier:outcome_id; 97, if_statement; 97, 98; 97, 105; 98, boolean_operator:or; 98, 99; 98, 102; 99, comparison_operator:is; 99, 100; 99, 101; 100, identifier:factor_term; 101, None; 102, comparison_operator:is; 102, 103; 102, 104; 103, identifier:outcome_event; 104, None; 105, block; 105, 106; 106, continue_statement; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:factor_term_type; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:factor_term; 113, identifier:find; 114, argument_list; 114, 115; 115, string:'type'; 116, if_statement; 116, 117; 116, 127; 117, boolean_operator:or; 117, 118; 117, 121; 117, 122; 118, comparison_operator:is; 118, 119; 118, 120; 119, identifier:factor_term_type; 120, None; 121, line_continuation:\; 122, comparison_operator:not; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:factor_term_type; 125, identifier:text; 126, identifier:molecule_types; 127, block; 127, 128; 128, continue_statement; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:factor_agent; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:_get_agent_by_id; 136, argument_list; 136, 137; 136, 138; 137, identifier:factor_id; 138, None; 139, if_statement; 139, 140; 139, 143; 140, comparison_operator:is; 140, 141; 140, 142; 141, identifier:factor_agent; 142, None; 143, block; 143, 144; 144, continue_statement; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:outcome_event_type; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:outcome_event; 151, identifier:find; 152, argument_list; 152, 153; 153, string:'type'; 154, if_statement; 154, 155; 154, 158; 155, comparison_operator:is; 155, 156; 155, 157; 156, identifier:outcome_event_type; 157, None; 158, block; 158, 159; 159, continue_statement; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:ev; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:self; 166, identifier:_get_evidence; 167, argument_list; 167, 168; 168, identifier:cc; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 176; 171, subscript; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:ev; 174, identifier:epistemics; 175, string:'direct'; 176, False; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:location; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:self; 183, identifier:_get_event_location; 184, argument_list; 184, 185; 185, identifier:outcome_event; 186, if_statement; 186, 187; 186, 195; 187, comparison_operator:in; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:outcome_event_type; 190, identifier:text; 191, list:['ONT::ACTIVATE', 'ONT::ACTIVITY',
'ONT::DEACTIVATE']; 191, 192; 191, 193; 191, 194; 192, string:'ONT::ACTIVATE'; 193, string:'ONT::ACTIVITY'; 194, string:'ONT::DEACTIVATE'; 195, block; 195, 196; 195, 230; 195, 247; 195, 261; 195, 267; 195, 284; 196, if_statement; 196, 197; 196, 204; 196, 214; 197, comparison_operator:in; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:outcome_event_type; 200, identifier:text; 201, list:['ONT::ACTIVATE',
'ONT::DEACTIVATE']; 201, 202; 201, 203; 202, string:'ONT::ACTIVATE'; 203, string:'ONT::DEACTIVATE'; 204, block; 204, 205; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:agent_tag; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:outcome_event; 211, identifier:find; 212, argument_list; 212, 213; 213, string:".//*[@role=':AFFECTED']"; 214, elif_clause; 214, 215; 214, 220; 215, comparison_operator:==; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:outcome_event_type; 218, identifier:text; 219, string:'ONT::ACTIVITY'; 220, block; 220, 221; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:agent_tag; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:outcome_event; 227, identifier:find; 228, argument_list; 228, 229; 229, string:".//*[@role=':AGENT']"; 230, if_statement; 230, 231; 230, 245; 231, boolean_operator:or; 231, 232; 231, 235; 232, comparison_operator:is; 232, 233; 232, 234; 233, identifier:agent_tag; 234, None; 235, comparison_operator:is; 235, 236; 235, 244; 236, call; 236, 237; 236, 242; 237, attribute; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:agent_tag; 240, identifier:attrib; 241, identifier:get; 242, argument_list; 242, 243; 243, string:'id'; 244, None; 245, block; 245, 246; 246, continue_statement; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:outcome_agent; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:self; 253, identifier:_get_agent_by_id; 254, argument_list; 254, 255; 254, 260; 255, subscript; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:agent_tag; 258, identifier:attrib; 259, string:'id'; 260, identifier:outcome_id; 261, if_statement; 261, 262; 261, 265; 262, comparison_operator:is; 262, 263; 262, 264; 263, identifier:outcome_agent; 264, None; 265, block; 265, 266; 266, continue_statement; 267, if_statement; 267, 268; 267, 273; 267, 278; 268, comparison_operator:==; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:outcome_event_type; 271, identifier:text; 272, string:'ONT::DEACTIVATE'; 273, block; 273, 274; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 277; 276, identifier:is_activation; 277, False; 278, else_clause; 278, 279; 279, block; 279, 280; 280, expression_statement; 280, 281; 281, assignment; 281, 282; 281, 283; 282, identifier:is_activation; 283, True; 284, for_statement; 284, 285; 284, 288; 284, 294; 285, pattern_list; 285, 286; 285, 287; 286, identifier:a1; 287, identifier:a2; 288, call; 288, 289; 288, 290; 289, identifier:_agent_list_product; 290, argument_list; 290, 291; 291, tuple; 291, 292; 291, 293; 292, identifier:factor_agent; 293, identifier:outcome_agent; 294, block; 294, 295; 294, 330; 294, 336; 295, if_statement; 295, 296; 295, 297; 295, 313; 296, identifier:is_activation; 297, block; 297, 298; 298, expression_statement; 298, 299; 299, assignment; 299, 300; 299, 301; 300, identifier:st; 301, call; 301, 302; 301, 303; 302, identifier:Activation; 303, argument_list; 303, 304; 303, 305; 303, 306; 304, identifier:a1; 305, identifier:a2; 306, keyword_argument; 306, 307; 306, 308; 307, identifier:evidence; 308, list:[deepcopy(ev)]; 308, 309; 309, call; 309, 310; 309, 311; 310, identifier:deepcopy; 311, argument_list; 311, 312; 312, identifier:ev; 313, else_clause; 313, 314; 314, block; 314, 315; 315, expression_statement; 315, 316; 316, assignment; 316, 317; 316, 318; 317, identifier:st; 318, call; 318, 319; 318, 320; 319, identifier:Inhibition; 320, argument_list; 320, 321; 320, 322; 320, 323; 321, identifier:a1; 322, identifier:a2; 323, keyword_argument; 323, 324; 323, 325; 324, identifier:evidence; 325, list:[deepcopy(ev)]; 325, 326; 326, call; 326, 327; 326, 328; 327, identifier:deepcopy; 328, argument_list; 328, 329; 329, identifier:ev; 330, expression_statement; 330, 331; 331, call; 331, 332; 331, 333; 332, identifier:_stmt_location_to_agents; 333, argument_list; 333, 334; 333, 335; 334, identifier:st; 335, identifier:location; 336, expression_statement; 336, 337; 337, call; 337, 338; 337, 343; 338, attribute; 338, 339; 338, 342; 339, attribute; 339, 340; 339, 341; 340, identifier:self; 341, identifier:statements; 342, identifier:append; 343, argument_list; 343, 344; 344, identifier:st | def get_activations_causal(self):
ccs = self.tree.findall("CC/[type='ONT::CAUSE']")
for cc in ccs:
factor = cc.find("arg/[@role=':FACTOR']")
outcome = cc.find("arg/[@role=':OUTCOME']")
if factor is None or outcome is None:
continue
factor_id = factor.attrib.get('id')
factor_term = self.tree.find("TERM/[@id='%s']" % factor_id)
outcome_id = outcome.attrib.get('id')
outcome_event = self.tree.find("EVENT/[@id='%s']" % outcome_id)
if factor_term is None or outcome_event is None:
continue
factor_term_type = factor_term.find('type')
if factor_term_type is None or \
factor_term_type.text not in molecule_types:
continue
factor_agent = self._get_agent_by_id(factor_id, None)
if factor_agent is None:
continue
outcome_event_type = outcome_event.find('type')
if outcome_event_type is None:
continue
ev = self._get_evidence(cc)
ev.epistemics['direct'] = False
location = self._get_event_location(outcome_event)
if outcome_event_type.text in ['ONT::ACTIVATE', 'ONT::ACTIVITY',
'ONT::DEACTIVATE']:
if outcome_event_type.text in ['ONT::ACTIVATE',
'ONT::DEACTIVATE']:
agent_tag = outcome_event.find(".//*[@role=':AFFECTED']")
elif outcome_event_type.text == 'ONT::ACTIVITY':
agent_tag = outcome_event.find(".//*[@role=':AGENT']")
if agent_tag is None or agent_tag.attrib.get('id') is None:
continue
outcome_agent = self._get_agent_by_id(agent_tag.attrib['id'],
outcome_id)
if outcome_agent is None:
continue
if outcome_event_type.text == 'ONT::DEACTIVATE':
is_activation = False
else:
is_activation = True
for a1, a2 in _agent_list_product((factor_agent,
outcome_agent)):
if is_activation:
st = Activation(a1, a2, evidence=[deepcopy(ev)])
else:
st = Inhibition(a1, a2, evidence=[deepcopy(ev)])
_stmt_location_to_agents(st, location)
self.statements.append(st) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_activations_stimulate; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 17; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:stim_events; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:tree; 14, identifier:findall; 15, argument_list; 15, 16; 16, string:"EVENT/[type='ONT::STIMULATE']"; 17, for_statement; 17, 18; 17, 19; 17, 20; 18, identifier:event; 19, identifier:stim_events; 20, block; 20, 21; 20, 32; 20, 40; 20, 49; 20, 58; 20, 68; 20, 79; 20, 92; 20, 103; 20, 116; 20, 126; 20, 135; 20, 148; 20, 158; 20, 164; 20, 173; 20, 179; 20, 188; 20, 196; 20, 205; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:event_id; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:event; 28, identifier:attrib; 29, identifier:get; 30, argument_list; 30, 31; 31, string:'id'; 32, if_statement; 32, 33; 32, 38; 33, comparison_operator:in; 33, 34; 33, 35; 34, identifier:event_id; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_static_events; 38, block; 38, 39; 39, continue_statement; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:controller; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:event; 46, identifier:find; 47, argument_list; 47, 48; 48, string:"arg1/[@role=':AGENT']"; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:affected; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:event; 55, identifier:find; 56, argument_list; 56, 57; 57, string:"arg2/[@role=':AFFECTED']"; 58, if_statement; 58, 59; 58, 66; 59, boolean_operator:or; 59, 60; 59, 63; 60, comparison_operator:is; 60, 61; 60, 62; 61, identifier:controller; 62, None; 63, comparison_operator:is; 63, 64; 63, 65; 64, identifier:affected; 65, None; 66, block; 66, 67; 67, continue_statement; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:controller_id; 71, call; 71, 72; 71, 77; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:controller; 75, identifier:attrib; 76, identifier:get; 77, argument_list; 77, 78; 78, string:'id'; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:controller_term; 82, call; 82, 83; 82, 88; 83, attribute; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:tree; 87, identifier:find; 88, argument_list; 88, 89; 89, binary_operator:%; 89, 90; 89, 91; 90, string:"TERM/[@id='%s']"; 91, identifier:controller_id; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:affected_id; 95, call; 95, 96; 95, 101; 96, attribute; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:affected; 99, identifier:attrib; 100, identifier:get; 101, argument_list; 101, 102; 102, string:'id'; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:affected_event; 106, call; 106, 107; 106, 112; 107, attribute; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:tree; 111, identifier:find; 112, argument_list; 112, 113; 113, binary_operator:%; 113, 114; 113, 115; 114, string:"EVENT/[@id='%s']"; 115, identifier:affected_id; 116, if_statement; 116, 117; 116, 124; 117, boolean_operator:or; 117, 118; 117, 121; 118, comparison_operator:is; 118, 119; 118, 120; 119, identifier:controller_term; 120, None; 121, comparison_operator:is; 121, 122; 121, 123; 122, identifier:affected_event; 123, None; 124, block; 124, 125; 125, continue_statement; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:controller_term_type; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:controller_term; 132, identifier:find; 133, argument_list; 133, 134; 134, string:'type'; 135, if_statement; 135, 136; 135, 146; 136, boolean_operator:or; 136, 137; 136, 140; 136, 141; 137, comparison_operator:is; 137, 138; 137, 139; 138, identifier:controller_term_type; 139, None; 140, line_continuation:\; 141, comparison_operator:not; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:controller_term_type; 144, identifier:text; 145, identifier:molecule_types; 146, block; 146, 147; 147, continue_statement; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:controller_agent; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:self; 154, identifier:_get_agent_by_id; 155, argument_list; 155, 156; 155, 157; 156, identifier:controller_id; 157, None; 158, if_statement; 158, 159; 158, 162; 159, comparison_operator:is; 159, 160; 159, 161; 160, identifier:controller_agent; 161, None; 162, block; 162, 163; 163, continue_statement; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:affected_event_type; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:affected_event; 170, identifier:find; 171, argument_list; 171, 172; 172, string:'type'; 173, if_statement; 173, 174; 173, 177; 174, comparison_operator:is; 174, 175; 174, 176; 175, identifier:affected_event_type; 176, None; 177, block; 177, 178; 178, continue_statement; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:ev; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:self; 185, identifier:_get_evidence; 186, argument_list; 186, 187; 187, identifier:event; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 195; 190, subscript; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:ev; 193, identifier:epistemics; 194, string:'direct'; 195, False; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:location; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:self; 202, identifier:_get_event_location; 203, argument_list; 203, 204; 204, identifier:affected_event; 205, if_statement; 205, 206; 205, 211; 205, 288; 206, comparison_operator:==; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:affected_event_type; 209, identifier:text; 210, string:'ONT::ACTIVATE'; 211, block; 211, 212; 211, 221; 211, 227; 211, 241; 211, 247; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:affected; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:affected_event; 218, identifier:find; 219, argument_list; 219, 220; 220, string:".//*[@role=':AFFECTED']"; 221, if_statement; 221, 222; 221, 225; 222, comparison_operator:is; 222, 223; 222, 224; 223, identifier:affected; 224, None; 225, block; 225, 226; 226, continue_statement; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:affected_agent; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:self; 233, identifier:_get_agent_by_id; 234, argument_list; 234, 235; 234, 240; 235, subscript; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:affected; 238, identifier:attrib; 239, string:'id'; 240, identifier:affected_id; 241, if_statement; 241, 242; 241, 245; 242, comparison_operator:is; 242, 243; 242, 244; 243, identifier:affected_agent; 244, None; 245, block; 245, 246; 246, continue_statement; 247, for_statement; 247, 248; 247, 251; 247, 257; 248, pattern_list; 248, 249; 248, 250; 249, identifier:a1; 250, identifier:a2; 251, call; 251, 252; 251, 253; 252, identifier:_agent_list_product; 253, argument_list; 253, 254; 254, tuple; 254, 255; 254, 256; 255, identifier:controller_agent; 256, identifier:affected_agent; 257, block; 257, 258; 257, 273; 257, 279; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 261; 260, identifier:st; 261, call; 261, 262; 261, 263; 262, identifier:Activation; 263, argument_list; 263, 264; 263, 265; 263, 266; 264, identifier:a1; 265, identifier:a2; 266, keyword_argument; 266, 267; 266, 268; 267, identifier:evidence; 268, list:[deepcopy(ev)]; 268, 269; 269, call; 269, 270; 269, 271; 270, identifier:deepcopy; 271, argument_list; 271, 272; 272, identifier:ev; 273, expression_statement; 273, 274; 274, call; 274, 275; 274, 276; 275, identifier:_stmt_location_to_agents; 276, argument_list; 276, 277; 276, 278; 277, identifier:st; 278, identifier:location; 279, expression_statement; 279, 280; 280, call; 280, 281; 280, 286; 281, attribute; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:self; 284, identifier:statements; 285, identifier:append; 286, argument_list; 286, 287; 287, identifier:st; 288, elif_clause; 288, 289; 288, 294; 289, comparison_operator:==; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:affected_event_type; 292, identifier:text; 293, string:'ONT::ACTIVITY'; 294, block; 294, 295; 294, 304; 294, 310; 294, 324; 294, 330; 295, expression_statement; 295, 296; 296, assignment; 296, 297; 296, 298; 297, identifier:agent_tag; 298, call; 298, 299; 298, 302; 299, attribute; 299, 300; 299, 301; 300, identifier:affected_event; 301, identifier:find; 302, argument_list; 302, 303; 303, string:".//*[@role=':AGENT']"; 304, if_statement; 304, 305; 304, 308; 305, comparison_operator:is; 305, 306; 305, 307; 306, identifier:agent_tag; 307, None; 308, block; 308, 309; 309, continue_statement; 310, expression_statement; 310, 311; 311, assignment; 311, 312; 311, 313; 312, identifier:affected_agent; 313, call; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:self; 316, identifier:_get_agent_by_id; 317, argument_list; 317, 318; 317, 323; 318, subscript; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:agent_tag; 321, identifier:attrib; 322, string:'id'; 323, identifier:affected_id; 324, if_statement; 324, 325; 324, 328; 325, comparison_operator:is; 325, 326; 325, 327; 326, identifier:affected_agent; 327, None; 328, block; 328, 329; 329, continue_statement; 330, for_statement; 330, 331; 330, 334; 330, 340; 331, pattern_list; 331, 332; 331, 333; 332, identifier:a1; 333, identifier:a2; 334, call; 334, 335; 334, 336; 335, identifier:_agent_list_product; 336, argument_list; 336, 337; 337, tuple; 337, 338; 337, 339; 338, identifier:controller_agent; 339, identifier:affected_agent; 340, block; 340, 341; 340, 356; 340, 362; 341, expression_statement; 341, 342; 342, assignment; 342, 343; 342, 344; 343, identifier:st; 344, call; 344, 345; 344, 346; 345, identifier:Activation; 346, argument_list; 346, 347; 346, 348; 346, 349; 347, identifier:a1; 348, identifier:a2; 349, keyword_argument; 349, 350; 349, 351; 350, identifier:evidence; 351, list:[deepcopy(ev)]; 351, 352; 352, call; 352, 353; 352, 354; 353, identifier:deepcopy; 354, argument_list; 354, 355; 355, identifier:ev; 356, expression_statement; 356, 357; 357, call; 357, 358; 357, 359; 358, identifier:_stmt_location_to_agents; 359, argument_list; 359, 360; 359, 361; 360, identifier:st; 361, identifier:location; 362, expression_statement; 362, 363; 363, call; 363, 364; 363, 369; 364, attribute; 364, 365; 364, 368; 365, attribute; 365, 366; 365, 367; 366, identifier:self; 367, identifier:statements; 368, identifier:append; 369, argument_list; 369, 370; 370, identifier:st | def get_activations_stimulate(self):
stim_events = self.tree.findall("EVENT/[type='ONT::STIMULATE']")
for event in stim_events:
event_id = event.attrib.get('id')
if event_id in self._static_events:
continue
controller = event.find("arg1/[@role=':AGENT']")
affected = event.find("arg2/[@role=':AFFECTED']")
if controller is None or affected is None:
continue
controller_id = controller.attrib.get('id')
controller_term = self.tree.find("TERM/[@id='%s']" % controller_id)
affected_id = affected.attrib.get('id')
affected_event = self.tree.find("EVENT/[@id='%s']" % affected_id)
if controller_term is None or affected_event is None:
continue
controller_term_type = controller_term.find('type')
if controller_term_type is None or \
controller_term_type.text not in molecule_types:
continue
controller_agent = self._get_agent_by_id(controller_id, None)
if controller_agent is None:
continue
affected_event_type = affected_event.find('type')
if affected_event_type is None:
continue
ev = self._get_evidence(event)
ev.epistemics['direct'] = False
location = self._get_event_location(affected_event)
if affected_event_type.text == 'ONT::ACTIVATE':
affected = affected_event.find(".//*[@role=':AFFECTED']")
if affected is None:
continue
affected_agent = self._get_agent_by_id(affected.attrib['id'],
affected_id)
if affected_agent is None:
continue
for a1, a2 in _agent_list_product((controller_agent,
affected_agent)):
st = Activation(a1, a2, evidence=[deepcopy(ev)])
_stmt_location_to_agents(st, location)
self.statements.append(st)
elif affected_event_type.text == 'ONT::ACTIVITY':
agent_tag = affected_event.find(".//*[@role=':AGENT']")
if agent_tag is None:
continue
affected_agent = self._get_agent_by_id(agent_tag.attrib['id'],
affected_id)
if affected_agent is None:
continue
for a1, a2 in _agent_list_product((controller_agent,
affected_agent)):
st = Activation(a1, a2, evidence=[deepcopy(ev)])
_stmt_location_to_agents(st, location)
self.statements.append(st) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_degradations; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 17; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:deg_events; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:tree; 14, identifier:findall; 15, argument_list; 15, 16; 16, string:"EVENT/[type='ONT::CONSUME']"; 17, for_statement; 17, 18; 17, 19; 17, 20; 18, identifier:event; 19, identifier:deg_events; 20, block; 20, 21; 20, 33; 20, 42; 20, 59; 20, 70; 20, 83; 20, 97; 20, 110; 20, 119; 20, 166; 20, 175; 20, 184; 20, 225; 21, if_statement; 21, 22; 21, 31; 22, comparison_operator:in; 22, 23; 22, 28; 23, subscript; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:event; 26, identifier:attrib; 27, string:'id'; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:_static_events; 31, block; 31, 32; 32, continue_statement; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:affected; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:event; 39, identifier:find; 40, argument_list; 40, 41; 41, string:".//*[@role=':AFFECTED']"; 42, if_statement; 42, 43; 42, 46; 43, comparison_operator:is; 43, 44; 43, 45; 44, identifier:affected; 45, None; 46, block; 46, 47; 46, 51; 46, 58; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:msg; 50, string:'Skipping degradation event with no affected term.'; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:logger; 55, identifier:debug; 56, argument_list; 56, 57; 57, identifier:msg; 58, continue_statement; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:affected_id; 62, call; 62, 63; 62, 68; 63, attribute; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:affected; 66, identifier:attrib; 67, identifier:get; 68, argument_list; 68, 69; 69, string:'id'; 70, if_statement; 70, 71; 70, 74; 71, comparison_operator:is; 71, 72; 71, 73; 72, identifier:affected_id; 73, None; 74, block; 74, 75; 74, 82; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:logger; 79, identifier:debug; 80, argument_list; 80, 81; 81, string:'Skipping degradation event with missing affected agent'; 82, continue_statement; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:affected_agent; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:_get_agent_by_id; 90, argument_list; 90, 91; 90, 92; 91, identifier:affected_id; 92, subscript; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:event; 95, identifier:attrib; 96, string:'id'; 97, if_statement; 97, 98; 97, 101; 98, comparison_operator:is; 98, 99; 98, 100; 99, identifier:affected_agent; 100, None; 101, block; 101, 102; 101, 109; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:logger; 106, identifier:debug; 107, argument_list; 107, 108; 108, string:'Skipping degradation event with missing affected agent'; 109, continue_statement; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:agent; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:event; 116, identifier:find; 117, argument_list; 117, 118; 118, string:".//*[@role=':AGENT']"; 119, if_statement; 119, 120; 119, 123; 119, 128; 120, comparison_operator:is; 120, 121; 120, 122; 121, identifier:agent; 122, None; 123, block; 123, 124; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:agent_agent; 127, None; 128, else_clause; 128, 129; 129, block; 129, 130; 129, 141; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:agent_id; 133, call; 133, 134; 133, 139; 134, attribute; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:agent; 137, identifier:attrib; 138, identifier:get; 139, argument_list; 139, 140; 140, string:'id'; 141, if_statement; 141, 142; 141, 145; 141, 150; 142, comparison_operator:is; 142, 143; 142, 144; 143, identifier:agent_id; 144, None; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:agent_agent; 149, None; 150, else_clause; 150, 151; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:agent_agent; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:self; 158, identifier:_get_agent_by_id; 159, argument_list; 159, 160; 159, 161; 160, identifier:agent_id; 161, subscript; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:event; 164, identifier:attrib; 165, string:'id'; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:ev; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:self; 172, identifier:_get_evidence; 173, argument_list; 173, 174; 174, identifier:event; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:location; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:self; 181, identifier:_get_event_location; 182, argument_list; 182, 183; 183, identifier:event; 184, for_statement; 184, 185; 184, 188; 184, 189; 184, 195; 185, pattern_list; 185, 186; 185, 187; 186, identifier:subj; 187, identifier:obj; 188, line_continuation:\; 189, call; 189, 190; 189, 191; 190, identifier:_agent_list_product; 191, argument_list; 191, 192; 192, tuple; 192, 193; 192, 194; 193, identifier:agent_agent; 194, identifier:affected_agent; 195, block; 195, 196; 195, 210; 195, 216; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:st; 199, call; 199, 200; 199, 201; 200, identifier:DecreaseAmount; 201, argument_list; 201, 202; 201, 203; 201, 204; 202, identifier:subj; 203, identifier:obj; 204, keyword_argument; 204, 205; 204, 206; 205, identifier:evidence; 206, call; 206, 207; 206, 208; 207, identifier:deepcopy; 208, argument_list; 208, 209; 209, identifier:ev; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 213; 212, identifier:_stmt_location_to_agents; 213, argument_list; 213, 214; 213, 215; 214, identifier:st; 215, identifier:location; 216, expression_statement; 216, 217; 217, call; 217, 218; 217, 223; 218, attribute; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:self; 221, identifier:statements; 222, identifier:append; 223, argument_list; 223, 224; 224, identifier:st; 225, expression_statement; 225, 226; 226, call; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:self; 229, identifier:_add_extracted; 230, argument_list; 230, 231; 230, 235; 231, call; 231, 232; 231, 233; 232, identifier:_get_type; 233, argument_list; 233, 234; 234, identifier:event; 235, subscript; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:event; 238, identifier:attrib; 239, string:'id' | def get_degradations(self):
deg_events = self.tree.findall("EVENT/[type='ONT::CONSUME']")
for event in deg_events:
if event.attrib['id'] in self._static_events:
continue
affected = event.find(".//*[@role=':AFFECTED']")
if affected is None:
msg = 'Skipping degradation event with no affected term.'
logger.debug(msg)
continue
affected_id = affected.attrib.get('id')
if affected_id is None:
logger.debug(
'Skipping degradation event with missing affected agent')
continue
affected_agent = self._get_agent_by_id(affected_id,
event.attrib['id'])
if affected_agent is None:
logger.debug(
'Skipping degradation event with missing affected agent')
continue
agent = event.find(".//*[@role=':AGENT']")
if agent is None:
agent_agent = None
else:
agent_id = agent.attrib.get('id')
if agent_id is None:
agent_agent = None
else:
agent_agent = self._get_agent_by_id(agent_id,
event.attrib['id'])
ev = self._get_evidence(event)
location = self._get_event_location(event)
for subj, obj in \
_agent_list_product((agent_agent, affected_agent)):
st = DecreaseAmount(subj, obj, evidence=deepcopy(ev))
_stmt_location_to_agents(st, location)
self.statements.append(st)
self._add_extracted(_get_type(event), event.attrib['id']) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_complexes; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 17; 5, 28; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:bind_events; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:tree; 14, identifier:findall; 15, argument_list; 15, 16; 16, string:"EVENT/[type='ONT::BIND']"; 17, expression_statement; 17, 18; 18, augmented_assignment:+=; 18, 19; 18, 20; 19, identifier:bind_events; 20, call; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:tree; 25, identifier:findall; 26, argument_list; 26, 27; 27, string:"EVENT/[type='ONT::INTERACT']"; 28, for_statement; 28, 29; 28, 30; 28, 31; 29, identifier:event; 30, identifier:bind_events; 31, block; 31, 32; 31, 44; 31, 53; 31, 62; 31, 104; 31, 146; 31, 164; 31, 182; 31, 199; 31, 201; 31, 210; 31, 219; 31, 260; 32, if_statement; 32, 33; 32, 42; 33, comparison_operator:in; 33, 34; 33, 39; 34, subscript; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:event; 37, identifier:attrib; 38, string:'id'; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:_static_events; 42, block; 42, 43; 43, continue_statement; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:arg1; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:event; 50, identifier:find; 51, argument_list; 51, 52; 52, string:"arg1"; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:arg2; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:event; 59, identifier:find; 60, argument_list; 60, 61; 61, string:"arg2"; 62, if_statement; 62, 63; 62, 70; 63, boolean_operator:and; 63, 64; 63, 67; 64, comparison_operator:is; 64, 65; 64, 66; 65, identifier:arg1; 66, None; 67, comparison_operator:is; 67, 68; 67, 69; 68, identifier:arg2; 69, None; 70, block; 70, 71; 70, 83; 70, 92; 70, 98; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:args; 74, call; 74, 75; 74, 76; 75, identifier:list; 76, argument_list; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:event; 80, identifier:findall; 81, argument_list; 81, 82; 82, string:'arg'; 83, if_statement; 83, 84; 83, 90; 84, comparison_operator:<; 84, 85; 84, 89; 85, call; 85, 86; 85, 87; 86, identifier:len; 87, argument_list; 87, 88; 88, identifier:args; 89, integer:2; 90, block; 90, 91; 91, continue_statement; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:arg1; 95, subscript; 95, 96; 95, 97; 96, identifier:args; 97, integer:0; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:arg2; 101, subscript; 101, 102; 101, 103; 102, identifier:args; 103, integer:1; 104, if_statement; 104, 105; 104, 137; 105, boolean_operator:or; 105, 106; 105, 121; 105, 122; 106, parenthesized_expression; 106, 107; 107, boolean_operator:or; 107, 108; 107, 111; 108, comparison_operator:is; 108, 109; 108, 110; 109, identifier:arg1; 110, None; 111, comparison_operator:is; 111, 112; 111, 120; 112, call; 112, 113; 112, 118; 113, attribute; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:arg1; 116, identifier:attrib; 117, identifier:get; 118, argument_list; 118, 119; 119, string:'id'; 120, None; 121, line_continuation:\; 122, parenthesized_expression; 122, 123; 123, boolean_operator:or; 123, 124; 123, 127; 124, comparison_operator:is; 124, 125; 124, 126; 125, identifier:arg2; 126, None; 127, comparison_operator:is; 127, 128; 127, 136; 128, call; 128, 129; 128, 134; 129, attribute; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:arg2; 132, identifier:attrib; 133, identifier:get; 134, argument_list; 134, 135; 135, string:'id'; 136, None; 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:debug; 143, argument_list; 143, 144; 144, string:'Skipping complex with less than 2 members'; 145, continue_statement; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:agent1; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:_get_agent_by_id; 153, argument_list; 153, 154; 153, 159; 154, subscript; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:arg1; 157, identifier:attrib; 158, string:'id'; 159, subscript; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:event; 162, identifier:attrib; 163, string:'id'; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:agent2; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:_get_agent_by_id; 171, argument_list; 171, 172; 171, 177; 172, subscript; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:arg2; 175, identifier:attrib; 176, string:'id'; 177, subscript; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:event; 180, identifier:attrib; 181, string:'id'; 182, if_statement; 182, 183; 182, 190; 183, boolean_operator:or; 183, 184; 183, 187; 184, comparison_operator:is; 184, 185; 184, 186; 185, identifier:agent1; 186, None; 187, comparison_operator:is; 187, 188; 187, 189; 188, identifier:agent2; 189, None; 190, block; 190, 191; 190, 198; 191, expression_statement; 191, 192; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:logger; 195, identifier:debug; 196, argument_list; 196, 197; 197, string:'Skipping complex with less than 2 members'; 198, continue_statement; 199, expression_statement; 199, 200; 200, string:'''
site_feature = self._find_in_term(arg1.attrib['id'], 'features/site')
if site_feature is not None:
sites, positions = self._get_site_by_id(site_id)
print sites, positions
site_feature = self._find_in_term(arg2.attrib['id'], 'features/site')
if site_feature is not None:
sites, positions = self._get_site_by_id(site_id)
print sites, positions
site = event.find("site")
if site is not None:
sites, positions = self._get_site_by_id(site.attrib['id'])
print sites, positions
'''; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:ev; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:self; 207, identifier:_get_evidence; 208, argument_list; 208, 209; 209, identifier:event; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:location; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:self; 216, identifier:_get_event_location; 217, argument_list; 217, 218; 218, identifier:event; 219, for_statement; 219, 220; 219, 223; 219, 229; 220, pattern_list; 220, 221; 220, 222; 221, identifier:a1; 222, identifier:a2; 223, call; 223, 224; 223, 225; 224, identifier:_agent_list_product; 225, argument_list; 225, 226; 226, tuple; 226, 227; 226, 228; 227, identifier:agent1; 228, identifier:agent2; 229, block; 229, 230; 229, 245; 229, 251; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:st; 233, call; 233, 234; 233, 235; 234, identifier:Complex; 235, argument_list; 235, 236; 235, 239; 236, list:[a1, a2]; 236, 237; 236, 238; 237, identifier:a1; 238, identifier:a2; 239, keyword_argument; 239, 240; 239, 241; 240, identifier:evidence; 241, call; 241, 242; 241, 243; 242, identifier:deepcopy; 243, argument_list; 243, 244; 244, identifier:ev; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 248; 247, identifier:_stmt_location_to_agents; 248, argument_list; 248, 249; 248, 250; 249, identifier:st; 250, identifier:location; 251, expression_statement; 251, 252; 252, call; 252, 253; 252, 258; 253, attribute; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:self; 256, identifier:statements; 257, identifier:append; 258, argument_list; 258, 259; 259, identifier:st; 260, expression_statement; 260, 261; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:self; 264, identifier:_add_extracted; 265, argument_list; 265, 266; 265, 270; 266, call; 266, 267; 266, 268; 267, identifier:_get_type; 268, argument_list; 268, 269; 269, identifier:event; 270, subscript; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:event; 273, identifier:attrib; 274, string:'id' | def get_complexes(self):
bind_events = self.tree.findall("EVENT/[type='ONT::BIND']")
bind_events += self.tree.findall("EVENT/[type='ONT::INTERACT']")
for event in bind_events:
if event.attrib['id'] in self._static_events:
continue
arg1 = event.find("arg1")
arg2 = event.find("arg2")
if arg1 is None and arg2 is None:
args = list(event.findall('arg'))
if len(args) < 2:
continue
arg1 = args[0]
arg2 = args[1]
if (arg1 is None or arg1.attrib.get('id') is None) or \
(arg2 is None or arg2.attrib.get('id') is None):
logger.debug('Skipping complex with less than 2 members')
continue
agent1 = self._get_agent_by_id(arg1.attrib['id'],
event.attrib['id'])
agent2 = self._get_agent_by_id(arg2.attrib['id'],
event.attrib['id'])
if agent1 is None or agent2 is None:
logger.debug('Skipping complex with less than 2 members')
continue
'''
site_feature = self._find_in_term(arg1.attrib['id'], 'features/site')
if site_feature is not None:
sites, positions = self._get_site_by_id(site_id)
print sites, positions
site_feature = self._find_in_term(arg2.attrib['id'], 'features/site')
if site_feature is not None:
sites, positions = self._get_site_by_id(site_id)
print sites, positions
site = event.find("site")
if site is not None:
sites, positions = self._get_site_by_id(site.attrib['id'])
print sites, positions
'''
ev = self._get_evidence(event)
location = self._get_event_location(event)
for a1, a2 in _agent_list_product((agent1, agent2)):
st = Complex([a1, a2], evidence=deepcopy(ev))
_stmt_location_to_agents(st, location)
self.statements.append(st)
self._add_extracted(_get_type(event), event.attrib['id']) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_modifications_indirect; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 17; 5, 22; 5, 129; 5, 236; 5, 243; 5, 250; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:mod_event_types; 9, call; 9, 10; 9, 11; 10, identifier:list; 11, argument_list; 11, 12; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:ont_to_mod_type; 15, identifier:keys; 16, argument_list; 17, expression_statement; 17, 18; 18, augmented_assignment:+=; 18, 19; 18, 20; 19, identifier:mod_event_types; 20, list:['ONT::PTM']; 20, 21; 21, string:'ONT::PTM'; 22, function_definition; 22, 23; 22, 24; 22, 26; 23, function_name:get_increase_events; 24, parameters; 24, 25; 25, identifier:mod_event_types; 26, block; 26, 27; 26, 31; 26, 42; 26, 127; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:mod_events; 30, list:[]; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:events; 34, call; 34, 35; 34, 40; 35, attribute; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:tree; 39, identifier:findall; 40, argument_list; 40, 41; 41, string:"EVENT/[type='ONT::INCREASE']"; 42, for_statement; 42, 43; 42, 44; 42, 45; 43, identifier:event; 44, identifier:events; 45, block; 45, 46; 45, 55; 45, 61; 45, 72; 45, 77; 45, 83; 45, 94; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:affected; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:event; 52, identifier:find; 53, argument_list; 53, 54; 54, string:".//*[@role=':AFFECTED']"; 55, if_statement; 55, 56; 55, 59; 56, comparison_operator:is; 56, 57; 56, 58; 57, identifier:affected; 58, None; 59, block; 59, 60; 60, continue_statement; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:affected_id; 64, call; 64, 65; 64, 70; 65, attribute; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:affected; 68, identifier:attrib; 69, identifier:get; 70, argument_list; 70, 71; 71, string:'id'; 72, if_statement; 72, 73; 72, 75; 73, not_operator; 73, 74; 74, identifier:affected_id; 75, block; 75, 76; 76, continue_statement; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:pattern; 80, binary_operator:%; 80, 81; 80, 82; 81, string:"EVENT/[@id='%s']"; 82, identifier:affected_id; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:affected_event; 86, call; 86, 87; 86, 92; 87, attribute; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:tree; 91, identifier:find; 92, argument_list; 92, 93; 93, identifier:pattern; 94, if_statement; 94, 95; 94, 98; 95, comparison_operator:is; 95, 96; 95, 97; 96, identifier:affected_event; 97, None; 98, block; 98, 99; 98, 108; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:affected_type; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:affected_event; 105, identifier:find; 106, argument_list; 106, 107; 107, string:'type'; 108, if_statement; 108, 109; 108, 119; 109, boolean_operator:and; 109, 110; 109, 113; 109, 114; 110, comparison_operator:is; 110, 111; 110, 112; 111, identifier:affected_type; 112, None; 113, line_continuation:\; 114, comparison_operator:in; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:affected_type; 117, identifier:text; 118, identifier:mod_event_types; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:mod_events; 124, identifier:append; 125, argument_list; 125, 126; 126, identifier:event; 127, return_statement; 127, 128; 128, identifier:mod_events; 129, function_definition; 129, 130; 129, 131; 129, 133; 130, function_name:get_cause_events; 131, parameters; 131, 132; 132, identifier:mod_event_types; 133, block; 133, 134; 133, 138; 133, 149; 133, 234; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:mod_events; 137, list:[]; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:ccs; 141, call; 141, 142; 141, 147; 142, attribute; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:tree; 146, identifier:findall; 147, argument_list; 147, 148; 148, string:"CC/[type='ONT::CAUSE']"; 149, for_statement; 149, 150; 149, 151; 149, 152; 150, identifier:cc; 151, identifier:ccs; 152, block; 152, 153; 152, 162; 152, 168; 152, 179; 152, 184; 152, 190; 152, 201; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:outcome; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:cc; 159, identifier:find; 160, argument_list; 160, 161; 161, string:".//*[@role=':OUTCOME']"; 162, if_statement; 162, 163; 162, 166; 163, comparison_operator:is; 163, 164; 163, 165; 164, identifier:outcome; 165, None; 166, block; 166, 167; 167, continue_statement; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:outcome_id; 171, call; 171, 172; 171, 177; 172, attribute; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:outcome; 175, identifier:attrib; 176, identifier:get; 177, argument_list; 177, 178; 178, string:'id'; 179, if_statement; 179, 180; 179, 182; 180, not_operator; 180, 181; 181, identifier:outcome_id; 182, block; 182, 183; 183, continue_statement; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:pattern; 187, binary_operator:%; 187, 188; 187, 189; 188, string:"EVENT/[@id='%s']"; 189, identifier:outcome_id; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:outcome_event; 193, call; 193, 194; 193, 199; 194, attribute; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:self; 197, identifier:tree; 198, identifier:find; 199, argument_list; 199, 200; 200, identifier:pattern; 201, if_statement; 201, 202; 201, 205; 202, comparison_operator:is; 202, 203; 202, 204; 203, identifier:outcome_event; 204, None; 205, block; 205, 206; 205, 215; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:outcome_type; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:outcome_event; 212, identifier:find; 213, argument_list; 213, 214; 214, string:'type'; 215, if_statement; 215, 216; 215, 226; 216, boolean_operator:and; 216, 217; 216, 220; 216, 221; 217, comparison_operator:is; 217, 218; 217, 219; 218, identifier:outcome_type; 219, None; 220, line_continuation:\; 221, comparison_operator:in; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:outcome_type; 224, identifier:text; 225, identifier:mod_event_types; 226, block; 226, 227; 227, expression_statement; 227, 228; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:mod_events; 231, identifier:append; 232, argument_list; 232, 233; 233, identifier:cc; 234, return_statement; 234, 235; 235, identifier:mod_events; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:mod_events; 239, call; 239, 240; 239, 241; 240, identifier:get_increase_events; 241, argument_list; 241, 242; 242, identifier:mod_event_types; 243, expression_statement; 243, 244; 244, augmented_assignment:+=; 244, 245; 244, 246; 245, identifier:mod_events; 246, call; 246, 247; 246, 248; 247, identifier:get_cause_events; 248, argument_list; 248, 249; 249, identifier:mod_event_types; 250, for_statement; 250, 251; 250, 252; 250, 253; 251, identifier:event; 252, identifier:mod_events; 253, block; 253, 254; 253, 262; 253, 270; 253, 277; 253, 286; 253, 306; 253, 317; 253, 323; 253, 333; 253, 342; 253, 362; 253, 373; 253, 378; 253, 391; 253, 397; 253, 484; 253, 496; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:event_id; 257, subscript; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:event; 260, identifier:attrib; 261, string:'id'; 262, if_statement; 262, 263; 262, 268; 263, comparison_operator:in; 263, 264; 263, 265; 264, identifier:event_id; 265, attribute; 265, 266; 265, 267; 266, identifier:self; 267, identifier:_static_events; 268, block; 268, 269; 269, continue_statement; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 273; 272, identifier:event_type; 273, call; 273, 274; 273, 275; 274, identifier:_get_type; 275, argument_list; 275, 276; 276, identifier:event; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 280; 279, identifier:enzyme; 280, call; 280, 281; 280, 284; 281, attribute; 281, 282; 281, 283; 282, identifier:event; 283, identifier:find; 284, argument_list; 284, 285; 285, string:".//*[@role=':AGENT']"; 286, if_statement; 286, 287; 286, 290; 287, comparison_operator:is; 287, 288; 287, 289; 288, identifier:enzyme; 289, None; 290, block; 290, 291; 290, 300; 291, expression_statement; 291, 292; 292, assignment; 292, 293; 292, 294; 293, identifier:enzyme; 294, call; 294, 295; 294, 298; 295, attribute; 295, 296; 295, 297; 296, identifier:event; 297, identifier:find; 298, argument_list; 298, 299; 299, string:".//*[@role=':FACTOR']"; 300, if_statement; 300, 301; 300, 304; 301, comparison_operator:is; 301, 302; 301, 303; 302, identifier:enzyme; 303, None; 304, block; 304, 305; 305, return_statement; 306, expression_statement; 306, 307; 307, assignment; 307, 308; 307, 309; 308, identifier:enzyme_id; 309, call; 309, 310; 309, 315; 310, attribute; 310, 311; 310, 314; 311, attribute; 311, 312; 311, 313; 312, identifier:enzyme; 313, identifier:attrib; 314, identifier:get; 315, argument_list; 315, 316; 316, string:'id'; 317, if_statement; 317, 318; 317, 321; 318, comparison_operator:is; 318, 319; 318, 320; 319, identifier:enzyme_id; 320, None; 321, block; 321, 322; 322, continue_statement; 323, expression_statement; 323, 324; 324, assignment; 324, 325; 324, 326; 325, identifier:enzyme_agent; 326, call; 326, 327; 326, 330; 327, attribute; 327, 328; 327, 329; 328, identifier:self; 329, identifier:_get_agent_by_id; 330, argument_list; 330, 331; 330, 332; 331, identifier:enzyme_id; 332, identifier:event_id; 333, expression_statement; 333, 334; 334, assignment; 334, 335; 334, 336; 335, identifier:affected_event_tag; 336, call; 336, 337; 336, 340; 337, attribute; 337, 338; 337, 339; 338, identifier:event; 339, identifier:find; 340, argument_list; 340, 341; 341, string:".//*[@role=':AFFECTED']"; 342, if_statement; 342, 343; 342, 346; 343, comparison_operator:is; 343, 344; 343, 345; 344, identifier:affected_event_tag; 345, None; 346, block; 346, 347; 346, 356; 347, expression_statement; 347, 348; 348, assignment; 348, 349; 348, 350; 349, identifier:affected_event_tag; 350, call; 350, 351; 350, 354; 351, attribute; 351, 352; 351, 353; 352, identifier:event; 353, identifier:find; 354, argument_list; 354, 355; 355, string:".//*[@role=':OUTCOME']"; 356, if_statement; 356, 357; 356, 360; 357, comparison_operator:is; 357, 358; 357, 359; 358, identifier:affected_event_tag; 359, None; 360, block; 360, 361; 361, return_statement; 362, expression_statement; 362, 363; 363, assignment; 363, 364; 363, 365; 364, identifier:affected_id; 365, call; 365, 366; 365, 371; 366, attribute; 366, 367; 366, 370; 367, attribute; 367, 368; 367, 369; 368, identifier:affected_event_tag; 369, identifier:attrib; 370, identifier:get; 371, argument_list; 371, 372; 372, string:'id'; 373, if_statement; 373, 374; 373, 376; 374, not_operator; 374, 375; 375, identifier:affected_id; 376, block; 376, 377; 377, return_statement; 378, expression_statement; 378, 379; 379, assignment; 379, 380; 379, 381; 380, identifier:affected_event; 381, call; 381, 382; 381, 387; 382, attribute; 382, 383; 382, 386; 383, attribute; 383, 384; 383, 385; 384, identifier:self; 385, identifier:tree; 386, identifier:find; 387, argument_list; 387, 388; 388, binary_operator:%; 388, 389; 388, 390; 389, string:"EVENT/[@id='%s']"; 390, identifier:affected_id; 391, if_statement; 391, 392; 391, 395; 392, comparison_operator:is; 392, 393; 392, 394; 393, identifier:affected_event; 394, None; 395, block; 395, 396; 396, return_statement; 397, for_statement; 397, 398; 397, 399; 397, 404; 398, identifier:enz_t; 399, call; 399, 400; 399, 401; 400, identifier:_agent_list_product; 401, argument_list; 401, 402; 402, tuple; 402, 403; 403, identifier:enzyme_agent; 404, block; 404, 405; 404, 411; 404, 420; 404, 424; 404, 451; 405, expression_statement; 405, 406; 406, assignment; 406, 407; 406, 408; 407, identifier:enz; 408, subscript; 408, 409; 408, 410; 409, identifier:enz_t; 410, integer:0; 411, expression_statement; 411, 412; 412, assignment; 412, 413; 412, 414; 413, identifier:stmts; 414, call; 414, 415; 414, 418; 415, attribute; 415, 416; 415, 417; 416, identifier:self; 417, identifier:_get_modification_event; 418, argument_list; 418, 419; 419, identifier:affected_event; 420, expression_statement; 420, 421; 421, assignment; 421, 422; 421, 423; 422, identifier:stmts_to_make; 423, list:[]; 424, if_statement; 424, 425; 424, 426; 425, identifier:stmts; 426, block; 426, 427; 427, for_statement; 427, 428; 427, 429; 427, 430; 428, identifier:stmt; 429, identifier:stmts; 430, block; 430, 431; 431, if_statement; 431, 432; 431, 443; 432, boolean_operator:and; 432, 433; 432, 438; 433, comparison_operator:is; 433, 434; 433, 437; 434, attribute; 434, 435; 434, 436; 435, identifier:stmt; 436, identifier:enz; 437, None; 438, comparison_operator:is; 438, 439; 438, 442; 439, attribute; 439, 440; 439, 441; 440, identifier:stmt; 441, identifier:sub; 442, None; 443, block; 443, 444; 444, expression_statement; 444, 445; 445, call; 445, 446; 445, 449; 446, attribute; 446, 447; 446, 448; 447, identifier:stmts_to_make; 448, identifier:append; 449, argument_list; 449, 450; 450, identifier:stmt; 451, for_statement; 451, 452; 451, 453; 451, 454; 452, identifier:stmt; 453, identifier:stmts_to_make; 454, block; 454, 455; 454, 461; 454, 475; 455, expression_statement; 455, 456; 456, assignment; 456, 457; 456, 460; 457, attribute; 457, 458; 457, 459; 458, identifier:stmt; 459, identifier:enz; 460, identifier:enz; 461, for_statement; 461, 462; 461, 463; 461, 466; 462, identifier:ev; 463, attribute; 463, 464; 463, 465; 464, identifier:stmt; 465, identifier:evidence; 466, block; 466, 467; 467, expression_statement; 467, 468; 468, assignment; 468, 469; 468, 474; 469, subscript; 469, 470; 469, 473; 470, attribute; 470, 471; 470, 472; 471, identifier:ev; 472, identifier:epistemics; 473, string:'direct'; 474, False; 475, expression_statement; 475, 476; 476, call; 476, 477; 476, 482; 477, attribute; 477, 478; 477, 481; 478, attribute; 478, 479; 478, 480; 479, identifier:self; 480, identifier:statements; 481, identifier:append; 482, argument_list; 482, 483; 483, identifier:stmt; 484, expression_statement; 484, 485; 485, call; 485, 486; 485, 489; 486, attribute; 486, 487; 486, 488; 487, identifier:self; 488, identifier:_add_extracted; 489, argument_list; 489, 490; 489, 491; 490, identifier:event_type; 491, subscript; 491, 492; 491, 495; 492, attribute; 492, 493; 492, 494; 493, identifier:event; 494, identifier:attrib; 495, string:'id'; 496, expression_statement; 496, 497; 497, call; 497, 498; 497, 501; 498, attribute; 498, 499; 498, 500; 499, identifier:self; 500, identifier:_add_extracted; 501, argument_list; 501, 502; 501, 510; 502, attribute; 502, 503; 502, 509; 503, call; 503, 504; 503, 507; 504, attribute; 504, 505; 504, 506; 505, identifier:affected_event; 506, identifier:find; 507, argument_list; 507, 508; 508, string:'type'; 509, identifier:text; 510, identifier:affected_id | def get_modifications_indirect(self):
mod_event_types = list(ont_to_mod_type.keys())
mod_event_types += ['ONT::PTM']
def get_increase_events(mod_event_types):
mod_events = []
events = self.tree.findall("EVENT/[type='ONT::INCREASE']")
for event in events:
affected = event.find(".//*[@role=':AFFECTED']")
if affected is None:
continue
affected_id = affected.attrib.get('id')
if not affected_id:
continue
pattern = "EVENT/[@id='%s']" % affected_id
affected_event = self.tree.find(pattern)
if affected_event is not None:
affected_type = affected_event.find('type')
if affected_type is not None and \
affected_type.text in mod_event_types:
mod_events.append(event)
return mod_events
def get_cause_events(mod_event_types):
mod_events = []
ccs = self.tree.findall("CC/[type='ONT::CAUSE']")
for cc in ccs:
outcome = cc.find(".//*[@role=':OUTCOME']")
if outcome is None:
continue
outcome_id = outcome.attrib.get('id')
if not outcome_id:
continue
pattern = "EVENT/[@id='%s']" % outcome_id
outcome_event = self.tree.find(pattern)
if outcome_event is not None:
outcome_type = outcome_event.find('type')
if outcome_type is not None and \
outcome_type.text in mod_event_types:
mod_events.append(cc)
return mod_events
mod_events = get_increase_events(mod_event_types)
mod_events += get_cause_events(mod_event_types)
for event in mod_events:
event_id = event.attrib['id']
if event_id in self._static_events:
continue
event_type = _get_type(event)
enzyme = event.find(".//*[@role=':AGENT']")
if enzyme is None:
enzyme = event.find(".//*[@role=':FACTOR']")
if enzyme is None:
return
enzyme_id = enzyme.attrib.get('id')
if enzyme_id is None:
continue
enzyme_agent = self._get_agent_by_id(enzyme_id, event_id)
affected_event_tag = event.find(".//*[@role=':AFFECTED']")
if affected_event_tag is None:
affected_event_tag = event.find(".//*[@role=':OUTCOME']")
if affected_event_tag is None:
return
affected_id = affected_event_tag.attrib.get('id')
if not affected_id:
return
affected_event = self.tree.find("EVENT/[@id='%s']" % affected_id)
if affected_event is None:
return
for enz_t in _agent_list_product((enzyme_agent, )):
enz = enz_t[0]
stmts = self._get_modification_event(affected_event)
stmts_to_make = []
if stmts:
for stmt in stmts:
if stmt.enz is None and stmt.sub is not None:
stmts_to_make.append(stmt)
for stmt in stmts_to_make:
stmt.enz = enz
for ev in stmt.evidence:
ev.epistemics['direct'] = False
self.statements.append(stmt)
self._add_extracted(event_type, event.attrib['id'])
self._add_extracted(affected_event.find('type').text, affected_id) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:replace_activities; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 13; 5, 17; 5, 47; 5, 53; 5, 272; 6, expression_statement; 6, 7; 7, call; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:logger; 10, identifier:debug; 11, argument_list; 11, 12; 12, string:'Running PySB Preassembler replace activities'; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:new_stmts; 16, list:[]; 17, function_definition; 17, 18; 17, 19; 17, 21; 18, function_name:has_agent_activity; 19, parameters; 19, 20; 20, identifier:stmt; 21, block; 21, 22; 21, 45; 22, for_statement; 22, 23; 22, 24; 22, 29; 23, identifier:agent; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:stmt; 27, identifier:agent_list; 28, argument_list; 29, block; 29, 30; 30, if_statement; 30, 31; 30, 42; 31, boolean_operator:and; 31, 32; 31, 37; 32, call; 32, 33; 32, 34; 33, identifier:isinstance; 34, argument_list; 34, 35; 34, 36; 35, identifier:agent; 36, identifier:Agent; 37, comparison_operator:is; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:agent; 40, identifier:activity; 41, None; 42, block; 42, 43; 43, return_statement; 43, 44; 44, True; 45, return_statement; 45, 46; 46, False; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:_gather_active_forms; 52, argument_list; 53, for_statement; 53, 54; 53, 57; 53, 63; 54, pattern_list; 54, 55; 54, 56; 55, identifier:j; 56, identifier:stmt; 57, call; 57, 58; 57, 59; 58, identifier:enumerate; 59, argument_list; 59, 60; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:statements; 63, block; 63, 64; 63, 83; 63, 98; 63, 106; 63, 113; 63, 121; 63, 237; 63, 247; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:logger; 68, identifier:debug; 69, argument_list; 69, 70; 70, binary_operator:%; 70, 71; 70, 72; 71, string:'%d/%d %s'; 72, tuple; 72, 73; 72, 76; 72, 82; 73, binary_operator:+; 73, 74; 73, 75; 74, identifier:j; 75, integer:1; 76, call; 76, 77; 76, 78; 77, identifier:len; 78, argument_list; 78, 79; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:statements; 82, identifier:stmt; 83, if_statement; 83, 84; 83, 89; 84, not_operator; 84, 85; 85, call; 85, 86; 85, 87; 86, identifier:has_agent_activity; 87, argument_list; 87, 88; 88, identifier:stmt; 89, block; 89, 90; 89, 97; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:new_stmts; 94, identifier:append; 95, argument_list; 95, 96; 96, identifier:stmt; 97, continue_statement; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:stmt_agents; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:stmt; 104, identifier:agent_list; 105, argument_list; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:num_agents; 109, call; 109, 110; 109, 111; 110, identifier:len; 111, argument_list; 111, 112; 112, identifier:stmt_agents; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:agent_forms; 116, list_comprehension; 116, 117; 116, 118; 117, list:[]; 118, for_in_clause; 118, 119; 118, 120; 119, identifier:a; 120, identifier:stmt_agents; 121, for_statement; 121, 122; 121, 125; 121, 129; 122, pattern_list; 122, 123; 122, 124; 123, identifier:i; 124, identifier:agent; 125, call; 125, 126; 125, 127; 126, identifier:enumerate; 127, argument_list; 127, 128; 128, identifier:stmt_agents; 129, block; 129, 130; 130, if_statement; 130, 131; 130, 147; 130, 226; 131, boolean_operator:and; 131, 132; 131, 141; 131, 142; 132, boolean_operator:and; 132, 133; 132, 136; 133, comparison_operator:is; 133, 134; 133, 135; 134, identifier:agent; 135, None; 136, call; 136, 137; 136, 138; 137, identifier:isinstance; 138, argument_list; 138, 139; 138, 140; 139, identifier:agent; 140, identifier:Agent; 141, line_continuation:\; 142, comparison_operator:is; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:agent; 145, identifier:activity; 146, None; 147, block; 147, 148; 147, 159; 147, 198; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:base_agent; 151, call; 151, 152; 151, 157; 152, attribute; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:agent_set; 156, identifier:get_create_base_agent; 157, argument_list; 157, 158; 158, identifier:agent; 159, if_statement; 159, 160; 159, 165; 159, 181; 160, attribute; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:agent; 163, identifier:activity; 164, identifier:is_active; 165, block; 165, 166; 165, 172; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:active_forms; 169, attribute; 169, 170; 169, 171; 170, identifier:base_agent; 171, identifier:active_forms; 172, if_statement; 172, 173; 172, 175; 173, not_operator; 173, 174; 174, identifier:active_forms; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:active_forms; 179, list:[agent]; 179, 180; 180, identifier:agent; 181, else_clause; 181, 182; 182, block; 182, 183; 182, 189; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:active_forms; 186, attribute; 186, 187; 186, 188; 187, identifier:base_agent; 188, identifier:inactive_forms; 189, if_statement; 189, 190; 189, 192; 190, not_operator; 190, 191; 191, identifier:active_forms; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:active_forms; 196, list:[agent]; 196, 197; 197, identifier:agent; 198, for_statement; 198, 199; 198, 200; 198, 201; 199, identifier:af; 200, identifier:active_forms; 201, block; 201, 202; 201, 209; 201, 217; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:new_agent; 205, call; 205, 206; 205, 207; 206, identifier:fast_deepcopy; 207, argument_list; 207, 208; 208, identifier:agent; 209, expression_statement; 209, 210; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:self; 213, identifier:_set_agent_context; 214, argument_list; 214, 215; 214, 216; 215, identifier:af; 216, identifier:new_agent; 217, expression_statement; 217, 218; 218, call; 218, 219; 218, 224; 219, attribute; 219, 220; 219, 223; 220, subscript; 220, 221; 220, 222; 221, identifier:agent_forms; 222, identifier:i; 223, identifier:append; 224, argument_list; 224, 225; 225, identifier:new_agent; 226, else_clause; 226, 227; 227, block; 227, 228; 228, expression_statement; 228, 229; 229, call; 229, 230; 229, 235; 230, attribute; 230, 231; 230, 234; 231, subscript; 231, 232; 231, 233; 232, identifier:agent_forms; 233, identifier:i; 234, identifier:append; 235, argument_list; 235, 236; 236, identifier:agent; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:agent_combs; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:itertools; 243, identifier:product; 244, argument_list; 244, 245; 245, list_splat; 245, 246; 246, identifier:agent_forms; 247, for_statement; 247, 248; 247, 249; 247, 250; 248, identifier:agent_comb; 249, identifier:agent_combs; 250, block; 250, 251; 250, 258; 250, 265; 251, expression_statement; 251, 252; 252, assignment; 252, 253; 252, 254; 253, identifier:new_stmt; 254, call; 254, 255; 254, 256; 255, identifier:fast_deepcopy; 256, argument_list; 256, 257; 257, identifier:stmt; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:new_stmt; 262, identifier:set_agent_list; 263, argument_list; 263, 264; 264, identifier:agent_comb; 265, expression_statement; 265, 266; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:new_stmts; 269, identifier:append; 270, argument_list; 270, 271; 271, identifier:new_stmt; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:self; 276, identifier:statements; 277, identifier:new_stmts | def replace_activities(self):
logger.debug('Running PySB Preassembler replace activities')
new_stmts = []
def has_agent_activity(stmt):
for agent in stmt.agent_list():
if isinstance(agent, Agent) and agent.activity is not None:
return True
return False
self._gather_active_forms()
for j, stmt in enumerate(self.statements):
logger.debug('%d/%d %s' % (j + 1, len(self.statements), stmt))
if not has_agent_activity(stmt):
new_stmts.append(stmt)
continue
stmt_agents = stmt.agent_list()
num_agents = len(stmt_agents)
agent_forms = [[] for a in stmt_agents]
for i, agent in enumerate(stmt_agents):
if agent is not None and isinstance(agent, Agent) and \
agent.activity is not None:
base_agent = self.agent_set.get_create_base_agent(agent)
if agent.activity.is_active:
active_forms = base_agent.active_forms
if not active_forms:
active_forms = [agent]
else:
active_forms = base_agent.inactive_forms
if not active_forms:
active_forms = [agent]
for af in active_forms:
new_agent = fast_deepcopy(agent)
self._set_agent_context(af, new_agent)
agent_forms[i].append(new_agent)
else:
agent_forms[i].append(agent)
agent_combs = itertools.product(*agent_forms)
for agent_comb in agent_combs:
new_stmt = fast_deepcopy(stmt)
new_stmt.set_agent_list(agent_comb)
new_stmts.append(new_stmt)
self.statements = new_stmts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:add_reverse_effects; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 10; 5, 14; 5, 18; 5, 22; 5, 208; 5, 212; 5, 276; 5, 303; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:pos_mod_sites; 9, dictionary; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:neg_mod_sites; 13, dictionary; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:syntheses; 17, list:[]; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:degradations; 21, list:[]; 22, for_statement; 22, 23; 22, 24; 22, 27; 23, identifier:stmt; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:statements; 27, block; 27, 28; 28, if_statement; 28, 29; 28, 34; 28, 76; 28, 124; 28, 172; 28, 190; 29, call; 29, 30; 29, 31; 30, identifier:isinstance; 31, argument_list; 31, 32; 31, 33; 32, identifier:stmt; 33, identifier:Phosphorylation; 34, block; 34, 35; 34, 43; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:agent; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:stmt; 41, identifier:sub; 42, identifier:name; 43, try_statement; 43, 44; 43, 60; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 52; 47, attribute; 47, 48; 47, 51; 48, subscript; 48, 49; 48, 50; 49, identifier:pos_mod_sites; 50, identifier:agent; 51, identifier:append; 52, argument_list; 52, 53; 53, tuple; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:stmt; 56, identifier:residue; 57, attribute; 57, 58; 57, 59; 58, identifier:stmt; 59, identifier:position; 60, except_clause; 60, 61; 60, 62; 61, identifier:KeyError; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:pos_mod_sites; 67, identifier:agent; 68, list:[(stmt.residue, stmt.position)]; 68, 69; 69, tuple; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:stmt; 72, identifier:residue; 73, attribute; 73, 74; 73, 75; 74, identifier:stmt; 75, identifier:position; 76, elif_clause; 76, 77; 76, 82; 77, call; 77, 78; 77, 79; 78, identifier:isinstance; 79, argument_list; 79, 80; 79, 81; 80, identifier:stmt; 81, identifier:Dephosphorylation; 82, block; 82, 83; 82, 91; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:agent; 86, attribute; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:stmt; 89, identifier:sub; 90, identifier:name; 91, try_statement; 91, 92; 91, 108; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 100; 95, attribute; 95, 96; 95, 99; 96, subscript; 96, 97; 96, 98; 97, identifier:neg_mod_sites; 98, identifier:agent; 99, identifier:append; 100, argument_list; 100, 101; 101, tuple; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:stmt; 104, identifier:residue; 105, attribute; 105, 106; 105, 107; 106, identifier:stmt; 107, identifier:position; 108, except_clause; 108, 109; 108, 110; 109, identifier:KeyError; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 116; 113, subscript; 113, 114; 113, 115; 114, identifier:neg_mod_sites; 115, identifier:agent; 116, list:[(stmt.residue, stmt.position)]; 116, 117; 117, tuple; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:stmt; 120, identifier:residue; 121, attribute; 121, 122; 121, 123; 122, identifier:stmt; 123, identifier:position; 124, elif_clause; 124, 125; 124, 130; 125, call; 125, 126; 125, 127; 126, identifier:isinstance; 127, argument_list; 127, 128; 127, 129; 128, identifier:stmt; 129, identifier:Influence; 130, block; 130, 131; 131, if_statement; 131, 132; 131, 139; 131, 151; 132, comparison_operator:==; 132, 133; 132, 138; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:stmt; 136, identifier:overall_polarity; 137, argument_list; 138, integer:1; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:syntheses; 144, identifier:append; 145, argument_list; 145, 146; 146, attribute; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:stmt; 149, identifier:obj; 150, identifier:name; 151, elif_clause; 151, 152; 151, 160; 152, comparison_operator:==; 152, 153; 152, 158; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:stmt; 156, identifier:overall_polarity; 157, argument_list; 158, unary_operator:-; 158, 159; 159, integer:1; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:degradations; 165, identifier:append; 166, argument_list; 166, 167; 167, attribute; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:stmt; 170, identifier:obj; 171, identifier:name; 172, elif_clause; 172, 173; 172, 178; 173, call; 173, 174; 173, 175; 174, identifier:isinstance; 175, argument_list; 175, 176; 175, 177; 176, identifier:stmt; 177, identifier:IncreaseAmount; 178, block; 178, 179; 179, expression_statement; 179, 180; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:syntheses; 183, identifier:append; 184, argument_list; 184, 185; 185, attribute; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:stmt; 188, identifier:obj; 189, identifier:name; 190, elif_clause; 190, 191; 190, 196; 191, call; 191, 192; 191, 193; 192, identifier:isinstance; 193, argument_list; 193, 194; 193, 195; 194, identifier:stmt; 195, identifier:DecreaseAmount; 196, block; 196, 197; 197, expression_statement; 197, 198; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:degradations; 201, identifier:append; 202, argument_list; 202, 203; 203, attribute; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:stmt; 206, identifier:obj; 207, identifier:name; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:new_stmts; 211, list:[]; 212, for_statement; 212, 213; 212, 216; 212, 221; 213, pattern_list; 213, 214; 213, 215; 214, identifier:agent_name; 215, identifier:pos_sites; 216, call; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:pos_mod_sites; 219, identifier:items; 220, argument_list; 221, block; 221, 222; 221, 232; 221, 247; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:neg_sites; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:neg_mod_sites; 228, identifier:get; 229, argument_list; 229, 230; 229, 231; 230, identifier:agent_name; 231, list:[]; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 235; 234, identifier:no_neg_site; 235, call; 235, 236; 235, 242; 236, attribute; 236, 237; 236, 241; 237, call; 237, 238; 237, 239; 238, identifier:set; 239, argument_list; 239, 240; 240, identifier:pos_sites; 241, identifier:difference; 242, argument_list; 242, 243; 243, call; 243, 244; 243, 245; 244, identifier:set; 245, argument_list; 245, 246; 246, identifier:neg_sites; 247, for_statement; 247, 248; 247, 251; 247, 252; 248, pattern_list; 248, 249; 248, 250; 249, identifier:residue; 250, identifier:position; 251, identifier:no_neg_site; 252, block; 252, 253; 252, 269; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:st; 256, call; 256, 257; 256, 258; 257, identifier:Dephosphorylation; 258, argument_list; 258, 259; 258, 263; 258, 267; 258, 268; 259, call; 259, 260; 259, 261; 260, identifier:Agent; 261, argument_list; 261, 262; 262, string:'phosphatase'; 263, call; 263, 264; 263, 265; 264, identifier:Agent; 265, argument_list; 265, 266; 266, identifier:agent_name; 267, identifier:residue; 268, identifier:position; 269, expression_statement; 269, 270; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:new_stmts; 273, identifier:append; 274, argument_list; 274, 275; 275, identifier:st; 276, for_statement; 276, 277; 276, 278; 276, 279; 277, identifier:agent_name; 278, identifier:syntheses; 279, block; 279, 280; 280, if_statement; 280, 281; 280, 284; 281, comparison_operator:not; 281, 282; 281, 283; 282, identifier:agent_name; 283, identifier:degradations; 284, block; 284, 285; 284, 296; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:st; 288, call; 288, 289; 288, 290; 289, identifier:DecreaseAmount; 290, argument_list; 290, 291; 290, 292; 291, None; 292, call; 292, 293; 292, 294; 293, identifier:Agent; 294, argument_list; 294, 295; 295, identifier:agent_name; 296, expression_statement; 296, 297; 297, call; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:new_stmts; 300, identifier:append; 301, argument_list; 301, 302; 302, identifier:st; 303, expression_statement; 303, 304; 304, augmented_assignment:+=; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:self; 307, identifier:statements; 308, identifier:new_stmts | def add_reverse_effects(self):
pos_mod_sites = {}
neg_mod_sites = {}
syntheses = []
degradations = []
for stmt in self.statements:
if isinstance(stmt, Phosphorylation):
agent = stmt.sub.name
try:
pos_mod_sites[agent].append((stmt.residue, stmt.position))
except KeyError:
pos_mod_sites[agent] = [(stmt.residue, stmt.position)]
elif isinstance(stmt, Dephosphorylation):
agent = stmt.sub.name
try:
neg_mod_sites[agent].append((stmt.residue, stmt.position))
except KeyError:
neg_mod_sites[agent] = [(stmt.residue, stmt.position)]
elif isinstance(stmt, Influence):
if stmt.overall_polarity() == 1:
syntheses.append(stmt.obj.name)
elif stmt.overall_polarity() == -1:
degradations.append(stmt.obj.name)
elif isinstance(stmt, IncreaseAmount):
syntheses.append(stmt.obj.name)
elif isinstance(stmt, DecreaseAmount):
degradations.append(stmt.obj.name)
new_stmts = []
for agent_name, pos_sites in pos_mod_sites.items():
neg_sites = neg_mod_sites.get(agent_name, [])
no_neg_site = set(pos_sites).difference(set(neg_sites))
for residue, position in no_neg_site:
st = Dephosphorylation(Agent('phosphatase'),
Agent(agent_name),
residue, position)
new_stmts.append(st)
for agent_name in syntheses:
if agent_name not in degradations:
st = DecreaseAmount(None, Agent(agent_name))
new_stmts.append(st)
self.statements += new_stmts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:map_sites; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:stmts; 6, block; 6, 7; 6, 11; 6, 15; 6, 49; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:valid_statements; 10, list:[]; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:mapped_statements; 14, list:[]; 15, for_statement; 15, 16; 15, 17; 15, 18; 16, identifier:stmt; 17, identifier:stmts; 18, block; 18, 19; 18, 28; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:mapped_stmt; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:map_stmt_sites; 26, argument_list; 26, 27; 27, identifier:stmt; 28, if_statement; 28, 29; 28, 32; 28, 40; 29, comparison_operator:is; 29, 30; 29, 31; 30, identifier:mapped_stmt; 31, None; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:mapped_statements; 37, identifier:append; 38, argument_list; 38, 39; 39, identifier:mapped_stmt; 40, else_clause; 40, 41; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:valid_statements; 46, identifier:append; 47, argument_list; 47, 48; 48, identifier:stmt; 49, return_statement; 49, 50; 50, expression_list; 50, 51; 50, 52; 51, identifier:valid_statements; 52, identifier:mapped_statements | def map_sites(self, stmts):
valid_statements = []
mapped_statements = []
for stmt in stmts:
mapped_stmt = self.map_stmt_sites(stmt)
if mapped_stmt is not None:
mapped_statements.append(mapped_stmt)
else:
valid_statements.append(stmt)
return valid_statements, mapped_statements |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_map_agent_sites; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:agent; 6, block; 6, 7; 6, 21; 6, 28; 6, 32; 6, 105; 7, if_statement; 7, 8; 7, 16; 8, boolean_operator:or; 8, 9; 8, 12; 9, comparison_operator:is; 9, 10; 9, 11; 10, identifier:agent; 11, None; 12, not_operator; 12, 13; 13, attribute; 13, 14; 13, 15; 14, identifier:agent; 15, identifier:mods; 16, block; 16, 17; 17, return_statement; 17, 18; 18, expression_list; 18, 19; 18, 20; 19, list:[]; 20, identifier:agent; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:new_agent; 24, call; 24, 25; 24, 26; 25, identifier:deepcopy; 26, argument_list; 26, 27; 27, identifier:agent; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:mapped_sites; 31, list:[]; 32, for_statement; 32, 33; 32, 36; 32, 42; 33, pattern_list; 33, 34; 33, 35; 34, identifier:idx; 35, identifier:mod_condition; 36, call; 36, 37; 36, 38; 37, identifier:enumerate; 38, argument_list; 38, 39; 39, attribute; 39, 40; 39, 41; 40, identifier:agent; 41, identifier:mods; 42, block; 42, 43; 42, 54; 42, 65; 42, 98; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 44, 47; 45, identifier:mapped_site; 46, line_continuation:\; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:_map_agent_mod; 51, argument_list; 51, 52; 51, 53; 52, identifier:agent; 53, identifier:mod_condition; 54, if_statement; 54, 55; 54, 63; 55, boolean_operator:or; 55, 56; 55, 58; 56, not_operator; 56, 57; 57, identifier:mapped_site; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:mapped_site; 61, identifier:not_invalid; 62, argument_list; 63, block; 63, 64; 64, continue_statement; 65, if_statement; 65, 66; 65, 71; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:mapped_site; 69, identifier:has_mapping; 70, argument_list; 71, block; 71, 72; 71, 90; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:mc; 75, call; 75, 76; 75, 77; 76, identifier:ModCondition; 77, argument_list; 77, 78; 77, 81; 77, 84; 77, 87; 78, attribute; 78, 79; 78, 80; 79, identifier:mod_condition; 80, identifier:mod_type; 81, attribute; 81, 82; 81, 83; 82, identifier:mapped_site; 83, identifier:mapped_res; 84, attribute; 84, 85; 84, 86; 85, identifier:mapped_site; 86, identifier:mapped_pos; 87, attribute; 87, 88; 87, 89; 88, identifier:mod_condition; 89, identifier:is_modified; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 97; 92, subscript; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:new_agent; 95, identifier:mods; 96, identifier:idx; 97, identifier:mc; 98, expression_statement; 98, 99; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:mapped_sites; 102, identifier:append; 103, argument_list; 103, 104; 104, identifier:mapped_site; 105, return_statement; 105, 106; 106, expression_list; 106, 107; 106, 108; 107, identifier:mapped_sites; 108, identifier:new_agent | def _map_agent_sites(self, agent):
if agent is None or not agent.mods:
return [], agent
new_agent = deepcopy(agent)
mapped_sites = []
for idx, mod_condition in enumerate(agent.mods):
mapped_site = \
self._map_agent_mod(agent, mod_condition)
if not mapped_site or mapped_site.not_invalid():
continue
if mapped_site.has_mapping():
mc = ModCondition(mod_condition.mod_type,
mapped_site.mapped_res,
mapped_site.mapped_pos,
mod_condition.is_modified)
new_agent.mods[idx] = mc
mapped_sites.append(mapped_site)
return mapped_sites, new_agent |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_map_agent_mod; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:agent; 6, identifier:mod_condition; 7, block; 7, 8; 7, 15; 7, 32; 7, 47; 7, 79; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:up_id; 11, call; 11, 12; 11, 13; 12, identifier:_get_uniprot_id; 13, argument_list; 13, 14; 14, identifier:agent; 15, if_statement; 15, 16; 15, 18; 16, not_operator; 16, 17; 17, identifier:up_id; 18, block; 18, 19; 18, 30; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:logger; 23, identifier:debug; 24, argument_list; 24, 25; 25, binary_operator:%; 25, 26; 25, 27; 26, string:"No uniprot ID for %s"; 27, attribute; 27, 28; 27, 29; 28, identifier:agent; 29, identifier:name; 30, return_statement; 30, 31; 31, None; 32, if_statement; 32, 33; 32, 44; 33, boolean_operator:or; 33, 34; 33, 39; 34, comparison_operator:is; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:mod_condition; 37, identifier:position; 38, None; 39, comparison_operator:is; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:mod_condition; 42, identifier:residue; 43, None; 44, block; 44, 45; 45, return_statement; 45, 46; 46, None; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 48, 51; 49, identifier:mapped_site; 50, line_continuation:\; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:map_to_human_ref; 55, argument_list; 55, 56; 55, 57; 55, 58; 55, 61; 55, 64; 55, 69; 55, 74; 56, identifier:up_id; 57, string:'uniprot'; 58, attribute; 58, 59; 58, 60; 59, identifier:mod_condition; 60, identifier:residue; 61, attribute; 61, 62; 61, 63; 62, identifier:mod_condition; 63, identifier:position; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:do_methionine_offset; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:do_methionine_offset; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:do_orthology_mapping; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:do_orthology_mapping; 74, keyword_argument; 74, 75; 74, 76; 75, identifier:do_isoform_mapping; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:do_isoform_mapping; 79, return_statement; 79, 80; 80, identifier:mapped_site | def _map_agent_mod(self, agent, mod_condition):
up_id = _get_uniprot_id(agent)
if not up_id:
logger.debug("No uniprot ID for %s" % agent.name)
return None
if mod_condition.position is None or mod_condition.residue is None:
return None
mapped_site = \
self.map_to_human_ref(up_id, 'uniprot',
mod_condition.residue,
mod_condition.position,
do_methionine_offset=self.do_methionine_offset,
do_orthology_mapping=self.do_orthology_mapping,
do_isoform_mapping=self.do_isoform_mapping)
return mapped_site |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_get_graph_reductions; 3, parameters; 3, 4; 4, identifier:graph; 5, block; 5, 6; 5, 60; 5, 64; 5, 80; 5, 92; 5, 131; 6, function_definition; 6, 7; 6, 8; 6, 11; 7, function_name:frontier; 8, parameters; 8, 9; 8, 10; 9, identifier:g; 10, identifier:nd; 11, block; 11, 12; 12, if_statement; 12, 13; 12, 21; 12, 28; 13, comparison_operator:==; 13, 14; 13, 20; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:g; 17, identifier:out_degree; 18, argument_list; 18, 19; 19, identifier:nd; 20, integer:0; 21, block; 21, 22; 22, return_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:set; 25, argument_list; 25, 26; 26, list:[nd]; 26, 27; 27, identifier:nd; 28, else_clause; 28, 29; 29, block; 29, 30; 29, 36; 29, 58; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:frontiers; 33, call; 33, 34; 33, 35; 34, identifier:set; 35, argument_list; 36, for_statement; 36, 37; 36, 38; 36, 44; 37, identifier:n; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:g; 41, identifier:successors; 42, argument_list; 42, 43; 43, identifier:nd; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:frontiers; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:frontiers; 51, identifier:union; 52, argument_list; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:frontier; 55, argument_list; 55, 56; 55, 57; 56, identifier:graph; 57, identifier:n; 58, return_statement; 58, 59; 59, identifier:frontiers; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:reductions; 63, dictionary; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:nodes_sort; 67, call; 67, 68; 67, 69; 68, identifier:list; 69, argument_list; 69, 70; 70, call; 70, 71; 70, 78; 71, attribute; 71, 72; 71, 77; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:networkx; 75, identifier:algorithms; 76, identifier:dag; 77, identifier:topological_sort; 78, argument_list; 78, 79; 79, identifier:graph; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:frontiers; 83, list_comprehension; 83, 84; 83, 89; 84, call; 84, 85; 84, 86; 85, identifier:frontier; 86, argument_list; 86, 87; 86, 88; 87, identifier:graph; 88, identifier:n; 89, for_in_clause; 89, 90; 89, 91; 90, identifier:n; 91, identifier:nodes_sort; 92, for_statement; 92, 93; 92, 96; 92, 100; 93, pattern_list; 93, 94; 93, 95; 94, identifier:i; 95, identifier:n1; 96, call; 96, 97; 96, 98; 97, identifier:enumerate; 98, argument_list; 98, 99; 99, identifier:nodes_sort; 100, block; 100, 101; 101, for_statement; 101, 102; 101, 105; 101, 109; 102, pattern_list; 102, 103; 102, 104; 103, identifier:j; 104, identifier:n2; 105, call; 105, 106; 105, 107; 106, identifier:enumerate; 107, argument_list; 107, 108; 108, identifier:nodes_sort; 109, block; 109, 110; 109, 116; 110, if_statement; 110, 111; 110, 114; 111, comparison_operator:>; 111, 112; 111, 113; 112, identifier:i; 113, identifier:j; 114, block; 114, 115; 115, continue_statement; 116, if_statement; 116, 117; 116, 124; 117, comparison_operator:==; 117, 118; 117, 121; 118, subscript; 118, 119; 118, 120; 119, identifier:frontiers; 120, identifier:i; 121, subscript; 121, 122; 121, 123; 122, identifier:frontiers; 123, identifier:j; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 130; 127, subscript; 127, 128; 127, 129; 128, identifier:reductions; 129, identifier:n1; 130, identifier:n2; 131, return_statement; 131, 132; 132, identifier:reductions | def _get_graph_reductions(graph):
def frontier(g, nd):
if g.out_degree(nd) == 0:
return set([nd])
else:
frontiers = set()
for n in g.successors(nd):
frontiers = frontiers.union(frontier(graph, n))
return frontiers
reductions = {}
nodes_sort = list(networkx.algorithms.dag.topological_sort(graph))
frontiers = [frontier(graph, n) for n in nodes_sort]
for i, n1 in enumerate(nodes_sort):
for j, n2 in enumerate(nodes_sort):
if i > j:
continue
if frontiers[i] == frontiers[j]:
reductions[n1] = n2
return reductions |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:gather_implicit_activities; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, for_statement; 6, 7; 6, 8; 6, 11; 7, identifier:stmt; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:statements; 11, block; 11, 12; 12, if_statement; 12, 13; 12, 32; 12, 70; 12, 114; 12, 158; 12, 202; 12, 271; 12, 340; 13, boolean_operator:or; 13, 14; 13, 26; 13, 27; 14, boolean_operator:or; 14, 15; 14, 20; 14, 21; 15, call; 15, 16; 15, 17; 16, identifier:isinstance; 17, argument_list; 17, 18; 17, 19; 18, identifier:stmt; 19, identifier:Phosphorylation; 20, line_continuation:\; 21, call; 21, 22; 21, 23; 22, identifier:isinstance; 23, argument_list; 23, 24; 23, 25; 24, identifier:stmt; 25, identifier:Transphosphorylation; 26, line_continuation:\; 27, call; 27, 28; 27, 29; 28, identifier:isinstance; 29, argument_list; 29, 30; 29, 31; 30, identifier:stmt; 31, identifier:Autophosphorylation; 32, block; 32, 33; 33, if_statement; 33, 34; 33, 39; 34, comparison_operator:is; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:stmt; 37, identifier:enz; 38, None; 39, block; 39, 40; 39, 51; 39, 58; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:enz_base; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:_get_base; 47, argument_list; 47, 48; 48, attribute; 48, 49; 48, 50; 49, identifier:stmt; 50, identifier:enz; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:enz_base; 55, identifier:add_activity; 56, argument_list; 56, 57; 57, string:'kinase'; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:enz_base; 62, identifier:add_active_state; 63, argument_list; 63, 64; 63, 65; 64, string:'kinase'; 65, attribute; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:stmt; 68, identifier:enz; 69, identifier:mods; 70, elif_clause; 70, 71; 70, 76; 71, call; 71, 72; 71, 73; 72, identifier:isinstance; 73, argument_list; 73, 74; 73, 75; 74, identifier:stmt; 75, identifier:Dephosphorylation; 76, block; 76, 77; 77, if_statement; 77, 78; 77, 83; 78, comparison_operator:is; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:stmt; 81, identifier:enz; 82, None; 83, block; 83, 84; 83, 95; 83, 102; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:enz_base; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:_get_base; 91, argument_list; 91, 92; 92, attribute; 92, 93; 92, 94; 93, identifier:stmt; 94, identifier:enz; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:enz_base; 99, identifier:add_activity; 100, argument_list; 100, 101; 101, string:'phosphatase'; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:enz_base; 106, identifier:add_active_state; 107, argument_list; 107, 108; 107, 109; 108, string:'phosphatase'; 109, attribute; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:stmt; 112, identifier:enz; 113, identifier:mods; 114, elif_clause; 114, 115; 114, 120; 115, call; 115, 116; 115, 117; 116, identifier:isinstance; 117, argument_list; 117, 118; 117, 119; 118, identifier:stmt; 119, identifier:Modification; 120, block; 120, 121; 121, if_statement; 121, 122; 121, 127; 122, comparison_operator:is; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:stmt; 125, identifier:enz; 126, None; 127, block; 127, 128; 127, 139; 127, 146; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:enz_base; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:_get_base; 135, argument_list; 135, 136; 136, attribute; 136, 137; 136, 138; 137, identifier:stmt; 138, identifier:enz; 139, expression_statement; 139, 140; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:enz_base; 143, identifier:add_activity; 144, argument_list; 144, 145; 145, string:'catalytic'; 146, expression_statement; 146, 147; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:enz_base; 150, identifier:add_active_state; 151, argument_list; 151, 152; 151, 153; 152, string:'catalytic'; 153, attribute; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:stmt; 156, identifier:enz; 157, identifier:mods; 158, elif_clause; 158, 159; 158, 164; 159, call; 159, 160; 159, 161; 160, identifier:isinstance; 161, argument_list; 161, 162; 161, 163; 162, identifier:stmt; 163, identifier:SelfModification; 164, block; 164, 165; 165, if_statement; 165, 166; 165, 171; 166, comparison_operator:is; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:stmt; 169, identifier:enz; 170, None; 171, block; 171, 172; 171, 183; 171, 190; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:enz_base; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:self; 178, identifier:_get_base; 179, argument_list; 179, 180; 180, attribute; 180, 181; 180, 182; 181, identifier:stmt; 182, identifier:enz; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:enz_base; 187, identifier:add_activity; 188, argument_list; 188, 189; 189, string:'catalytic'; 190, expression_statement; 190, 191; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:enz_base; 194, identifier:add_active_state; 195, argument_list; 195, 196; 195, 197; 196, string:'catalytic'; 197, attribute; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:stmt; 200, identifier:enz; 201, identifier:mods; 202, elif_clause; 202, 203; 202, 208; 203, call; 203, 204; 203, 205; 204, identifier:isinstance; 205, argument_list; 205, 206; 205, 207; 206, identifier:stmt; 207, identifier:Gef; 208, block; 208, 209; 209, if_statement; 209, 210; 209, 215; 210, comparison_operator:is; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:stmt; 213, identifier:gef; 214, None; 215, block; 215, 216; 215, 227; 215, 234; 215, 259; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:gef_base; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:self; 222, identifier:_get_base; 223, argument_list; 223, 224; 224, attribute; 224, 225; 224, 226; 225, identifier:stmt; 226, identifier:gef; 227, expression_statement; 227, 228; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:gef_base; 231, identifier:add_activity; 232, argument_list; 232, 233; 233, string:'gef'; 234, if_statement; 234, 235; 234, 242; 234, 253; 235, comparison_operator:is; 235, 236; 235, 241; 236, attribute; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:stmt; 239, identifier:gef; 240, identifier:activity; 241, None; 242, block; 242, 243; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:act; 246, attribute; 246, 247; 246, 252; 247, attribute; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:stmt; 250, identifier:gef; 251, identifier:activity; 252, identifier:activity_type; 253, else_clause; 253, 254; 254, block; 254, 255; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:act; 258, string:'activity'; 259, expression_statement; 259, 260; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:gef_base; 263, identifier:add_active_state; 264, argument_list; 264, 265; 264, 266; 265, identifier:act; 266, attribute; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:stmt; 269, identifier:gef; 270, identifier:mods; 271, elif_clause; 271, 272; 271, 277; 272, call; 272, 273; 272, 274; 273, identifier:isinstance; 274, argument_list; 274, 275; 274, 276; 275, identifier:stmt; 276, identifier:Gap; 277, block; 277, 278; 278, if_statement; 278, 279; 278, 284; 279, comparison_operator:is; 279, 280; 279, 283; 280, attribute; 280, 281; 280, 282; 281, identifier:stmt; 282, identifier:gap; 283, None; 284, block; 284, 285; 284, 296; 284, 303; 284, 328; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:gap_base; 288, call; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:self; 291, identifier:_get_base; 292, argument_list; 292, 293; 293, attribute; 293, 294; 293, 295; 294, identifier:stmt; 295, identifier:gap; 296, expression_statement; 296, 297; 297, call; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:gap_base; 300, identifier:add_activity; 301, argument_list; 301, 302; 302, string:'gap'; 303, if_statement; 303, 304; 303, 311; 303, 322; 304, comparison_operator:is; 304, 305; 304, 310; 305, attribute; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:stmt; 308, identifier:gap; 309, identifier:activity; 310, None; 311, block; 311, 312; 312, expression_statement; 312, 313; 313, assignment; 313, 314; 313, 315; 314, identifier:act; 315, attribute; 315, 316; 315, 321; 316, attribute; 316, 317; 316, 320; 317, attribute; 317, 318; 317, 319; 318, identifier:stmt; 319, identifier:gap; 320, identifier:activity; 321, identifier:activity_type; 322, else_clause; 322, 323; 323, block; 323, 324; 324, expression_statement; 324, 325; 325, assignment; 325, 326; 325, 327; 326, identifier:act; 327, string:'activity'; 328, expression_statement; 328, 329; 329, call; 329, 330; 329, 333; 330, attribute; 330, 331; 330, 332; 331, identifier:gap_base; 332, identifier:add_active_state; 333, argument_list; 333, 334; 333, 335; 334, string:'act'; 335, attribute; 335, 336; 335, 339; 336, attribute; 336, 337; 336, 338; 337, identifier:stmt; 338, identifier:gap; 339, identifier:mods; 340, elif_clause; 340, 341; 340, 346; 341, call; 341, 342; 341, 343; 342, identifier:isinstance; 343, argument_list; 343, 344; 343, 345; 344, identifier:stmt; 345, identifier:RegulateActivity; 346, block; 346, 347; 347, if_statement; 347, 348; 347, 353; 348, comparison_operator:is; 348, 349; 348, 352; 349, attribute; 349, 350; 349, 351; 350, identifier:stmt; 351, identifier:subj; 352, None; 353, block; 353, 354; 353, 365; 354, expression_statement; 354, 355; 355, assignment; 355, 356; 355, 357; 356, identifier:subj_base; 357, call; 357, 358; 357, 361; 358, attribute; 358, 359; 358, 360; 359, identifier:self; 360, identifier:_get_base; 361, argument_list; 361, 362; 362, attribute; 362, 363; 362, 364; 363, identifier:stmt; 364, identifier:subj; 365, expression_statement; 365, 366; 366, call; 366, 367; 366, 370; 367, attribute; 367, 368; 367, 369; 368, identifier:subj_base; 369, identifier:add_activity; 370, argument_list; 370, 371; 371, attribute; 371, 372; 371, 373; 372, identifier:stmt; 373, identifier:j | def gather_implicit_activities(self):
for stmt in self.statements:
if isinstance(stmt, Phosphorylation) or \
isinstance(stmt, Transphosphorylation) or \
isinstance(stmt, Autophosphorylation):
if stmt.enz is not None:
enz_base = self._get_base(stmt.enz)
enz_base.add_activity('kinase')
enz_base.add_active_state('kinase', stmt.enz.mods)
elif isinstance(stmt, Dephosphorylation):
if stmt.enz is not None:
enz_base = self._get_base(stmt.enz)
enz_base.add_activity('phosphatase')
enz_base.add_active_state('phosphatase', stmt.enz.mods)
elif isinstance(stmt, Modification):
if stmt.enz is not None:
enz_base = self._get_base(stmt.enz)
enz_base.add_activity('catalytic')
enz_base.add_active_state('catalytic', stmt.enz.mods)
elif isinstance(stmt, SelfModification):
if stmt.enz is not None:
enz_base = self._get_base(stmt.enz)
enz_base.add_activity('catalytic')
enz_base.add_active_state('catalytic', stmt.enz.mods)
elif isinstance(stmt, Gef):
if stmt.gef is not None:
gef_base = self._get_base(stmt.gef)
gef_base.add_activity('gef')
if stmt.gef.activity is not None:
act = stmt.gef.activity.activity_type
else:
act = 'activity'
gef_base.add_active_state(act, stmt.gef.mods)
elif isinstance(stmt, Gap):
if stmt.gap is not None:
gap_base = self._get_base(stmt.gap)
gap_base.add_activity('gap')
if stmt.gap.activity is not None:
act = stmt.gap.activity.activity_type
else:
act = 'activity'
gap_base.add_active_state('act', stmt.gap.mods)
elif isinstance(stmt, RegulateActivity):
if stmt.subj is not None:
subj_base = self._get_base(stmt.subj)
subj_base.add_activity(stmt.j) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:reduce_activities; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, for_statement; 6, 7; 6, 8; 6, 11; 7, identifier:stmt; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:statements; 11, block; 11, 12; 11, 20; 11, 70; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:agents; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:stmt; 18, identifier:agent_list; 19, argument_list; 20, for_statement; 20, 21; 20, 22; 20, 23; 21, identifier:agent; 22, identifier:agents; 23, block; 23, 24; 24, if_statement; 24, 25; 24, 34; 25, boolean_operator:and; 25, 26; 25, 29; 26, comparison_operator:is; 26, 27; 26, 28; 27, identifier:agent; 28, None; 29, comparison_operator:is; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:agent; 32, identifier:activity; 33, None; 34, block; 34, 35; 34, 44; 34, 57; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:agent_base; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:_get_base; 42, argument_list; 42, 43; 43, identifier:agent; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:act_red; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:agent_base; 50, identifier:get_activity_reduction; 51, argument_list; 51, 52; 52, attribute; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:agent; 55, identifier:activity; 56, identifier:activity_type; 57, if_statement; 57, 58; 57, 61; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:act_red; 60, None; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:agent; 67, identifier:activity; 68, identifier:activity_type; 69, identifier:act_red; 70, if_statement; 70, 71; 70, 76; 70, 118; 71, call; 71, 72; 71, 73; 72, identifier:isinstance; 73, argument_list; 73, 74; 73, 75; 74, identifier:stmt; 75, identifier:RegulateActivity; 76, block; 76, 77; 77, if_statement; 77, 78; 77, 83; 78, comparison_operator:is; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:stmt; 81, identifier:obj; 82, None; 83, block; 83, 84; 83, 95; 83, 107; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:obj_base; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:_get_base; 91, argument_list; 91, 92; 92, attribute; 92, 93; 92, 94; 93, identifier:stmt; 94, identifier:obj; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 96, 99; 97, identifier:act_red; 98, line_continuation:\; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:obj_base; 102, identifier:get_activity_reduction; 103, argument_list; 103, 104; 104, attribute; 104, 105; 104, 106; 105, identifier:stmt; 106, identifier:obj_activity; 107, if_statement; 107, 108; 107, 111; 108, comparison_operator:is; 108, 109; 108, 110; 109, identifier:act_red; 110, None; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:stmt; 116, identifier:obj_activity; 117, identifier:act_red; 118, elif_clause; 118, 119; 118, 124; 119, call; 119, 120; 119, 121; 120, identifier:isinstance; 121, argument_list; 121, 122; 121, 123; 122, identifier:stmt; 123, identifier:ActiveForm; 124, block; 124, 125; 124, 136; 124, 147; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:agent_base; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:_get_base; 132, argument_list; 132, 133; 133, attribute; 133, 134; 133, 135; 134, identifier:stmt; 135, identifier:agent; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:act_red; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:agent_base; 142, identifier:get_activity_reduction; 143, argument_list; 143, 144; 144, attribute; 144, 145; 144, 146; 145, identifier:stmt; 146, identifier:activity; 147, if_statement; 147, 148; 147, 151; 148, comparison_operator:is; 148, 149; 148, 150; 149, identifier:act_red; 150, None; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:stmt; 156, identifier:activity; 157, identifier:act_red | def reduce_activities(self):
for stmt in self.statements:
agents = stmt.agent_list()
for agent in agents:
if agent is not None and agent.activity is not None:
agent_base = self._get_base(agent)
act_red = agent_base.get_activity_reduction(
agent.activity.activity_type)
if act_red is not None:
agent.activity.activity_type = act_red
if isinstance(stmt, RegulateActivity):
if stmt.obj is not None:
obj_base = self._get_base(stmt.obj)
act_red = \
obj_base.get_activity_reduction(stmt.obj_activity)
if act_red is not None:
stmt.obj_activity = act_red
elif isinstance(stmt, ActiveForm):
agent_base = self._get_base(stmt.agent)
act_red = agent_base.get_activity_reduction(stmt.activity)
if act_red is not None:
stmt.activity = act_red |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:infer_activations; 3, parameters; 3, 4; 4, identifier:stmts; 5, block; 5, 6; 5, 10; 5, 18; 5, 26; 5, 183; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:linked_stmts; 9, list:[]; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:af_stmts; 13, call; 13, 14; 13, 15; 14, identifier:_get_statements_by_type; 15, argument_list; 15, 16; 15, 17; 16, identifier:stmts; 17, identifier:ActiveForm; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:mod_stmts; 21, call; 21, 22; 21, 23; 22, identifier:_get_statements_by_type; 23, argument_list; 23, 24; 23, 25; 24, identifier:stmts; 25, identifier:Modification; 26, for_statement; 26, 27; 26, 30; 26, 39; 27, pattern_list; 27, 28; 27, 29; 28, identifier:af_stmt; 29, identifier:mod_stmt; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:itertools; 33, identifier:product; 34, argument_list; 34, 35; 35, list_splat; 35, 36; 36, tuple; 36, 37; 36, 38; 37, identifier:af_stmts; 38, identifier:mod_stmts; 39, block; 39, 40; 39, 62; 39, 71; 39, 75; 39, 116; 39, 121; 39, 127; 39, 170; 40, if_statement; 40, 41; 40, 60; 41, boolean_operator:or; 41, 42; 41, 47; 41, 48; 42, comparison_operator:is; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:mod_stmt; 45, identifier:enz; 46, None; 47, line_continuation:\; 48, parenthesized_expression; 48, 49; 49, not_operator; 49, 50; 50, call; 50, 51; 50, 56; 51, attribute; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:af_stmt; 54, identifier:agent; 55, identifier:entity_matches; 56, argument_list; 56, 57; 57, attribute; 57, 58; 57, 59; 58, identifier:mod_stmt; 59, identifier:sub; 60, block; 60, 61; 61, continue_statement; 62, if_statement; 62, 63; 62, 69; 63, not_operator; 63, 64; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:af_stmt; 67, identifier:agent; 68, identifier:mods; 69, block; 69, 70; 70, continue_statement; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:found; 74, False; 75, for_statement; 75, 76; 75, 77; 75, 82; 76, identifier:mc; 77, attribute; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:af_stmt; 80, identifier:agent; 81, identifier:mods; 82, block; 82, 83; 83, if_statement; 83, 84; 83, 111; 84, boolean_operator:and; 84, 85; 84, 103; 84, 104; 85, boolean_operator:and; 85, 86; 85, 95; 85, 96; 86, comparison_operator:==; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:mc; 89, identifier:mod_type; 90, subscript; 90, 91; 90, 92; 91, identifier:modclass_to_modtype; 92, attribute; 92, 93; 92, 94; 93, identifier:mod_stmt; 94, identifier:__class__; 95, line_continuation:\; 96, comparison_operator:==; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:mc; 99, identifier:residue; 100, attribute; 100, 101; 100, 102; 101, identifier:mod_stmt; 102, identifier:residue; 103, line_continuation:\; 104, comparison_operator:==; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:mc; 107, identifier:position; 108, attribute; 108, 109; 108, 110; 109, identifier:mod_stmt; 110, identifier:position; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:found; 115, True; 116, if_statement; 116, 117; 116, 119; 117, not_operator; 117, 118; 118, identifier:found; 119, block; 119, 120; 120, continue_statement; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:ev; 124, attribute; 124, 125; 124, 126; 125, identifier:mod_stmt; 126, identifier:evidence; 127, if_statement; 127, 128; 127, 131; 127, 150; 128, attribute; 128, 129; 128, 130; 129, identifier:af_stmt; 130, identifier:is_active; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:st; 135, call; 135, 136; 135, 137; 136, identifier:Activation; 137, argument_list; 137, 138; 137, 141; 137, 144; 137, 147; 138, attribute; 138, 139; 138, 140; 139, identifier:mod_stmt; 140, identifier:enz; 141, attribute; 141, 142; 141, 143; 142, identifier:mod_stmt; 143, identifier:sub; 144, attribute; 144, 145; 144, 146; 145, identifier:af_stmt; 146, identifier:activity; 147, keyword_argument; 147, 148; 147, 149; 148, identifier:evidence; 149, identifier:ev; 150, else_clause; 150, 151; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:st; 155, call; 155, 156; 155, 157; 156, identifier:Inhibition; 157, argument_list; 157, 158; 157, 161; 157, 164; 157, 167; 158, attribute; 158, 159; 158, 160; 159, identifier:mod_stmt; 160, identifier:enz; 161, attribute; 161, 162; 161, 163; 162, identifier:mod_stmt; 163, identifier:sub; 164, attribute; 164, 165; 164, 166; 165, identifier:af_stmt; 166, identifier:activity; 167, keyword_argument; 167, 168; 167, 169; 168, identifier:evidence; 169, identifier:ev; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:linked_stmts; 174, identifier:append; 175, argument_list; 175, 176; 176, call; 176, 177; 176, 178; 177, identifier:LinkedStatement; 178, argument_list; 178, 179; 178, 182; 179, list:[af_stmt, mod_stmt]; 179, 180; 179, 181; 180, identifier:af_stmt; 181, identifier:mod_stmt; 182, identifier:st; 183, return_statement; 183, 184; 184, identifier:linked_stmts | def infer_activations(stmts):
linked_stmts = []
af_stmts = _get_statements_by_type(stmts, ActiveForm)
mod_stmts = _get_statements_by_type(stmts, Modification)
for af_stmt, mod_stmt in itertools.product(*(af_stmts, mod_stmts)):
if mod_stmt.enz is None or \
(not af_stmt.agent.entity_matches(mod_stmt.sub)):
continue
if not af_stmt.agent.mods:
continue
found = False
for mc in af_stmt.agent.mods:
if mc.mod_type == modclass_to_modtype[mod_stmt.__class__] and \
mc.residue == mod_stmt.residue and \
mc.position == mod_stmt.position:
found = True
if not found:
continue
ev = mod_stmt.evidence
if af_stmt.is_active:
st = Activation(mod_stmt.enz, mod_stmt.sub, af_stmt.activity,
evidence=ev)
else:
st = Inhibition(mod_stmt.enz, mod_stmt.sub, af_stmt.activity,
evidence=ev)
linked_stmts.append(LinkedStatement([af_stmt, mod_stmt], st))
return linked_stmts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:infer_active_forms; 3, parameters; 3, 4; 4, identifier:stmts; 5, block; 5, 6; 5, 10; 5, 248; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:linked_stmts; 9, list:[]; 10, for_statement; 10, 11; 10, 12; 10, 17; 11, identifier:act_stmt; 12, call; 12, 13; 12, 14; 13, identifier:_get_statements_by_type; 14, argument_list; 14, 15; 14, 16; 15, identifier:stmts; 16, identifier:RegulateActivity; 17, block; 17, 18; 17, 48; 17, 52; 17, 58; 17, 113; 17, 118; 17, 122; 17, 184; 17, 195; 17, 228; 17, 239; 18, if_statement; 18, 19; 18, 46; 19, not_operator; 19, 20; 20, parenthesized_expression; 20, 21; 21, boolean_operator:and; 21, 22; 21, 39; 22, boolean_operator:and; 22, 23; 22, 30; 23, comparison_operator:is; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:act_stmt; 27, identifier:subj; 28, identifier:activity; 29, None; 30, comparison_operator:==; 30, 31; 30, 38; 31, attribute; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:act_stmt; 35, identifier:subj; 36, identifier:activity; 37, identifier:activity_type; 38, string:'kinase'; 39, attribute; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:act_stmt; 43, identifier:subj; 44, identifier:activity; 45, identifier:is_active; 46, block; 46, 47; 47, continue_statement; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:matching; 51, list:[]; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:ev; 55, attribute; 55, 56; 55, 57; 56, identifier:act_stmt; 57, identifier:evidence; 58, for_statement; 58, 59; 58, 60; 58, 65; 59, identifier:mod_stmt; 60, call; 60, 61; 60, 62; 61, identifier:_get_statements_by_type; 62, argument_list; 62, 63; 62, 64; 63, identifier:stmts; 64, identifier:Modification; 65, block; 65, 66; 66, if_statement; 66, 67; 66, 72; 67, comparison_operator:is; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:mod_stmt; 70, identifier:enz; 71, None; 72, block; 72, 73; 73, if_statement; 73, 74; 73, 96; 74, boolean_operator:and; 74, 75; 74, 85; 74, 86; 75, call; 75, 76; 75, 81; 76, attribute; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:mod_stmt; 79, identifier:enz; 80, identifier:entity_matches; 81, argument_list; 81, 82; 82, attribute; 82, 83; 82, 84; 83, identifier:act_stmt; 84, identifier:subj; 85, line_continuation:\; 86, call; 86, 87; 86, 92; 87, attribute; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:mod_stmt; 90, identifier:sub; 91, identifier:entity_matches; 92, argument_list; 92, 93; 93, attribute; 93, 94; 93, 95; 94, identifier:act_stmt; 95, identifier:obj; 96, block; 96, 97; 96, 104; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:matching; 101, identifier:append; 102, argument_list; 102, 103; 103, identifier:mod_stmt; 104, expression_statement; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:ev; 108, identifier:extend; 109, argument_list; 109, 110; 110, attribute; 110, 111; 110, 112; 111, identifier:mod_stmt; 112, identifier:evidence; 113, if_statement; 113, 114; 113, 116; 114, not_operator; 114, 115; 115, identifier:matching; 116, block; 116, 117; 117, continue_statement; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:mods; 121, list:[]; 122, for_statement; 122, 123; 122, 124; 122, 125; 123, identifier:mod_stmt; 124, identifier:matching; 125, block; 125, 126; 125, 138; 125, 163; 125, 177; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:mod_type_name; 129, call; 129, 130; 129, 137; 130, attribute; 130, 131; 130, 136; 131, attribute; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:mod_stmt; 134, identifier:__class__; 135, identifier:__name__; 136, identifier:lower; 137, argument_list; 138, if_statement; 138, 139; 138, 144; 138, 149; 139, call; 139, 140; 139, 141; 140, identifier:isinstance; 141, argument_list; 141, 142; 141, 143; 142, identifier:mod_stmt; 143, identifier:AddModification; 144, block; 144, 145; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:is_modified; 148, True; 149, else_clause; 149, 150; 150, block; 150, 151; 150, 155; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:is_modified; 154, False; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:mod_type_name; 158, subscript; 158, 159; 158, 160; 159, identifier:mod_type_name; 160, slice; 160, 161; 160, 162; 161, integer:2; 162, colon; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:mc; 166, call; 166, 167; 166, 168; 167, identifier:ModCondition; 168, argument_list; 168, 169; 168, 170; 168, 173; 168, 176; 169, identifier:mod_type_name; 170, attribute; 170, 171; 170, 172; 171, identifier:mod_stmt; 172, identifier:residue; 173, attribute; 173, 174; 173, 175; 174, identifier:mod_stmt; 175, identifier:position; 176, identifier:is_modified; 177, expression_statement; 177, 178; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:mods; 181, identifier:append; 182, argument_list; 182, 183; 183, identifier:mc; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:source_stmts; 187, binary_operator:+; 187, 188; 187, 190; 188, list:[act_stmt]; 188, 189; 189, identifier:act_stmt; 190, list_comprehension; 190, 191; 190, 192; 191, identifier:m; 192, for_in_clause; 192, 193; 192, 194; 193, identifier:m; 194, identifier:matching; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:st; 198, call; 198, 199; 198, 200; 199, identifier:ActiveForm; 200, argument_list; 200, 201; 200, 219; 200, 222; 200, 225; 201, call; 201, 202; 201, 203; 202, identifier:Agent; 203, argument_list; 203, 204; 203, 209; 203, 212; 204, attribute; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:act_stmt; 207, identifier:obj; 208, identifier:name; 209, keyword_argument; 209, 210; 209, 211; 210, identifier:mods; 211, identifier:mods; 212, keyword_argument; 212, 213; 212, 214; 213, identifier:db_refs; 214, attribute; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:act_stmt; 217, identifier:obj; 218, identifier:db_refs; 219, attribute; 219, 220; 219, 221; 220, identifier:act_stmt; 221, identifier:obj_activity; 222, attribute; 222, 223; 222, 224; 223, identifier:act_stmt; 224, identifier:is_activation; 225, keyword_argument; 225, 226; 225, 227; 226, identifier:evidence; 227, identifier:ev; 228, expression_statement; 228, 229; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:linked_stmts; 232, identifier:append; 233, argument_list; 233, 234; 234, call; 234, 235; 234, 236; 235, identifier:LinkedStatement; 236, argument_list; 236, 237; 236, 238; 237, identifier:source_stmts; 238, identifier:st; 239, expression_statement; 239, 240; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:logger; 243, identifier:info; 244, argument_list; 244, 245; 245, binary_operator:%; 245, 246; 245, 247; 246, string:'inferred: %s'; 247, identifier:st; 248, return_statement; 248, 249; 249, identifier:linked_stmts | def infer_active_forms(stmts):
linked_stmts = []
for act_stmt in _get_statements_by_type(stmts, RegulateActivity):
if not (act_stmt.subj.activity is not None and
act_stmt.subj.activity.activity_type == 'kinase' and
act_stmt.subj.activity.is_active):
continue
matching = []
ev = act_stmt.evidence
for mod_stmt in _get_statements_by_type(stmts, Modification):
if mod_stmt.enz is not None:
if mod_stmt.enz.entity_matches(act_stmt.subj) and \
mod_stmt.sub.entity_matches(act_stmt.obj):
matching.append(mod_stmt)
ev.extend(mod_stmt.evidence)
if not matching:
continue
mods = []
for mod_stmt in matching:
mod_type_name = mod_stmt.__class__.__name__.lower()
if isinstance(mod_stmt, AddModification):
is_modified = True
else:
is_modified = False
mod_type_name = mod_type_name[2:]
mc = ModCondition(mod_type_name, mod_stmt.residue,
mod_stmt.position, is_modified)
mods.append(mc)
source_stmts = [act_stmt] + [m for m in matching]
st = ActiveForm(Agent(act_stmt.obj.name, mods=mods,
db_refs=act_stmt.obj.db_refs),
act_stmt.obj_activity, act_stmt.is_activation,
evidence=ev)
linked_stmts.append(LinkedStatement(source_stmts, st))
logger.info('inferred: %s' % st)
return linked_stmts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:infer_modifications; 3, parameters; 3, 4; 4, identifier:stmts; 5, block; 5, 6; 5, 10; 5, 188; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:linked_stmts; 9, list:[]; 10, for_statement; 10, 11; 10, 12; 10, 17; 11, identifier:act_stmt; 12, call; 12, 13; 12, 14; 13, identifier:_get_statements_by_type; 14, argument_list; 14, 15; 14, 16; 15, identifier:stmts; 16, identifier:RegulateActivity; 17, block; 17, 18; 18, for_statement; 18, 19; 18, 20; 18, 25; 19, identifier:af_stmt; 20, call; 20, 21; 20, 22; 21, identifier:_get_statements_by_type; 22, argument_list; 22, 23; 22, 24; 23, identifier:stmts; 24, identifier:ActiveForm; 25, block; 25, 26; 25, 40; 25, 48; 25, 70; 25, 79; 26, if_statement; 26, 27; 26, 38; 27, not_operator; 27, 28; 28, call; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:af_stmt; 32, identifier:agent; 33, identifier:entity_matches; 34, argument_list; 34, 35; 35, attribute; 35, 36; 35, 37; 36, identifier:act_stmt; 37, identifier:obj; 38, block; 38, 39; 39, continue_statement; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:mods; 43, attribute; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:af_stmt; 46, identifier:agent; 47, identifier:mods; 48, if_statement; 48, 49; 48, 68; 49, boolean_operator:or; 49, 50; 49, 62; 49, 63; 50, boolean_operator:or; 50, 51; 50, 56; 50, 57; 51, attribute; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:af_stmt; 54, identifier:agent; 55, identifier:mutations; 56, line_continuation:\; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:af_stmt; 60, identifier:agent; 61, identifier:bound_conditions; 62, line_continuation:\; 63, attribute; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:af_stmt; 66, identifier:agent; 67, identifier:location; 68, block; 68, 69; 69, continue_statement; 70, if_statement; 70, 71; 70, 77; 71, not_operator; 71, 72; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:af_stmt; 75, identifier:agent; 76, identifier:mods; 77, block; 77, 78; 78, continue_statement; 79, for_statement; 79, 80; 79, 81; 79, 86; 80, identifier:mod; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:af_stmt; 84, identifier:agent; 85, identifier:mods; 86, block; 86, 87; 86, 97; 86, 109; 86, 130; 86, 136; 86, 141; 86, 162; 86, 172; 86, 179; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:evs; 90, binary_operator:+; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:act_stmt; 93, identifier:evidence; 94, attribute; 94, 95; 94, 96; 95, identifier:af_stmt; 96, identifier:evidence; 97, for_statement; 97, 98; 97, 99; 97, 100; 98, identifier:ev; 99, identifier:evs; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 108; 103, subscript; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:ev; 106, identifier:epistemics; 107, string:'direct'; 108, False; 109, if_statement; 109, 110; 109, 113; 109, 120; 110, attribute; 110, 111; 110, 112; 111, identifier:mod; 112, identifier:is_modified; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:mod_type_name; 117, attribute; 117, 118; 117, 119; 118, identifier:mod; 119, identifier:mod_type; 120, else_clause; 120, 121; 121, block; 121, 122; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:mod_type_name; 125, subscript; 125, 126; 125, 127; 126, identifier:modtype_to_inverse; 127, attribute; 127, 128; 127, 129; 128, identifier:mod; 129, identifier:mod_type; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:mod_class; 133, subscript; 133, 134; 133, 135; 134, identifier:modtype_to_modclass; 135, identifier:mod_type_name; 136, if_statement; 136, 137; 136, 139; 137, not_operator; 137, 138; 138, identifier:mod_class; 139, block; 139, 140; 140, continue_statement; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:st; 144, call; 144, 145; 144, 146; 145, identifier:mod_class; 146, argument_list; 146, 147; 146, 150; 146, 153; 146, 156; 146, 159; 147, attribute; 147, 148; 147, 149; 148, identifier:act_stmt; 149, identifier:subj; 150, attribute; 150, 151; 150, 152; 151, identifier:act_stmt; 152, identifier:obj; 153, attribute; 153, 154; 153, 155; 154, identifier:mod; 155, identifier:residue; 156, attribute; 156, 157; 156, 158; 157, identifier:mod; 158, identifier:position; 159, keyword_argument; 159, 160; 159, 161; 160, identifier:evidence; 161, identifier:evs; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:ls; 165, call; 165, 166; 165, 167; 166, identifier:LinkedStatement; 167, argument_list; 167, 168; 167, 171; 168, list:[act_stmt, af_stmt]; 168, 169; 168, 170; 169, identifier:act_stmt; 170, identifier:af_stmt; 171, identifier:st; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:linked_stmts; 176, identifier:append; 177, argument_list; 177, 178; 178, identifier:ls; 179, expression_statement; 179, 180; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:logger; 183, identifier:info; 184, argument_list; 184, 185; 185, binary_operator:%; 185, 186; 185, 187; 186, string:'inferred: %s'; 187, identifier:st; 188, return_statement; 188, 189; 189, identifier:linked_stmts | def infer_modifications(stmts):
linked_stmts = []
for act_stmt in _get_statements_by_type(stmts, RegulateActivity):
for af_stmt in _get_statements_by_type(stmts, ActiveForm):
if not af_stmt.agent.entity_matches(act_stmt.obj):
continue
mods = af_stmt.agent.mods
if af_stmt.agent.mutations or \
af_stmt.agent.bound_conditions or \
af_stmt.agent.location:
continue
if not af_stmt.agent.mods:
continue
for mod in af_stmt.agent.mods:
evs = act_stmt.evidence + af_stmt.evidence
for ev in evs:
ev.epistemics['direct'] = False
if mod.is_modified:
mod_type_name = mod.mod_type
else:
mod_type_name = modtype_to_inverse[mod.mod_type]
mod_class = modtype_to_modclass[mod_type_name]
if not mod_class:
continue
st = mod_class(act_stmt.subj,
act_stmt.obj,
mod.residue, mod.position,
evidence=evs)
ls = LinkedStatement([act_stmt, af_stmt], st)
linked_stmts.append(ls)
logger.info('inferred: %s' % st)
return linked_stmts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:score_evidence_list; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:evidences; 6, block; 6, 7; 6, 121; 6, 139; 6, 156; 6, 163; 6, 170; 6, 179; 7, function_definition; 7, 8; 7, 9; 7, 11; 8, function_name:_score; 9, parameters; 9, 10; 10, identifier:evidences; 11, block; 11, 12; 11, 18; 11, 28; 11, 37; 11, 53; 11, 63; 11, 89; 11, 93; 11, 113; 11, 119; 12, if_statement; 12, 13; 12, 15; 13, not_operator; 13, 14; 14, identifier:evidences; 15, block; 15, 16; 16, return_statement; 16, 17; 17, integer:0; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:sources; 21, list_comprehension; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:ev; 24, identifier:source_api; 25, for_in_clause; 25, 26; 25, 27; 26, identifier:ev; 27, identifier:evidences; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:uniq_sources; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:numpy; 34, identifier:unique; 35, argument_list; 35, 36; 36, identifier:sources; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:syst_factors; 40, dictionary_comprehension; 40, 41; 40, 50; 41, pair; 41, 42; 41, 43; 42, identifier:s; 43, subscript; 43, 44; 43, 49; 44, subscript; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:prior_probs; 48, string:'syst'; 49, identifier:s; 50, for_in_clause; 50, 51; 50, 52; 51, identifier:s; 52, identifier:uniq_sources; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:rand_factors; 56, dictionary_comprehension; 56, 57; 56, 60; 57, pair; 57, 58; 57, 59; 58, identifier:k; 59, list:[]; 60, for_in_clause; 60, 61; 60, 62; 61, identifier:k; 62, identifier:uniq_sources; 63, for_statement; 63, 64; 63, 65; 63, 66; 64, identifier:ev; 65, identifier:evidences; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 76; 69, attribute; 69, 70; 69, 75; 70, subscript; 70, 71; 70, 72; 71, identifier:rand_factors; 72, attribute; 72, 73; 72, 74; 73, identifier:ev; 74, identifier:source_api; 75, identifier:append; 76, argument_list; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:evidence_random_noise_prior; 79, argument_list; 79, 80; 79, 81; 79, 86; 80, identifier:ev; 81, subscript; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:prior_probs; 85, string:'rand'; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:subtype_probs; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:neg_prob_prior; 92, integer:1; 93, for_statement; 93, 94; 93, 95; 93, 96; 94, identifier:s; 95, identifier:uniq_sources; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, augmented_assignment:*=; 98, 99; 98, 100; 99, identifier:neg_prob_prior; 100, parenthesized_expression; 100, 101; 101, binary_operator:+; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:syst_factors; 104, identifier:s; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:numpy; 108, identifier:prod; 109, argument_list; 109, 110; 110, subscript; 110, 111; 110, 112; 111, identifier:rand_factors; 112, identifier:s; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:prob_prior; 116, binary_operator:-; 116, 117; 116, 118; 117, integer:1; 118, identifier:neg_prob_prior; 119, return_statement; 119, 120; 120, identifier:prob_prior; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:pos_evidence; 124, list_comprehension; 124, 125; 124, 126; 124, 129; 125, identifier:ev; 126, for_in_clause; 126, 127; 126, 128; 127, identifier:ev; 128, identifier:evidences; 129, if_clause; 129, 130; 130, not_operator; 130, 131; 131, call; 131, 132; 131, 137; 132, attribute; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:ev; 135, identifier:epistemics; 136, identifier:get; 137, argument_list; 137, 138; 138, string:'negated'; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:neg_evidence; 142, list_comprehension; 142, 143; 142, 144; 142, 147; 143, identifier:ev; 144, for_in_clause; 144, 145; 144, 146; 145, identifier:ev; 146, identifier:evidences; 147, if_clause; 147, 148; 148, call; 148, 149; 148, 154; 149, attribute; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:ev; 152, identifier:epistemics; 153, identifier:get; 154, argument_list; 154, 155; 155, string:'negated'; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:pp; 159, call; 159, 160; 159, 161; 160, identifier:_score; 161, argument_list; 161, 162; 162, identifier:pos_evidence; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:np; 166, call; 166, 167; 166, 168; 167, identifier:_score; 168, argument_list; 168, 169; 169, identifier:neg_evidence; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:score; 173, binary_operator:*; 173, 174; 173, 175; 174, identifier:pp; 175, parenthesized_expression; 175, 176; 176, binary_operator:-; 176, 177; 176, 178; 177, integer:1; 178, identifier:np; 179, return_statement; 179, 180; 180, identifier:score | def score_evidence_list(self, evidences):
def _score(evidences):
if not evidences:
return 0
sources = [ev.source_api for ev in evidences]
uniq_sources = numpy.unique(sources)
syst_factors = {s: self.prior_probs['syst'][s]
for s in uniq_sources}
rand_factors = {k: [] for k in uniq_sources}
for ev in evidences:
rand_factors[ev.source_api].append(
evidence_random_noise_prior(
ev,
self.prior_probs['rand'],
self.subtype_probs))
neg_prob_prior = 1
for s in uniq_sources:
neg_prob_prior *= (syst_factors[s] +
numpy.prod(rand_factors[s]))
prob_prior = 1 - neg_prob_prior
return prob_prior
pos_evidence = [ev for ev in evidences if
not ev.epistemics.get('negated')]
neg_evidence = [ev for ev in evidences if
ev.epistemics.get('negated')]
pp = _score(pos_evidence)
np = _score(neg_evidence)
score = pp * (1 - np)
return score |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:update_probs; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 10; 5, 20; 5, 78; 5, 82; 5, 153; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:syst_error; 9, float:0.05; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:prior_probs; 13, dictionary; 13, 14; 13, 17; 14, pair; 14, 15; 14, 16; 15, string:'syst'; 16, dictionary; 17, pair; 17, 18; 17, 19; 18, string:'rand'; 19, dictionary; 20, for_statement; 20, 21; 20, 26; 20, 33; 21, pattern_list; 21, 22; 21, 23; 22, identifier:source; 23, tuple_pattern; 23, 24; 23, 25; 24, identifier:p; 25, identifier:n; 26, call; 26, 27; 26, 32; 27, attribute; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:prior_counts; 31, identifier:items; 32, argument_list; 33, block; 33, 34; 33, 42; 33, 50; 34, if_statement; 34, 35; 34, 40; 35, comparison_operator:==; 35, 36; 35, 39; 36, binary_operator:+; 36, 37; 36, 38; 37, identifier:n; 38, identifier:p; 39, integer:0; 40, block; 40, 41; 41, continue_statement; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 49; 44, subscript; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:prior_probs; 47, string:'syst'; 48, identifier:source; 49, identifier:syst_error; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 57; 51, 58; 52, subscript; 52, 53; 52, 56; 53, subscript; 53, 54; 53, 55; 54, identifier:prior_probs; 55, string:'rand'; 56, identifier:source; 57, line_continuation:\; 58, binary_operator:-; 58, 59; 58, 77; 59, binary_operator:-; 59, 60; 59, 61; 60, integer:1; 61, call; 61, 62; 61, 63; 62, identifier:min; 63, argument_list; 63, 64; 64, tuple; 64, 65; 64, 74; 65, binary_operator:/; 65, 66; 65, 70; 66, call; 66, 67; 66, 68; 67, identifier:float; 68, argument_list; 68, 69; 69, identifier:p; 70, parenthesized_expression; 70, 71; 71, binary_operator:+; 71, 72; 71, 73; 72, identifier:n; 73, identifier:p; 74, binary_operator:-; 74, 75; 74, 76; 75, integer:1; 76, identifier:syst_error; 77, identifier:syst_error; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:subtype_probs; 81, dictionary; 82, for_statement; 82, 83; 82, 86; 82, 93; 83, pattern_list; 83, 84; 83, 85; 84, identifier:source; 85, identifier:entry; 86, call; 86, 87; 86, 92; 87, attribute; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:subtype_counts; 91, identifier:items; 92, argument_list; 93, block; 93, 94; 94, for_statement; 94, 95; 94, 100; 94, 105; 95, pattern_list; 95, 96; 95, 97; 96, identifier:rule; 97, tuple_pattern; 97, 98; 97, 99; 98, identifier:p; 99, identifier:n; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:entry; 103, identifier:items; 104, argument_list; 105, block; 105, 106; 105, 114; 105, 125; 106, if_statement; 106, 107; 106, 112; 107, comparison_operator:==; 107, 108; 107, 111; 108, binary_operator:+; 108, 109; 108, 110; 109, identifier:n; 110, identifier:p; 111, integer:0; 112, block; 112, 113; 113, continue_statement; 114, if_statement; 114, 115; 114, 118; 115, comparison_operator:not; 115, 116; 115, 117; 116, identifier:source; 117, identifier:subtype_probs; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 124; 121, subscript; 121, 122; 121, 123; 122, identifier:subtype_probs; 123, identifier:source; 124, dictionary; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 132; 126, 133; 127, subscript; 127, 128; 127, 131; 128, subscript; 128, 129; 128, 130; 129, identifier:subtype_probs; 130, identifier:source; 131, identifier:rule; 132, line_continuation:\; 133, binary_operator:-; 133, 134; 133, 152; 134, binary_operator:-; 134, 135; 134, 136; 135, integer:1; 136, call; 136, 137; 136, 138; 137, identifier:min; 138, argument_list; 138, 139; 139, tuple; 139, 140; 139, 149; 140, binary_operator:/; 140, 141; 140, 145; 141, call; 141, 142; 141, 143; 142, identifier:float; 143, argument_list; 143, 144; 144, identifier:p; 145, parenthesized_expression; 145, 146; 146, binary_operator:+; 146, 147; 146, 148; 147, identifier:n; 148, identifier:p; 149, binary_operator:-; 149, 150; 149, 151; 150, integer:1; 151, identifier:syst_error; 152, identifier:syst_error; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 162; 155, attribute; 155, 156; 155, 161; 156, call; 156, 157; 156, 158; 157, identifier:super; 158, argument_list; 158, 159; 158, 160; 159, identifier:BayesianScorer; 160, identifier:self; 161, identifier:update_probs; 162, argument_list; 162, 163; 162, 164; 163, identifier:prior_probs; 164, identifier:subtype_probs | def update_probs(self):
syst_error = 0.05
prior_probs = {'syst': {}, 'rand': {}}
for source, (p, n) in self.prior_counts.items():
if n + p == 0:
continue
prior_probs['syst'][source] = syst_error
prior_probs['rand'][source] = \
1 - min((float(p) / (n + p), 1-syst_error)) - syst_error
subtype_probs = {}
for source, entry in self.subtype_counts.items():
for rule, (p, n) in entry.items():
if n + p == 0:
continue
if source not in subtype_probs:
subtype_probs[source] = {}
subtype_probs[source][rule] = \
1 - min((float(p) / (n + p), 1-syst_error)) - syst_error
super(BayesianScorer, self).update_probs(prior_probs, subtype_probs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:set_hierarchy_probs; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:statements; 6, block; 6, 7; 6, 76; 6, 120; 6, 157; 6, 164; 6, 169; 6, 176; 7, function_definition; 7, 8; 7, 9; 7, 11; 8, function_name:build_hierarchy_graph; 9, parameters; 9, 10; 10, identifier:stmts; 11, block; 11, 12; 11, 20; 11, 74; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:g; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:networkx; 18, identifier:DiGraph; 19, argument_list; 20, for_statement; 20, 21; 20, 22; 20, 23; 21, identifier:st1; 22, identifier:stmts; 23, block; 23, 24; 23, 38; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:g; 28, identifier:add_node; 29, argument_list; 29, 30; 29, 35; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:st1; 33, identifier:matches_key; 34, argument_list; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:stmt; 37, identifier:st1; 38, for_statement; 38, 39; 38, 40; 38, 43; 39, identifier:st2; 40, attribute; 40, 41; 40, 42; 41, identifier:st1; 42, identifier:supported_by; 43, block; 43, 44; 43, 58; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:g; 48, identifier:add_node; 49, argument_list; 49, 50; 49, 55; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:st2; 53, identifier:matches_key; 54, argument_list; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:stmt; 57, identifier:st2; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:g; 62, identifier:add_edge; 63, argument_list; 63, 64; 63, 69; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:st2; 67, identifier:matches_key; 68, argument_list; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:st1; 72, identifier:matches_key; 73, argument_list; 74, return_statement; 74, 75; 75, identifier:g; 76, function_definition; 76, 77; 76, 78; 76, 80; 77, function_name:get_ranked_stmts; 78, parameters; 78, 79; 79, identifier:g; 80, block; 80, 81; 80, 94; 80, 104; 80, 118; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:node_ranks; 84, call; 84, 85; 84, 92; 85, attribute; 85, 86; 85, 91; 86, attribute; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:networkx; 89, identifier:algorithms; 90, identifier:dag; 91, identifier:topological_sort; 92, argument_list; 92, 93; 93, identifier:g; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:node_ranks; 97, call; 97, 98; 97, 99; 98, identifier:reversed; 99, argument_list; 99, 100; 100, call; 100, 101; 100, 102; 101, identifier:list; 102, argument_list; 102, 103; 103, identifier:node_ranks; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:stmts; 107, list_comprehension; 107, 108; 107, 115; 108, subscript; 108, 109; 108, 114; 109, subscript; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:g; 112, identifier:node; 113, identifier:n; 114, string:'stmt'; 115, for_in_clause; 115, 116; 115, 117; 116, identifier:n; 117, identifier:node_ranks; 118, return_statement; 118, 119; 119, identifier:stmts; 120, function_definition; 120, 121; 120, 122; 120, 124; 121, function_name:assert_no_cycle; 122, parameters; 122, 123; 123, identifier:g; 124, block; 124, 125; 124, 148; 124, 154; 125, try_statement; 125, 126; 125, 140; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:cyc; 130, call; 130, 131; 130, 138; 131, attribute; 131, 132; 131, 137; 132, attribute; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:networkx; 135, identifier:algorithms; 136, identifier:cycles; 137, identifier:find_cycle; 138, argument_list; 138, 139; 139, identifier:g; 140, except_clause; 140, 141; 140, 146; 141, attribute; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:networkx; 144, identifier:exception; 145, identifier:NetworkXNoCycle; 146, block; 146, 147; 147, return_statement; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:msg; 151, binary_operator:%; 151, 152; 151, 153; 152, string:'Cycle found in hierarchy graph: %s'; 153, identifier:cyc; 154, assert_statement; 154, 155; 154, 156; 155, False; 156, identifier:msg; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:g; 160, call; 160, 161; 160, 162; 161, identifier:build_hierarchy_graph; 162, argument_list; 162, 163; 163, identifier:statements; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 167; 166, identifier:assert_no_cycle; 167, argument_list; 167, 168; 168, identifier:g; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:ranked_stmts; 172, call; 172, 173; 172, 174; 173, identifier:get_ranked_stmts; 174, argument_list; 174, 175; 175, identifier:g; 176, for_statement; 176, 177; 176, 178; 176, 179; 177, identifier:st; 178, identifier:ranked_stmts; 179, block; 179, 180; 179, 187; 179, 191; 179, 224; 179, 236; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:bps; 183, call; 183, 184; 183, 185; 184, identifier:_get_belief_package; 185, argument_list; 185, 186; 186, identifier:st; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:supporting_evidences; 190, list:[]; 191, for_statement; 191, 192; 191, 193; 191, 199; 192, identifier:bp; 193, subscript; 193, 194; 193, 195; 194, identifier:bps; 195, slice; 195, 196; 195, 197; 196, colon; 197, unary_operator:-; 197, 198; 198, integer:1; 199, block; 199, 200; 200, for_statement; 200, 201; 200, 202; 200, 205; 201, identifier:ev; 202, attribute; 202, 203; 202, 204; 203, identifier:bp; 204, identifier:evidences; 205, block; 205, 206; 206, if_statement; 206, 207; 206, 216; 207, not_operator; 207, 208; 208, call; 208, 209; 208, 214; 209, attribute; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:ev; 212, identifier:epistemics; 213, identifier:get; 214, argument_list; 214, 215; 215, string:'negated'; 216, block; 216, 217; 217, expression_statement; 217, 218; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:supporting_evidences; 221, identifier:append; 222, argument_list; 222, 223; 223, identifier:ev; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:belief; 227, call; 227, 228; 227, 233; 228, attribute; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:self; 231, identifier:scorer; 232, identifier:score_statement; 233, argument_list; 233, 234; 233, 235; 234, identifier:st; 235, identifier:supporting_evidences; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:st; 240, identifier:belief; 241, identifier:belief | def set_hierarchy_probs(self, statements):
def build_hierarchy_graph(stmts):
g = networkx.DiGraph()
for st1 in stmts:
g.add_node(st1.matches_key(), stmt=st1)
for st2 in st1.supported_by:
g.add_node(st2.matches_key(), stmt=st2)
g.add_edge(st2.matches_key(), st1.matches_key())
return g
def get_ranked_stmts(g):
node_ranks = networkx.algorithms.dag.topological_sort(g)
node_ranks = reversed(list(node_ranks))
stmts = [g.node[n]['stmt'] for n in node_ranks]
return stmts
def assert_no_cycle(g):
try:
cyc = networkx.algorithms.cycles.find_cycle(g)
except networkx.exception.NetworkXNoCycle:
return
msg = 'Cycle found in hierarchy graph: %s' % cyc
assert False, msg
g = build_hierarchy_graph(statements)
assert_no_cycle(g)
ranked_stmts = get_ranked_stmts(g)
for st in ranked_stmts:
bps = _get_belief_package(st)
supporting_evidences = []
for bp in bps[:-1]:
for ev in bp.evidences:
if not ev.epistemics.get('negated'):
supporting_evidences.append(ev)
belief = self.scorer.score_statement(st, supporting_evidences)
st.belief = belief |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_statements; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:reprocess; 7, False; 8, block; 8, 9; 8, 219; 9, if_statement; 9, 10; 9, 17; 9, 208; 10, boolean_operator:or; 10, 11; 10, 16; 11, comparison_operator:is; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:_statements; 15, None; 16, identifier:reprocess; 17, block; 17, 18; 17, 33; 17, 167; 17, 199; 18, if_statement; 18, 19; 18, 24; 19, comparison_operator:is; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:content; 23, None; 24, block; 24, 25; 24, 31; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:_statements; 30, list:[]; 31, return_statement; 31, 32; 32, list:[]; 33, if_statement; 33, 34; 33, 41; 33, 82; 33, 136; 33, 156; 34, comparison_operator:==; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:reader; 38, attribute; 38, 39; 38, 40; 39, identifier:ReachReader; 40, identifier:name; 41, block; 41, 42; 42, if_statement; 42, 43; 42, 50; 42, 71; 43, comparison_operator:==; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:format; 47, attribute; 47, 48; 47, 49; 48, identifier:formats; 49, identifier:JSON; 50, block; 50, 51; 50, 62; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:json_str; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:json; 57, identifier:dumps; 58, argument_list; 58, 59; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:content; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:processor; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:reach; 68, identifier:process_json_str; 69, argument_list; 69, 70; 70, identifier:json_str; 71, else_clause; 71, 72; 72, block; 72, 73; 73, raise_statement; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:ReadingError; 76, argument_list; 76, 77; 77, binary_operator:%; 77, 78; 77, 79; 78, string:"Incorrect format for Reach output: %s."; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:format; 82, elif_clause; 82, 83; 82, 90; 83, comparison_operator:==; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:reader; 87, attribute; 87, 88; 87, 89; 88, identifier:SparserReader; 89, identifier:name; 90, block; 90, 91; 91, if_statement; 91, 92; 91, 99; 91, 123; 92, comparison_operator:==; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:format; 96, attribute; 96, 97; 96, 98; 97, identifier:formats; 98, identifier:JSON; 99, block; 99, 100; 99, 111; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:processor; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:sparser; 106, identifier:process_json_dict; 107, argument_list; 107, 108; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:content; 111, if_statement; 111, 112; 111, 115; 112, comparison_operator:is; 112, 113; 112, 114; 113, identifier:processor; 114, None; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:processor; 120, identifier:set_statements_pmid; 121, argument_list; 121, 122; 122, None; 123, else_clause; 123, 124; 124, block; 124, 125; 125, raise_statement; 125, 126; 126, call; 126, 127; 126, 128; 127, identifier:ReadingError; 128, argument_list; 128, 129; 129, binary_operator:%; 129, 130; 129, 133; 130, concatenated_string; 130, 131; 130, 132; 131, string:"Sparser should only ever be JSON, not "; 132, string:"%s."; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:format; 136, elif_clause; 136, 137; 136, 144; 137, comparison_operator:==; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:self; 140, identifier:reader; 141, attribute; 141, 142; 141, 143; 142, identifier:TripsReader; 143, identifier:name; 144, block; 144, 145; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:processor; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:trips; 151, identifier:process_xml; 152, argument_list; 152, 153; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:content; 156, else_clause; 156, 157; 157, block; 157, 158; 158, raise_statement; 158, 159; 159, call; 159, 160; 159, 161; 160, identifier:ReadingError; 161, argument_list; 161, 162; 162, binary_operator:%; 162, 163; 162, 164; 163, string:"Unknown reader: %s."; 164, attribute; 164, 165; 164, 166; 165, identifier:self; 166, identifier:reader; 167, if_statement; 167, 168; 167, 171; 167, 191; 168, comparison_operator:is; 168, 169; 168, 170; 169, identifier:processor; 170, None; 171, block; 171, 172; 171, 187; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:logger; 176, identifier:error; 177, argument_list; 177, 178; 178, binary_operator:%; 178, 179; 178, 180; 179, string:"Production of statements from %s failed for %s."; 180, tuple; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:self; 183, identifier:reader; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:content_id; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:stmts; 190, list:[]; 191, else_clause; 191, 192; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:stmts; 196, attribute; 196, 197; 196, 198; 197, identifier:processor; 198, identifier:statements; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:self; 203, identifier:_statements; 204, subscript; 204, 205; 204, 206; 205, identifier:stmts; 206, slice; 206, 207; 207, colon; 208, else_clause; 208, 209; 209, block; 209, 210; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:stmts; 213, subscript; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:self; 216, identifier:_statements; 217, slice; 217, 218; 218, colon; 219, return_statement; 219, 220; 220, identifier:stmts | def get_statements(self, reprocess=False):
if self._statements is None or reprocess:
if self.content is None:
self._statements = []
return []
if self.reader == ReachReader.name:
if self.format == formats.JSON:
json_str = json.dumps(self.content)
processor = reach.process_json_str(json_str)
else:
raise ReadingError("Incorrect format for Reach output: %s."
% self.format)
elif self.reader == SparserReader.name:
if self.format == formats.JSON:
processor = sparser.process_json_dict(self.content)
if processor is not None:
processor.set_statements_pmid(None)
else:
raise ReadingError("Sparser should only ever be JSON, not "
"%s." % self.format)
elif self.reader == TripsReader.name:
processor = trips.process_xml(self.content)
else:
raise ReadingError("Unknown reader: %s." % self.reader)
if processor is None:
logger.error("Production of statements from %s failed for %s."
% (self.reader, self.content_id))
stmts = []
else:
stmts = processor.statements
self._statements = stmts[:]
else:
stmts = self._statements[:]
return stmts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:read; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:read_list; 6, default_parameter; 6, 7; 6, 8; 7, identifier:verbose; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:log; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:n_per_proc; 14, None; 15, block; 15, 16; 15, 18; 15, 22; 15, 29; 15, 38; 15, 45; 15, 52; 15, 56; 15, 81; 15, 357; 15, 366; 16, expression_statement; 16, 17; 17, string:"Perform the actual reading."; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:ret; 21, list:[]; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:prep_input; 27, argument_list; 27, 28; 28, identifier:read_list; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:L; 32, call; 32, 33; 32, 34; 33, identifier:len; 34, argument_list; 34, 35; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:file_list; 38, if_statement; 38, 39; 38, 42; 39, comparison_operator:==; 39, 40; 39, 41; 40, identifier:L; 41, integer:0; 42, block; 42, 43; 43, return_statement; 43, 44; 44, identifier:ret; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:logger; 49, identifier:info; 50, argument_list; 50, 51; 51, string:"Beginning to run sparser."; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:output_file_list; 55, list:[]; 56, if_statement; 56, 57; 56, 58; 56, 75; 57, identifier:log; 58, block; 58, 59; 58, 67; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:log_name; 62, binary_operator:%; 62, 63; 62, 64; 63, string:'sparser_run_%s.log'; 64, call; 64, 65; 64, 66; 65, identifier:_time_stamp; 66, argument_list; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:outbuf; 70, call; 70, 71; 70, 72; 71, identifier:open; 72, argument_list; 72, 73; 72, 74; 73, identifier:log_name; 74, string:'wb'; 75, else_clause; 75, 76; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:outbuf; 80, None; 81, try_statement; 81, 82; 81, 334; 82, block; 82, 83; 83, if_statement; 83, 84; 83, 89; 83, 121; 84, comparison_operator:==; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:n_proc; 88, integer:1; 89, block; 89, 90; 90, for_statement; 90, 91; 90, 92; 90, 95; 91, identifier:fpath; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:file_list; 95, block; 95, 96; 95, 109; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 101; 98, pattern_list; 98, 99; 98, 100; 99, identifier:outpath; 100, identifier:_; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:read_one; 105, argument_list; 105, 106; 105, 107; 105, 108; 106, identifier:fpath; 107, identifier:outbuf; 108, identifier:verbose; 109, if_statement; 109, 110; 109, 113; 110, comparison_operator:is; 110, 111; 110, 112; 111, identifier:outpath; 112, None; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:output_file_list; 118, identifier:append; 119, argument_list; 119, 120; 120, identifier:outpath; 121, else_clause; 121, 122; 122, block; 122, 123; 122, 146; 122, 150; 122, 255; 123, if_statement; 123, 124; 123, 127; 124, comparison_operator:is; 124, 125; 124, 126; 125, identifier:n_per_proc; 126, None; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:n_per_proc; 131, call; 131, 132; 131, 133; 132, identifier:max; 133, argument_list; 133, 134; 133, 135; 134, integer:1; 135, call; 135, 136; 135, 137; 136, identifier:min; 137, argument_list; 137, 138; 137, 139; 138, integer:1000; 139, binary_operator://; 139, 140; 139, 145; 140, binary_operator://; 140, 141; 140, 142; 141, identifier:L; 142, attribute; 142, 143; 142, 144; 143, identifier:self; 144, identifier:n_proc; 145, integer:2; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:pool; 149, None; 150, try_statement; 150, 151; 150, 236; 151, block; 151, 152; 151, 161; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:pool; 155, call; 155, 156; 155, 157; 156, identifier:Pool; 157, argument_list; 157, 158; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:n_proc; 161, if_statement; 161, 162; 161, 165; 161, 207; 162, comparison_operator:is; 162, 163; 162, 164; 163, identifier:n_per_proc; 164, integer:1; 165, block; 165, 166; 165, 195; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:batches; 169, list_comprehension; 169, 170; 169, 185; 170, subscript; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:self; 173, identifier:file_list; 174, slice; 174, 175; 174, 178; 174, 179; 175, binary_operator:*; 175, 176; 175, 177; 176, identifier:n; 177, identifier:n_per_proc; 178, colon; 179, binary_operator:*; 179, 180; 179, 184; 180, parenthesized_expression; 180, 181; 181, binary_operator:+; 181, 182; 181, 183; 182, identifier:n; 183, integer:1; 184, identifier:n_per_proc; 185, for_in_clause; 185, 186; 185, 187; 186, identifier:n; 187, call; 187, 188; 187, 189; 188, identifier:range; 189, argument_list; 189, 190; 190, binary_operator:+; 190, 191; 190, 194; 191, binary_operator://; 191, 192; 191, 193; 192, identifier:L; 193, identifier:n_per_proc; 194, integer:1; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:out_lists_and_buffs; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:pool; 201, identifier:map; 202, argument_list; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:self; 205, identifier:read_some; 206, identifier:batches; 207, else_clause; 207, 208; 208, block; 208, 209; 208, 223; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:out_files_and_buffs; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:pool; 215, identifier:map; 216, argument_list; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:self; 219, identifier:read_one; 220, attribute; 220, 221; 220, 222; 221, identifier:self; 222, identifier:file_list; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:out_lists_and_buffs; 226, list_comprehension; 226, 227; 226, 231; 227, tuple; 227, 228; 227, 230; 228, list:[out_files]; 228, 229; 229, identifier:out_files; 230, identifier:buffs; 231, for_in_clause; 231, 232; 231, 235; 232, pattern_list; 232, 233; 232, 234; 233, identifier:out_files; 234, identifier:buffs; 235, identifier:out_files_and_buffs; 236, finally_clause; 236, 237; 237, block; 237, 238; 238, if_statement; 238, 239; 238, 242; 239, comparison_operator:is; 239, 240; 239, 241; 240, identifier:pool; 241, None; 242, block; 242, 243; 242, 249; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:pool; 247, identifier:close; 248, argument_list; 249, expression_statement; 249, 250; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:pool; 253, identifier:join; 254, argument_list; 255, for_statement; 255, 256; 255, 261; 255, 265; 256, pattern_list; 256, 257; 256, 258; 257, identifier:i; 258, tuple_pattern; 258, 259; 258, 260; 259, identifier:out_list; 260, identifier:buff; 261, call; 261, 262; 261, 263; 262, identifier:enumerate; 263, argument_list; 263, 264; 264, identifier:out_lists_and_buffs; 265, block; 265, 266; 265, 275; 266, if_statement; 266, 267; 266, 270; 267, comparison_operator:is; 267, 268; 267, 269; 268, identifier:out_list; 269, None; 270, block; 270, 271; 271, expression_statement; 271, 272; 272, augmented_assignment:+=; 272, 273; 272, 274; 273, identifier:output_file_list; 274, identifier:out_list; 275, if_statement; 275, 276; 275, 277; 276, identifier:log; 277, block; 277, 278; 277, 292; 277, 328; 278, expression_statement; 278, 279; 279, call; 279, 280; 279, 283; 280, attribute; 280, 281; 280, 282; 281, identifier:outbuf; 282, identifier:write; 283, argument_list; 283, 284; 284, binary_operator:%; 284, 285; 284, 286; 285, string:b'Log for producing output %d/%d.\n'; 286, tuple; 286, 287; 286, 288; 287, identifier:i; 288, call; 288, 289; 288, 290; 289, identifier:len; 290, argument_list; 290, 291; 291, identifier:out_lists_and_buffs; 292, if_statement; 292, 293; 292, 296; 292, 317; 293, comparison_operator:is; 293, 294; 293, 295; 294, identifier:buff; 295, None; 296, block; 296, 297; 296, 304; 297, expression_statement; 297, 298; 298, call; 298, 299; 298, 302; 299, attribute; 299, 300; 299, 301; 300, identifier:buff; 301, identifier:seek; 302, argument_list; 302, 303; 303, integer:0; 304, expression_statement; 304, 305; 305, call; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:outbuf; 308, identifier:write; 309, argument_list; 309, 310; 310, binary_operator:+; 310, 311; 310, 316; 311, call; 311, 312; 311, 315; 312, attribute; 312, 313; 312, 314; 313, identifier:buff; 314, identifier:read; 315, argument_list; 316, string:b'\n'; 317, else_clause; 317, 318; 318, block; 318, 319; 319, expression_statement; 319, 320; 320, call; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, identifier:outbuf; 323, identifier:write; 324, argument_list; 324, 325; 325, concatenated_string; 325, 326; 325, 327; 326, string:b'ERROR: no buffer was None. '; 327, string:b'No logs available.\n'; 328, expression_statement; 328, 329; 329, call; 329, 330; 329, 333; 330, attribute; 330, 331; 330, 332; 331, identifier:outbuf; 332, identifier:flush; 333, argument_list; 334, finally_clause; 334, 335; 335, block; 335, 336; 336, if_statement; 336, 337; 336, 338; 337, identifier:log; 338, block; 338, 339; 338, 345; 339, expression_statement; 339, 340; 340, call; 340, 341; 340, 344; 341, attribute; 341, 342; 341, 343; 342, identifier:outbuf; 343, identifier:close; 344, argument_list; 345, if_statement; 345, 346; 345, 347; 346, identifier:verbose; 347, block; 347, 348; 348, expression_statement; 348, 349; 349, call; 349, 350; 349, 353; 350, attribute; 350, 351; 350, 352; 351, identifier:logger; 352, identifier:info; 353, argument_list; 353, 354; 354, binary_operator:%; 354, 355; 354, 356; 355, string:"Sparser logs may be found at %s."; 356, identifier:log_name; 357, expression_statement; 357, 358; 358, assignment; 358, 359; 358, 360; 359, identifier:ret; 360, call; 360, 361; 360, 364; 361, attribute; 361, 362; 361, 363; 362, identifier:self; 363, identifier:get_output; 364, argument_list; 364, 365; 365, identifier:output_file_list; 366, return_statement; 366, 367; 367, identifier:ret | def read(self, read_list, verbose=False, log=False, n_per_proc=None):
"Perform the actual reading."
ret = []
self.prep_input(read_list)
L = len(self.file_list)
if L == 0:
return ret
logger.info("Beginning to run sparser.")
output_file_list = []
if log:
log_name = 'sparser_run_%s.log' % _time_stamp()
outbuf = open(log_name, 'wb')
else:
outbuf = None
try:
if self.n_proc == 1:
for fpath in self.file_list:
outpath, _ = self.read_one(fpath, outbuf, verbose)
if outpath is not None:
output_file_list.append(outpath)
else:
if n_per_proc is None:
n_per_proc = max(1, min(1000, L//self.n_proc//2))
pool = None
try:
pool = Pool(self.n_proc)
if n_per_proc is not 1:
batches = [self.file_list[n*n_per_proc:(n+1)*n_per_proc]
for n in range(L//n_per_proc + 1)]
out_lists_and_buffs = pool.map(self.read_some,
batches)
else:
out_files_and_buffs = pool.map(self.read_one,
self.file_list)
out_lists_and_buffs = [([out_files], buffs)
for out_files, buffs
in out_files_and_buffs]
finally:
if pool is not None:
pool.close()
pool.join()
for i, (out_list, buff) in enumerate(out_lists_and_buffs):
if out_list is not None:
output_file_list += out_list
if log:
outbuf.write(b'Log for producing output %d/%d.\n'
% (i, len(out_lists_and_buffs)))
if buff is not None:
buff.seek(0)
outbuf.write(buff.read() + b'\n')
else:
outbuf.write(b'ERROR: no buffer was None. '
b'No logs available.\n')
outbuf.flush()
finally:
if log:
outbuf.close()
if verbose:
logger.info("Sparser logs may be found at %s." %
log_name)
ret = self.get_output(output_file_list)
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:read_pmid_sentences; 3, parameters; 3, 4; 3, 5; 4, identifier:pmid_sentences; 5, dictionary_splat_pattern; 5, 6; 6, identifier:drum_args; 7, block; 7, 8; 7, 30; 7, 40; 7, 44; 7, 48; 7, 224; 7, 237; 8, function_definition; 8, 9; 8, 10; 8, 13; 9, function_name:_set_pmid; 10, parameters; 10, 11; 10, 12; 11, identifier:statements; 12, identifier:pmid; 13, block; 13, 14; 14, for_statement; 14, 15; 14, 16; 14, 17; 15, identifier:stmt; 16, identifier:statements; 17, block; 17, 18; 18, for_statement; 18, 19; 18, 20; 18, 23; 19, identifier:evidence; 20, attribute; 20, 21; 20, 22; 21, identifier:stmt; 22, identifier:evidence; 23, block; 23, 24; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:evidence; 28, identifier:pmid; 29, identifier:pmid; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:run_drum; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:drum_args; 36, identifier:get; 37, argument_list; 37, 38; 37, 39; 38, string:'run_drum'; 39, False; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:drum_process; 43, None; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:all_statements; 47, dictionary; 48, for_statement; 48, 49; 48, 52; 48, 57; 49, pattern_list; 49, 50; 49, 51; 50, identifier:pmid; 51, identifier:sentences; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:pmid_sentences; 55, identifier:items; 56, argument_list; 57, block; 57, 58; 57, 65; 57, 79; 57, 87; 57, 95; 57, 103; 57, 110; 57, 137; 57, 148; 57, 160; 57, 164; 57, 188; 57, 194; 57, 202; 57, 218; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:logger; 62, identifier:info; 63, argument_list; 63, 64; 64, string:'================================'; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:logger; 69, identifier:info; 70, argument_list; 70, 71; 71, binary_operator:%; 71, 72; 71, 73; 72, string:'Processing %d sentences for %s'; 73, tuple; 73, 74; 73, 78; 74, call; 74, 75; 74, 76; 75, identifier:len; 76, argument_list; 76, 77; 77, identifier:sentences; 78, identifier:pmid; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:ts; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:time; 85, identifier:time; 86, argument_list; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 92; 89, subscript; 89, 90; 89, 91; 90, identifier:drum_args; 91, string:'name'; 92, binary_operator:%; 92, 93; 92, 94; 93, string:'DrumReader%s'; 94, identifier:pmid; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:dr; 98, call; 98, 99; 98, 100; 99, identifier:DrumReader; 100, argument_list; 100, 101; 101, dictionary_splat; 101, 102; 102, identifier:drum_args; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:time; 107, identifier:sleep; 108, argument_list; 108, 109; 109, integer:3; 110, if_statement; 110, 111; 110, 116; 111, boolean_operator:and; 111, 112; 111, 113; 112, identifier:run_drum; 113, comparison_operator:is; 113, 114; 113, 115; 114, identifier:drum_process; 115, None; 116, block; 116, 117; 116, 125; 116, 131; 117, expression_statement; 117, 118; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:drum_args; 121, identifier:pop; 122, argument_list; 122, 123; 122, 124; 123, string:'run_drum'; 124, None; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:drum_process; 128, attribute; 128, 129; 128, 130; 129, identifier:dr; 130, identifier:drum_system; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 136; 133, subscript; 133, 134; 133, 135; 134, identifier:drum_args; 135, string:'drum_system'; 136, identifier:drum_process; 137, for_statement; 137, 138; 137, 139; 137, 140; 138, identifier:sentence; 139, identifier:sentences; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:dr; 145, identifier:read_text; 146, argument_list; 146, 147; 147, identifier:sentence; 148, try_statement; 148, 149; 148, 156; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:dr; 154, identifier:start; 155, argument_list; 156, except_clause; 156, 157; 156, 158; 157, identifier:SystemExit; 158, block; 158, 159; 159, pass_statement; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:statements; 163, list:[]; 164, for_statement; 164, 165; 164, 166; 164, 169; 165, identifier:extraction; 166, attribute; 166, 167; 166, 168; 167, identifier:dr; 168, identifier:extractions; 169, block; 169, 170; 169, 175; 169, 182; 170, if_statement; 170, 171; 170, 173; 171, not_operator; 171, 172; 172, identifier:extraction; 173, block; 173, 174; 174, continue_statement; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:tp; 178, call; 178, 179; 178, 180; 179, identifier:process_xml; 180, argument_list; 180, 181; 181, identifier:extraction; 182, expression_statement; 182, 183; 183, augmented_assignment:+=; 183, 184; 183, 185; 184, identifier:statements; 185, attribute; 185, 186; 185, 187; 186, identifier:tp; 187, identifier:statements; 188, expression_statement; 188, 189; 189, call; 189, 190; 189, 191; 190, identifier:_set_pmid; 191, argument_list; 191, 192; 191, 193; 192, identifier:statements; 193, identifier:pmid; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:te; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:time; 200, identifier:time; 201, argument_list; 202, expression_statement; 202, 203; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:logger; 206, identifier:info; 207, argument_list; 207, 208; 208, binary_operator:%; 208, 209; 208, 210; 209, string:'Reading took %d seconds and produced %d Statements.'; 210, tuple; 210, 211; 210, 214; 211, binary_operator:-; 211, 212; 211, 213; 212, identifier:te; 213, identifier:ts; 214, call; 214, 215; 214, 216; 215, identifier:len; 216, argument_list; 216, 217; 217, identifier:statements; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 223; 220, subscript; 220, 221; 220, 222; 221, identifier:all_statements; 222, identifier:pmid; 223, identifier:statements; 224, if_statement; 224, 225; 224, 230; 225, boolean_operator:and; 225, 226; 225, 227; 226, identifier:drum_process; 227, attribute; 227, 228; 227, 229; 228, identifier:dr; 229, identifier:drum_system; 230, block; 230, 231; 231, expression_statement; 231, 232; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:dr; 235, identifier:_kill_drum; 236, argument_list; 237, return_statement; 237, 238; 238, identifier:all_statements | def read_pmid_sentences(pmid_sentences, **drum_args):
def _set_pmid(statements, pmid):
for stmt in statements:
for evidence in stmt.evidence:
evidence.pmid = pmid
run_drum = drum_args.get('run_drum', False)
drum_process = None
all_statements = {}
for pmid, sentences in pmid_sentences.items():
logger.info('================================')
logger.info('Processing %d sentences for %s' % (len(sentences), pmid))
ts = time.time()
drum_args['name'] = 'DrumReader%s' % pmid
dr = DrumReader(**drum_args)
time.sleep(3)
if run_drum and drum_process is None:
drum_args.pop('run_drum', None)
drum_process = dr.drum_system
drum_args['drum_system'] = drum_process
for sentence in sentences:
dr.read_text(sentence)
try:
dr.start()
except SystemExit:
pass
statements = []
for extraction in dr.extractions:
if not extraction:
continue
tp = process_xml(extraction)
statements += tp.statements
_set_pmid(statements, pmid)
te = time.time()
logger.info('Reading took %d seconds and produced %d Statements.' %
(te-ts, len(statements)))
all_statements[pmid] = statements
if drum_process and dr.drum_system:
dr._kill_drum()
return all_statements |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:graph_query; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:kind; 5, identifier:source; 6, default_parameter; 6, 7; 6, 8; 7, identifier:target; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:neighbor_limit; 11, integer:1; 12, default_parameter; 12, 13; 12, 14; 13, identifier:database_filter; 14, None; 15, block; 15, 16; 15, 38; 15, 52; 15, 56; 15, 62; 15, 68; 15, 74; 15, 82; 15, 101; 15, 107; 15, 129; 15, 135; 15, 166; 15, 199; 15, 206; 15, 227; 15, 234; 15, 248; 15, 285; 15, 294; 15, 306; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:default_databases; 19, list:['wp', 'smpdb', 'reconx', 'reactome', 'psp', 'pid',
'panther', 'netpath', 'msigdb', 'mirtarbase', 'kegg',
'intact', 'inoh', 'humancyc', 'hprd',
'drugbank', 'dip', 'corum']; 19, 20; 19, 21; 19, 22; 19, 23; 19, 24; 19, 25; 19, 26; 19, 27; 19, 28; 19, 29; 19, 30; 19, 31; 19, 32; 19, 33; 19, 34; 19, 35; 19, 36; 19, 37; 20, string:'wp'; 21, string:'smpdb'; 22, string:'reconx'; 23, string:'reactome'; 24, string:'psp'; 25, string:'pid'; 26, string:'panther'; 27, string:'netpath'; 28, string:'msigdb'; 29, string:'mirtarbase'; 30, string:'kegg'; 31, string:'intact'; 32, string:'inoh'; 33, string:'humancyc'; 34, string:'hprd'; 35, string:'drugbank'; 36, string:'dip'; 37, string:'corum'; 38, if_statement; 38, 39; 38, 41; 38, 46; 39, not_operator; 39, 40; 40, identifier:database_filter; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:query_databases; 45, identifier:default_databases; 46, else_clause; 46, 47; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:query_databases; 51, identifier:database_filter; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:params; 55, dictionary; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 61; 58, subscript; 58, 59; 58, 60; 59, identifier:params; 60, string:'format'; 61, string:'BIOPAX'; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 67; 64, subscript; 64, 65; 64, 66; 65, identifier:params; 66, string:'organism'; 67, string:'9606'; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 73; 70, subscript; 70, 71; 70, 72; 71, identifier:params; 72, string:'datasource'; 73, identifier:query_databases; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:kind_str; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:kind; 80, identifier:lower; 81, argument_list; 82, if_statement; 82, 83; 82, 89; 83, comparison_operator:not; 83, 84; 83, 85; 84, identifier:kind; 85, list:['neighborhood', 'pathsbetween', 'pathsfromto']; 85, 86; 85, 87; 85, 88; 86, string:'neighborhood'; 87, string:'pathsbetween'; 88, string:'pathsfromto'; 89, block; 89, 90; 89, 99; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:logger; 94, identifier:warn; 95, argument_list; 95, 96; 96, binary_operator:%; 96, 97; 96, 98; 97, string:'Invalid query type %s'; 98, identifier:kind_str; 99, return_statement; 99, 100; 100, None; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 106; 103, subscript; 103, 104; 103, 105; 104, identifier:params; 105, string:'kind'; 106, identifier:kind_str; 107, if_statement; 107, 108; 107, 113; 107, 118; 108, call; 108, 109; 108, 110; 109, identifier:isinstance; 110, argument_list; 110, 111; 110, 112; 111, identifier:source; 112, identifier:basestring; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:source_str; 117, identifier:source; 118, else_clause; 118, 119; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:source_str; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, string:','; 126, identifier:join; 127, argument_list; 127, 128; 128, identifier:source; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 134; 131, subscript; 131, 132; 131, 133; 132, identifier:params; 133, string:'source'; 134, identifier:source_str; 135, try_statement; 135, 136; 135, 150; 136, block; 136, 137; 136, 144; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:neighbor_limit; 140, call; 140, 141; 140, 142; 141, identifier:int; 142, argument_list; 142, 143; 143, identifier:neighbor_limit; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 149; 146, subscript; 146, 147; 146, 148; 147, identifier:params; 148, string:'limit'; 149, identifier:neighbor_limit; 150, except_clause; 150, 151; 150, 154; 151, tuple; 151, 152; 151, 153; 152, identifier:TypeError; 153, identifier:ValueError; 154, block; 154, 155; 154, 164; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:logger; 159, identifier:warn; 160, argument_list; 160, 161; 161, binary_operator:%; 161, 162; 161, 163; 162, string:'Invalid neighborhood limit %s'; 163, identifier:neighbor_limit; 164, return_statement; 164, 165; 165, None; 166, if_statement; 166, 167; 166, 170; 167, comparison_operator:is; 167, 168; 167, 169; 168, identifier:target; 169, None; 170, block; 170, 171; 170, 193; 171, if_statement; 171, 172; 171, 177; 171, 182; 172, call; 172, 173; 172, 174; 173, identifier:isinstance; 174, argument_list; 174, 175; 174, 176; 175, identifier:target; 176, identifier:basestring; 177, block; 177, 178; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:target_str; 181, identifier:target; 182, else_clause; 182, 183; 183, block; 183, 184; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:target_str; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, string:','; 190, identifier:join; 191, argument_list; 191, 192; 192, identifier:target; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 198; 195, subscript; 195, 196; 195, 197; 196, identifier:params; 197, string:'target'; 198, identifier:target_str; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:logger; 203, identifier:info; 204, argument_list; 204, 205; 205, string:'Sending Pathway Commons query with parameters: '; 206, for_statement; 206, 207; 206, 210; 206, 215; 207, pattern_list; 207, 208; 207, 209; 208, identifier:k; 209, identifier:v; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:params; 213, identifier:items; 214, argument_list; 215, block; 215, 216; 216, expression_statement; 216, 217; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:logger; 220, identifier:info; 221, argument_list; 221, 222; 222, binary_operator:%; 222, 223; 222, 224; 223, string:' %s: %s'; 224, tuple; 224, 225; 224, 226; 225, identifier:k; 226, identifier:v; 227, expression_statement; 227, 228; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:logger; 231, identifier:info; 232, argument_list; 232, 233; 233, string:'Sending Pathway Commons query...'; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:res; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:requests; 240, identifier:get; 241, argument_list; 241, 242; 241, 245; 242, binary_operator:+; 242, 243; 242, 244; 243, identifier:pc2_url; 244, string:'graph'; 245, keyword_argument; 245, 246; 245, 247; 246, identifier:params; 247, identifier:params; 248, if_statement; 248, 249; 248, 255; 249, not_operator; 249, 250; 250, comparison_operator:==; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:res; 253, identifier:status_code; 254, integer:200; 255, block; 255, 256; 255, 267; 255, 283; 256, expression_statement; 256, 257; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:logger; 260, identifier:error; 261, argument_list; 261, 262; 262, binary_operator:%; 262, 263; 262, 264; 263, string:'Response is HTTP code %d.'; 264, attribute; 264, 265; 264, 266; 265, identifier:res; 266, identifier:status_code; 267, if_statement; 267, 268; 267, 273; 268, comparison_operator:==; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:res; 271, identifier:status_code; 272, integer:500; 273, block; 273, 274; 274, expression_statement; 274, 275; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:logger; 278, identifier:error; 279, argument_list; 279, 280; 280, concatenated_string; 280, 281; 280, 282; 281, string:'Note: HTTP code 500 can mean empty '; 282, string:'results for a valid query.'; 283, return_statement; 283, 284; 284, None; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:model; 288, call; 288, 289; 288, 290; 289, identifier:owl_str_to_model; 290, argument_list; 290, 291; 291, attribute; 291, 292; 291, 293; 292, identifier:res; 293, identifier:content; 294, if_statement; 294, 295; 294, 298; 295, comparison_operator:is; 295, 296; 295, 297; 296, identifier:model; 297, None; 298, block; 298, 299; 299, expression_statement; 299, 300; 300, call; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:logger; 303, identifier:info; 304, argument_list; 304, 305; 305, string:'Pathway Commons query returned a model...'; 306, return_statement; 306, 307; 307, identifier:model | def graph_query(kind, source, target=None, neighbor_limit=1,
database_filter=None):
default_databases = ['wp', 'smpdb', 'reconx', 'reactome', 'psp', 'pid',
'panther', 'netpath', 'msigdb', 'mirtarbase', 'kegg',
'intact', 'inoh', 'humancyc', 'hprd',
'drugbank', 'dip', 'corum']
if not database_filter:
query_databases = default_databases
else:
query_databases = database_filter
params = {}
params['format'] = 'BIOPAX'
params['organism'] = '9606'
params['datasource'] = query_databases
kind_str = kind.lower()
if kind not in ['neighborhood', 'pathsbetween', 'pathsfromto']:
logger.warn('Invalid query type %s' % kind_str)
return None
params['kind'] = kind_str
if isinstance(source, basestring):
source_str = source
else:
source_str = ','.join(source)
params['source'] = source_str
try:
neighbor_limit = int(neighbor_limit)
params['limit'] = neighbor_limit
except (TypeError, ValueError):
logger.warn('Invalid neighborhood limit %s' % neighbor_limit)
return None
if target is not None:
if isinstance(target, basestring):
target_str = target
else:
target_str = ','.join(target)
params['target'] = target_str
logger.info('Sending Pathway Commons query with parameters: ')
for k, v in params.items():
logger.info(' %s: %s' % (k, v))
logger.info('Sending Pathway Commons query...')
res = requests.get(pc2_url + 'graph', params=params)
if not res.status_code == 200:
logger.error('Response is HTTP code %d.' % res.status_code)
if res.status_code == 500:
logger.error('Note: HTTP code 500 can mean empty '
'results for a valid query.')
return None
model = owl_str_to_model(res.content)
if model is not None:
logger.info('Pathway Commons query returned a model...')
return model |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:set_CCLE_context; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:cell_types; 6, block; 6, 7; 6, 13; 6, 26; 6, 39; 6, 49; 6, 95; 6, 279; 6, 286; 6, 296; 7, expression_statement; 7, 8; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:get_gene_names; 12, argument_list; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 14, 17; 15, identifier:exp_values; 16, line_continuation:\; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:context_client; 20, identifier:get_protein_expression; 21, argument_list; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:_gene_names; 25, identifier:cell_types; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 27, 30; 28, identifier:mut_values; 29, line_continuation:\; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:context_client; 33, identifier:get_mutations; 34, argument_list; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_gene_names; 38, identifier:cell_types; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:muts; 42, dictionary_comprehension; 42, 43; 42, 46; 43, pair; 43, 44; 43, 45; 44, identifier:cell_line; 45, dictionary; 46, for_in_clause; 46, 47; 46, 48; 47, identifier:cell_line; 48, identifier:cell_types; 49, for_statement; 49, 50; 49, 53; 49, 58; 50, pattern_list; 50, 51; 50, 52; 51, identifier:cell_line; 52, identifier:entries; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:mut_values; 56, identifier:items; 57, argument_list; 58, block; 58, 59; 59, if_statement; 59, 60; 59, 63; 60, comparison_operator:is; 60, 61; 60, 62; 61, identifier:entries; 62, None; 63, block; 63, 64; 64, for_statement; 64, 65; 64, 68; 64, 73; 65, pattern_list; 65, 66; 65, 67; 66, identifier:gene; 67, identifier:mutations; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:entries; 71, identifier:items; 72, argument_list; 73, block; 73, 74; 74, if_statement; 74, 75; 74, 76; 74, 85; 75, identifier:mutations; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 84; 79, subscript; 79, 80; 79, 83; 80, subscript; 80, 81; 80, 82; 81, identifier:muts; 82, identifier:cell_line; 83, identifier:gene; 84, integer:1; 85, else_clause; 85, 86; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 94; 89, subscript; 89, 90; 89, 93; 90, subscript; 90, 91; 90, 92; 91, identifier:muts; 92, identifier:cell_line; 93, identifier:gene; 94, integer:0; 95, function_definition; 95, 96; 95, 97; 95, 99; 96, function_name:bin_exp; 97, parameters; 97, 98; 98, identifier:expression_dict; 99, block; 99, 100; 99, 104; 99, 108; 99, 138; 99, 142; 99, 177; 99, 194; 99, 277; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:d; 103, identifier:expression_dict; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:exp_values; 107, list:[]; 108, for_statement; 108, 109; 108, 110; 108, 111; 109, identifier:line; 110, identifier:d; 111, block; 111, 112; 112, for_statement; 112, 113; 112, 114; 112, 117; 113, identifier:gene; 114, subscript; 114, 115; 114, 116; 115, identifier:d; 116, identifier:line; 117, block; 117, 118; 117, 126; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:val; 121, subscript; 121, 122; 121, 125; 122, subscript; 122, 123; 122, 124; 123, identifier:d; 124, identifier:line; 125, identifier:gene; 126, if_statement; 126, 127; 126, 130; 127, comparison_operator:is; 127, 128; 127, 129; 128, identifier:val; 129, None; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:exp_values; 135, identifier:append; 136, argument_list; 136, 137; 137, identifier:val; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:thr_dict; 141, dictionary; 142, for_statement; 142, 143; 142, 144; 142, 149; 143, identifier:n_bins; 144, call; 144, 145; 144, 146; 145, identifier:range; 146, argument_list; 146, 147; 146, 148; 147, integer:3; 148, integer:10; 149, block; 149, 150; 149, 171; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:bin_thr; 153, subscript; 153, 154; 153, 168; 154, subscript; 154, 155; 154, 167; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:np; 158, identifier:histogram; 159, argument_list; 159, 160; 159, 166; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:np; 163, identifier:log10; 164, argument_list; 164, 165; 165, identifier:exp_values; 166, identifier:n_bins; 167, integer:1; 168, slice; 168, 169; 168, 170; 169, integer:1; 170, colon; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 176; 173, subscript; 173, 174; 173, 175; 174, identifier:thr_dict; 175, identifier:n_bins; 176, identifier:bin_thr; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:binned_dict; 180, dictionary_comprehension; 180, 181; 180, 187; 181, pair; 181, 182; 181, 183; 182, identifier:x; 183, call; 183, 184; 183, 185; 184, identifier:deepcopy; 185, argument_list; 185, 186; 186, identifier:expression_dict; 187, for_in_clause; 187, 188; 187, 189; 188, identifier:x; 189, call; 189, 190; 189, 191; 190, identifier:range; 191, argument_list; 191, 192; 191, 193; 192, integer:3; 193, integer:10; 194, for_statement; 194, 195; 194, 196; 194, 197; 195, identifier:n_bins; 196, identifier:binned_dict; 197, block; 197, 198; 198, for_statement; 198, 199; 198, 200; 198, 203; 199, identifier:line; 200, subscript; 200, 201; 200, 202; 201, identifier:binned_dict; 202, identifier:n_bins; 203, block; 203, 204; 204, for_statement; 204, 205; 204, 206; 204, 211; 205, identifier:gene; 206, subscript; 206, 207; 206, 210; 207, subscript; 207, 208; 207, 209; 208, identifier:binned_dict; 209, identifier:n_bins; 210, identifier:line; 211, block; 211, 212; 212, if_statement; 212, 213; 212, 222; 212, 233; 213, comparison_operator:is; 213, 214; 213, 221; 214, subscript; 214, 215; 214, 220; 215, subscript; 215, 216; 215, 219; 216, subscript; 216, 217; 216, 218; 217, identifier:binned_dict; 218, identifier:n_bins; 219, identifier:line; 220, identifier:gene; 221, None; 222, block; 222, 223; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 232; 225, subscript; 225, 226; 225, 231; 226, subscript; 226, 227; 226, 230; 227, subscript; 227, 228; 227, 229; 228, identifier:binned_dict; 229, identifier:n_bins; 230, identifier:line; 231, identifier:gene; 232, identifier:n_bins; 233, else_clause; 233, 234; 234, block; 234, 235; 234, 250; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:val; 238, call; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:np; 241, identifier:log10; 242, argument_list; 242, 243; 243, subscript; 243, 244; 243, 249; 244, subscript; 244, 245; 244, 248; 245, subscript; 245, 246; 245, 247; 246, identifier:binned_dict; 247, identifier:n_bins; 248, identifier:line; 249, identifier:gene; 250, for_statement; 250, 251; 250, 254; 250, 260; 251, pattern_list; 251, 252; 251, 253; 252, identifier:thr_idx; 253, identifier:thr; 254, call; 254, 255; 254, 256; 255, identifier:enumerate; 256, argument_list; 256, 257; 257, subscript; 257, 258; 257, 259; 258, identifier:thr_dict; 259, identifier:n_bins; 260, block; 260, 261; 261, if_statement; 261, 262; 261, 265; 262, comparison_operator:<=; 262, 263; 262, 264; 263, identifier:val; 264, identifier:thr; 265, block; 265, 266; 265, 276; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 275; 268, subscript; 268, 269; 268, 274; 269, subscript; 269, 270; 269, 273; 270, subscript; 270, 271; 270, 272; 271, identifier:binned_dict; 272, identifier:n_bins; 273, identifier:line; 274, identifier:gene; 275, identifier:thr_idx; 276, break_statement; 277, return_statement; 277, 278; 278, identifier:binned_dict; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:binned_exp; 282, call; 282, 283; 282, 284; 283, identifier:bin_exp; 284, argument_list; 284, 285; 285, identifier:exp_values; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 288, identifier:context; 289, dictionary; 289, 290; 289, 293; 290, pair; 290, 291; 290, 292; 291, string:'bin_expression'; 292, identifier:binned_exp; 293, pair; 293, 294; 293, 295; 294, string:'mutation'; 295, identifier:muts; 296, expression_statement; 296, 297; 297, assignment; 297, 298; 297, 303; 298, subscript; 298, 299; 298, 302; 299, attribute; 299, 300; 299, 301; 300, identifier:self; 301, identifier:_context; 302, string:'CCLE'; 303, identifier:context | def set_CCLE_context(self, cell_types):
self.get_gene_names()
exp_values = \
context_client.get_protein_expression(self._gene_names, cell_types)
mut_values = \
context_client.get_mutations(self._gene_names, cell_types)
muts = {cell_line: {} for cell_line in cell_types}
for cell_line, entries in mut_values.items():
if entries is not None:
for gene, mutations in entries.items():
if mutations:
muts[cell_line][gene] = 1
else:
muts[cell_line][gene] = 0
def bin_exp(expression_dict):
d = expression_dict
exp_values = []
for line in d:
for gene in d[line]:
val = d[line][gene]
if val is not None:
exp_values.append(val)
thr_dict = {}
for n_bins in range(3, 10):
bin_thr = np.histogram(np.log10(exp_values), n_bins)[1][1:]
thr_dict[n_bins] = bin_thr
binned_dict = {x: deepcopy(expression_dict) for x in range(3, 10)}
for n_bins in binned_dict:
for line in binned_dict[n_bins]:
for gene in binned_dict[n_bins][line]:
if binned_dict[n_bins][line][gene] is None:
binned_dict[n_bins][line][gene] = n_bins
else:
val = np.log10(binned_dict[n_bins][line][gene])
for thr_idx, thr in enumerate(thr_dict[n_bins]):
if val <= thr:
binned_dict[n_bins][line][gene] = thr_idx
break
return binned_dict
binned_exp = bin_exp(exp_values)
context = {'bin_expression': binned_exp,
'mutation': muts}
self._context['CCLE'] = context |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_get_node_key; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:node_dict_item; 6, block; 6, 7; 6, 19; 6, 31; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:s; 10, call; 10, 11; 10, 12; 11, identifier:tuple; 12, argument_list; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:sorted; 15, argument_list; 15, 16; 16, subscript; 16, 17; 16, 18; 17, identifier:node_dict_item; 18, string:'sources'; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:t; 22, call; 22, 23; 22, 24; 23, identifier:tuple; 24, argument_list; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:sorted; 27, argument_list; 27, 28; 28, subscript; 28, 29; 28, 30; 29, identifier:node_dict_item; 30, string:'targets'; 31, return_statement; 31, 32; 32, tuple; 32, 33; 32, 34; 33, identifier:s; 34, identifier:t | def _get_node_key(self, node_dict_item):
s = tuple(sorted(node_dict_item['sources']))
t = tuple(sorted(node_dict_item['targets']))
return (s, t) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_get_node_groups; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 28; 5, 102; 5, 112; 5, 140; 5, 160; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:node_dict; 9, dictionary_comprehension; 9, 10; 9, 23; 10, pair; 10, 11; 10, 16; 11, subscript; 11, 12; 11, 15; 12, subscript; 12, 13; 12, 14; 13, identifier:node; 14, string:'data'; 15, string:'id'; 16, dictionary; 16, 17; 16, 20; 17, pair; 17, 18; 17, 19; 18, string:'sources'; 19, list:[]; 20, pair; 20, 21; 20, 22; 21, string:'targets'; 22, list:[]; 23, for_in_clause; 23, 24; 23, 25; 24, identifier:node; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:_nodes; 28, for_statement; 28, 29; 28, 30; 28, 33; 29, identifier:edge; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_edges; 33, block; 33, 34; 33, 53; 33, 68; 33, 87; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:edge_data; 37, tuple; 37, 38; 37, 43; 37, 48; 38, subscript; 38, 39; 38, 42; 39, subscript; 39, 40; 39, 41; 40, identifier:edge; 41, string:'data'; 42, string:'i'; 43, subscript; 43, 44; 43, 47; 44, subscript; 44, 45; 44, 46; 45, identifier:edge; 46, string:'data'; 47, string:'polarity'; 48, subscript; 48, 49; 48, 52; 49, subscript; 49, 50; 49, 51; 50, identifier:edge; 51, string:'data'; 52, string:'source'; 53, expression_statement; 53, 54; 54, call; 54, 55; 54, 66; 55, attribute; 55, 56; 55, 65; 56, subscript; 56, 57; 56, 64; 57, subscript; 57, 58; 57, 59; 58, identifier:node_dict; 59, subscript; 59, 60; 59, 63; 60, subscript; 60, 61; 60, 62; 61, identifier:edge; 62, string:'data'; 63, string:'target'; 64, string:'sources'; 65, identifier:append; 66, argument_list; 66, 67; 67, identifier:edge_data; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:edge_data; 71, tuple; 71, 72; 71, 77; 71, 82; 72, subscript; 72, 73; 72, 76; 73, subscript; 73, 74; 73, 75; 74, identifier:edge; 75, string:'data'; 76, string:'i'; 77, subscript; 77, 78; 77, 81; 78, subscript; 78, 79; 78, 80; 79, identifier:edge; 80, string:'data'; 81, string:'polarity'; 82, subscript; 82, 83; 82, 86; 83, subscript; 83, 84; 83, 85; 84, identifier:edge; 85, string:'data'; 86, string:'target'; 87, expression_statement; 87, 88; 88, call; 88, 89; 88, 100; 89, attribute; 89, 90; 89, 99; 90, subscript; 90, 91; 90, 98; 91, subscript; 91, 92; 91, 93; 92, identifier:node_dict; 93, subscript; 93, 94; 93, 97; 94, subscript; 94, 95; 94, 96; 95, identifier:edge; 96, string:'data'; 97, string:'source'; 98, string:'targets'; 99, identifier:append; 100, argument_list; 100, 101; 101, identifier:edge_data; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:node_key_dict; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:collections; 108, identifier:defaultdict; 109, argument_list; 109, 110; 110, lambda; 110, 111; 111, list:[]; 112, for_statement; 112, 113; 112, 116; 112, 121; 113, pattern_list; 113, 114; 113, 115; 114, identifier:node_id; 115, identifier:node_d; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:node_dict; 119, identifier:items; 120, argument_list; 121, block; 121, 122; 121, 131; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:key; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:_get_node_key; 129, argument_list; 129, 130; 130, identifier:node_d; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 138; 133, attribute; 133, 134; 133, 137; 134, subscript; 134, 135; 134, 136; 135, identifier:node_key_dict; 136, identifier:key; 137, identifier:append; 138, argument_list; 138, 139; 139, identifier:node_id; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:node_groups; 143, list_comprehension; 143, 144; 143, 145; 143, 152; 144, identifier:g; 145, for_in_clause; 145, 146; 145, 147; 146, identifier:g; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:node_key_dict; 150, identifier:values; 151, argument_list; 152, if_clause; 152, 153; 153, parenthesized_expression; 153, 154; 154, comparison_operator:>; 154, 155; 154, 159; 155, call; 155, 156; 155, 157; 156, identifier:len; 157, argument_list; 157, 158; 158, identifier:g; 159, integer:1; 160, return_statement; 160, 161; 161, identifier:node_groups | def _get_node_groups(self):
node_dict = {node['data']['id']: {'sources': [], 'targets': []}
for node in self._nodes}
for edge in self._edges:
edge_data = (edge['data']['i'], edge['data']['polarity'],
edge['data']['source'])
node_dict[edge['data']['target']]['sources'].append(edge_data)
edge_data = (edge['data']['i'], edge['data']['polarity'],
edge['data']['target'])
node_dict[edge['data']['source']]['targets'].append(edge_data)
node_key_dict = collections.defaultdict(lambda: [])
for node_id, node_d in node_dict.items():
key = self._get_node_key(node_d)
node_key_dict[key].append(node_id)
node_groups = [g for g in node_key_dict.values() if (len(g) > 1)]
return node_groups |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_group_edges; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 234; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:edges_to_add; 9, list:[[], []]; 9, 10; 9, 11; 10, list:[]; 11, list:[]; 12, for_statement; 12, 13; 12, 14; 12, 17; 13, identifier:e; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_edges; 17, block; 17, 18; 17, 25; 17, 35; 17, 47; 17, 55; 17, 63; 17, 83; 17, 103; 17, 132; 17, 161; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:new_edge; 21, call; 21, 22; 21, 23; 22, identifier:deepcopy; 23, argument_list; 23, 24; 24, identifier:e; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 32; 27, attribute; 27, 28; 27, 31; 28, subscript; 28, 29; 28, 30; 29, identifier:new_edge; 30, string:'data'; 31, identifier:pop; 32, argument_list; 32, 33; 32, 34; 33, string:'id'; 34, None; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:uuid_list; 38, call; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, subscript; 40, 41; 40, 42; 41, identifier:new_edge; 42, string:'data'; 43, identifier:pop; 44, argument_list; 44, 45; 44, 46; 45, string:'uuid_list'; 46, list:[]; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:source; 50, subscript; 50, 51; 50, 54; 51, subscript; 51, 52; 51, 53; 52, identifier:e; 53, string:'data'; 54, string:'source'; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:target; 58, subscript; 58, 59; 58, 62; 59, subscript; 59, 60; 59, 61; 60, identifier:e; 61, string:'data'; 62, string:'target'; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:source_node; 66, subscript; 66, 67; 66, 82; 67, list_comprehension; 67, 68; 67, 69; 67, 74; 68, identifier:x; 69, for_in_clause; 69, 70; 69, 71; 70, identifier:x; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:_nodes; 74, if_clause; 74, 75; 75, comparison_operator:==; 75, 76; 75, 81; 76, subscript; 76, 77; 76, 80; 77, subscript; 77, 78; 77, 79; 78, identifier:x; 79, string:'data'; 80, string:'id'; 81, identifier:source; 82, integer:0; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:target_node; 86, subscript; 86, 87; 86, 102; 87, list_comprehension; 87, 88; 87, 89; 87, 94; 88, identifier:x; 89, for_in_clause; 89, 90; 89, 91; 90, identifier:x; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:_nodes; 94, if_clause; 94, 95; 95, comparison_operator:==; 95, 96; 95, 101; 96, subscript; 96, 97; 96, 100; 97, subscript; 97, 98; 97, 99; 98, identifier:x; 99, string:'data'; 100, string:'id'; 101, identifier:target; 102, integer:0; 103, if_statement; 103, 104; 103, 111; 104, comparison_operator:!=; 104, 105; 104, 110; 105, subscript; 105, 106; 105, 109; 106, subscript; 106, 107; 106, 108; 107, identifier:source_node; 108, string:'data'; 109, string:'parent'; 110, string:''; 111, block; 111, 112; 111, 124; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 119; 114, subscript; 114, 115; 114, 118; 115, subscript; 115, 116; 115, 117; 116, identifier:new_edge; 117, string:'data'; 118, string:'source'; 119, subscript; 119, 120; 119, 123; 120, subscript; 120, 121; 120, 122; 121, identifier:source_node; 122, string:'data'; 123, string:'parent'; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 131; 126, subscript; 126, 127; 126, 130; 127, subscript; 127, 128; 127, 129; 128, identifier:e; 129, string:'data'; 130, string:'i'; 131, string:'Virtual'; 132, if_statement; 132, 133; 132, 140; 133, comparison_operator:!=; 133, 134; 133, 139; 134, subscript; 134, 135; 134, 138; 135, subscript; 135, 136; 135, 137; 136, identifier:target_node; 137, string:'data'; 138, string:'parent'; 139, string:''; 140, block; 140, 141; 140, 153; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 148; 143, subscript; 143, 144; 143, 147; 144, subscript; 144, 145; 144, 146; 145, identifier:new_edge; 146, string:'data'; 147, string:'target'; 148, subscript; 148, 149; 148, 152; 149, subscript; 149, 150; 149, 151; 150, identifier:target_node; 151, string:'data'; 152, string:'parent'; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 160; 155, subscript; 155, 156; 155, 159; 156, subscript; 156, 157; 156, 158; 157, identifier:e; 158, string:'data'; 159, string:'i'; 160, string:'Virtual'; 161, if_statement; 161, 162; 161, 169; 162, comparison_operator:==; 162, 163; 162, 168; 163, subscript; 163, 164; 163, 167; 164, subscript; 164, 165; 164, 166; 165, identifier:e; 166, string:'data'; 167, string:'i'; 168, string:'Virtual'; 169, block; 169, 170; 170, if_statement; 170, 171; 170, 176; 170, 195; 171, comparison_operator:not; 171, 172; 171, 173; 172, identifier:new_edge; 173, subscript; 173, 174; 173, 175; 174, identifier:edges_to_add; 175, integer:0; 176, block; 176, 177; 176, 186; 177, expression_statement; 177, 178; 178, call; 178, 179; 178, 184; 179, attribute; 179, 180; 179, 183; 180, subscript; 180, 181; 180, 182; 181, identifier:edges_to_add; 182, integer:0; 183, identifier:append; 184, argument_list; 184, 185; 185, identifier:new_edge; 186, expression_statement; 186, 187; 187, call; 187, 188; 187, 193; 188, attribute; 188, 189; 188, 192; 189, subscript; 189, 190; 189, 191; 190, identifier:edges_to_add; 191, integer:1; 192, identifier:append; 193, argument_list; 193, 194; 194, identifier:uuid_list; 195, else_clause; 195, 196; 196, block; 196, 197; 196, 208; 196, 216; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 200; 199, identifier:idx; 200, call; 200, 201; 200, 206; 201, attribute; 201, 202; 201, 205; 202, subscript; 202, 203; 202, 204; 203, identifier:edges_to_add; 204, integer:0; 205, identifier:index; 206, argument_list; 206, 207; 207, identifier:new_edge; 208, expression_statement; 208, 209; 209, augmented_assignment:+=; 209, 210; 209, 215; 210, subscript; 210, 211; 210, 214; 211, subscript; 211, 212; 211, 213; 212, identifier:edges_to_add; 213, integer:1; 214, identifier:idx; 215, identifier:uuid_list; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 223; 218, subscript; 218, 219; 218, 222; 219, subscript; 219, 220; 219, 221; 220, identifier:edges_to_add; 221, integer:1; 222, identifier:idx; 223, call; 223, 224; 223, 225; 224, identifier:list; 225, argument_list; 225, 226; 226, call; 226, 227; 226, 228; 227, identifier:set; 228, argument_list; 228, 229; 229, subscript; 229, 230; 229, 233; 230, subscript; 230, 231; 230, 232; 231, identifier:edges_to_add; 232, integer:1; 233, identifier:idx; 234, for_statement; 234, 235; 234, 236; 234, 241; 235, identifier:ze; 236, call; 236, 237; 236, 238; 237, identifier:zip; 238, argument_list; 238, 239; 239, list_splat; 239, 240; 240, identifier:edges_to_add; 241, block; 241, 242; 241, 248; 241, 260; 241, 270; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:edge; 245, subscript; 245, 246; 245, 247; 246, identifier:ze; 247, integer:0; 248, expression_statement; 248, 249; 249, assignment; 249, 250; 249, 255; 250, subscript; 250, 251; 250, 254; 251, subscript; 251, 252; 251, 253; 252, identifier:edge; 253, string:'data'; 254, string:'id'; 255, call; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:self; 258, identifier:_get_new_id; 259, argument_list; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 267; 262, subscript; 262, 263; 262, 266; 263, subscript; 263, 264; 263, 265; 264, identifier:edge; 265, string:'data'; 266, string:'uuid_list'; 267, subscript; 267, 268; 267, 269; 268, identifier:ze; 269, integer:1; 270, expression_statement; 270, 271; 271, call; 271, 272; 271, 277; 272, attribute; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:self; 275, identifier:_edges; 276, identifier:append; 277, argument_list; 277, 278; 278, identifier:edge | def _group_edges(self):
edges_to_add = [[], []]
for e in self._edges:
new_edge = deepcopy(e)
new_edge['data'].pop('id', None)
uuid_list = new_edge['data'].pop('uuid_list', [])
source = e['data']['source']
target = e['data']['target']
source_node = [x for x in self._nodes if
x['data']['id'] == source][0]
target_node = [x for x in self._nodes if
x['data']['id'] == target][0]
if source_node['data']['parent'] != '':
new_edge['data']['source'] = source_node['data']['parent']
e['data']['i'] = 'Virtual'
if target_node['data']['parent'] != '':
new_edge['data']['target'] = target_node['data']['parent']
e['data']['i'] = 'Virtual'
if e['data']['i'] == 'Virtual':
if new_edge not in edges_to_add[0]:
edges_to_add[0].append(new_edge)
edges_to_add[1].append(uuid_list)
else:
idx = edges_to_add[0].index(new_edge)
edges_to_add[1][idx] += uuid_list
edges_to_add[1][idx] = list(set(edges_to_add[1][idx]))
for ze in zip(*edges_to_add):
edge = ze[0]
edge['data']['id'] = self._get_new_id()
edge['data']['uuid_list'] = ze[1]
self._edges.append(edge) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 40; 2, function_name:get_statements; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 3, 25; 3, 28; 3, 31; 3, 34; 3, 37; 4, default_parameter; 4, 5; 4, 6; 5, identifier:subject; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:object; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:agents; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:stmt_type; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:use_exact_type; 18, False; 19, default_parameter; 19, 20; 19, 21; 20, identifier:persist; 21, True; 22, default_parameter; 22, 23; 22, 24; 23, identifier:timeout; 24, None; 25, default_parameter; 25, 26; 25, 27; 26, identifier:simple_response; 27, False; 28, default_parameter; 28, 29; 28, 30; 29, identifier:ev_limit; 30, integer:10; 31, default_parameter; 31, 32; 31, 33; 32, identifier:best_first; 33, True; 34, default_parameter; 34, 35; 34, 36; 35, identifier:tries; 36, integer:2; 37, default_parameter; 37, 38; 37, 39; 38, identifier:max_stmts; 39, None; 40, block; 40, 41; 40, 58; 40, 73; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:processor; 44, call; 44, 45; 44, 46; 45, identifier:IndraDBRestProcessor; 46, argument_list; 46, 47; 46, 48; 46, 49; 46, 50; 46, 51; 46, 52; 46, 53; 46, 54; 46, 55; 46, 56; 46, 57; 47, identifier:subject; 48, identifier:object; 49, identifier:agents; 50, identifier:stmt_type; 51, identifier:use_exact_type; 52, identifier:persist; 53, identifier:timeout; 54, identifier:ev_limit; 55, identifier:best_first; 56, identifier:tries; 57, identifier:max_stmts; 58, if_statement; 58, 59; 58, 60; 58, 67; 59, identifier:simple_response; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:ret; 64, attribute; 64, 65; 64, 66; 65, identifier:processor; 66, identifier:statements; 67, else_clause; 67, 68; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:ret; 72, identifier:processor; 73, return_statement; 73, 74; 74, identifier:ret | def get_statements(subject=None, object=None, agents=None, stmt_type=None,
use_exact_type=False, persist=True, timeout=None,
simple_response=False, ev_limit=10, best_first=True, tries=2,
max_stmts=None):
processor = IndraDBRestProcessor(subject, object, agents, stmt_type,
use_exact_type, persist, timeout,
ev_limit, best_first, tries, max_stmts)
if simple_response:
ret = processor.statements
else:
ret = processor
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:get_statements_by_hash; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:hash_list; 5, default_parameter; 5, 6; 5, 7; 6, identifier:ev_limit; 7, integer:100; 8, default_parameter; 8, 9; 8, 10; 9, identifier:best_first; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:tries; 13, integer:2; 14, block; 14, 15; 14, 33; 14, 39; 14, 59; 14, 81; 14, 104; 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:hash_list; 21, identifier:list; 22, block; 22, 23; 23, raise_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:ValueError; 26, argument_list; 26, 27; 27, binary_operator:%; 27, 28; 27, 29; 28, string:"The `hash_list` input is a list, not %s."; 29, call; 29, 30; 29, 31; 30, identifier:type; 31, argument_list; 31, 32; 32, identifier:hash_list; 33, if_statement; 33, 34; 33, 36; 34, not_operator; 34, 35; 35, identifier:hash_list; 36, block; 36, 37; 37, return_statement; 37, 38; 38, list:[]; 39, if_statement; 39, 40; 39, 47; 40, call; 40, 41; 40, 42; 41, identifier:isinstance; 42, argument_list; 42, 43; 42, 46; 43, subscript; 43, 44; 43, 45; 44, identifier:hash_list; 45, integer:0; 46, identifier:str; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:hash_list; 51, list_comprehension; 51, 52; 51, 56; 52, call; 52, 53; 52, 54; 53, identifier:int; 54, argument_list; 54, 55; 55, identifier:h; 56, for_in_clause; 56, 57; 56, 58; 57, identifier:h; 58, identifier:hash_list; 59, if_statement; 59, 60; 59, 73; 60, not_operator; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:all; 63, argument_list; 63, 64; 64, list_comprehension; 64, 65; 64, 70; 65, call; 65, 66; 65, 67; 66, identifier:isinstance; 67, argument_list; 67, 68; 67, 69; 68, identifier:h; 69, identifier:int; 70, for_in_clause; 70, 71; 70, 72; 71, identifier:h; 72, identifier:hash_list; 73, block; 73, 74; 74, raise_statement; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:ValueError; 77, argument_list; 77, 78; 78, concatenated_string; 78, 79; 78, 80; 79, string:"Hashes must be ints or strings that can be "; 80, string:"converted into ints."; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:resp; 84, call; 84, 85; 84, 86; 85, identifier:submit_statement_request; 86, argument_list; 86, 87; 86, 88; 86, 89; 86, 92; 86, 98; 86, 101; 87, string:'post'; 88, string:'from_hashes'; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:ev_limit; 91, identifier:ev_limit; 92, keyword_argument; 92, 93; 92, 94; 93, identifier:data; 94, dictionary; 94, 95; 95, pair; 95, 96; 95, 97; 96, string:'hashes'; 97, identifier:hash_list; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:best_first; 100, identifier:best_first; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:tries; 103, identifier:tries; 104, return_statement; 104, 105; 105, call; 105, 106; 105, 107; 106, identifier:stmts_from_json; 107, argument_list; 107, 108; 108, call; 108, 109; 108, 118; 109, attribute; 109, 110; 109, 117; 110, subscript; 110, 111; 110, 116; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:resp; 114, identifier:json; 115, argument_list; 116, string:'statements'; 117, identifier:values; 118, argument_list | def get_statements_by_hash(hash_list, ev_limit=100, best_first=True, tries=2):
if not isinstance(hash_list, list):
raise ValueError("The `hash_list` input is a list, not %s."
% type(hash_list))
if not hash_list:
return []
if isinstance(hash_list[0], str):
hash_list = [int(h) for h in hash_list]
if not all([isinstance(h, int) for h in hash_list]):
raise ValueError("Hashes must be ints or strings that can be "
"converted into ints.")
resp = submit_statement_request('post', 'from_hashes', ev_limit=ev_limit,
data={'hashes': hash_list},
best_first=best_first, tries=tries)
return stmts_from_json(resp.json()['statements'].values()) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:get_statements_for_paper; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:ids; 5, default_parameter; 5, 6; 5, 7; 6, identifier:ev_limit; 7, integer:10; 8, default_parameter; 8, 9; 8, 10; 9, identifier:best_first; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:tries; 13, integer:2; 14, default_parameter; 14, 15; 14, 16; 15, identifier:max_stmts; 16, None; 17, block; 17, 18; 17, 34; 17, 60; 17, 70; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:id_l; 21, list_comprehension; 21, 22; 21, 29; 22, dictionary; 22, 23; 22, 26; 23, pair; 23, 24; 23, 25; 24, string:'id'; 25, identifier:id_val; 26, pair; 26, 27; 26, 28; 27, string:'type'; 28, identifier:id_type; 29, for_in_clause; 29, 30; 29, 33; 30, pattern_list; 30, 31; 30, 32; 31, identifier:id_type; 32, identifier:id_val; 33, identifier:ids; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:resp; 37, call; 37, 38; 37, 39; 38, identifier:submit_statement_request; 39, argument_list; 39, 40; 39, 41; 39, 42; 39, 48; 39, 51; 39, 54; 39, 57; 40, string:'post'; 41, string:'from_papers'; 42, keyword_argument; 42, 43; 42, 44; 43, identifier:data; 44, dictionary; 44, 45; 45, pair; 45, 46; 45, 47; 46, string:'ids'; 47, identifier:id_l; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:ev_limit; 50, identifier:ev_limit; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:best_first; 53, identifier:best_first; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:tries; 56, identifier:tries; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:max_stmts; 59, identifier:max_stmts; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:stmts_json; 63, subscript; 63, 64; 63, 69; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:resp; 67, identifier:json; 68, argument_list; 69, string:'statements'; 70, return_statement; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:stmts_from_json; 73, argument_list; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:stmts_json; 77, identifier:values; 78, argument_list | def get_statements_for_paper(ids, ev_limit=10, best_first=True, tries=2,
max_stmts=None):
id_l = [{'id': id_val, 'type': id_type} for id_type, id_val in ids]
resp = submit_statement_request('post', 'from_papers', data={'ids': id_l},
ev_limit=ev_limit, best_first=best_first,
tries=tries, max_stmts=max_stmts)
stmts_json = resp.json()['statements']
return stmts_from_json(stmts_json.values()) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:get_statement_queries; 3, parameters; 3, 4; 3, 5; 4, identifier:stmts; 5, dictionary_splat_pattern; 5, 6; 6, identifier:params; 7, block; 7, 8; 7, 61; 7, 65; 7, 72; 7, 79; 7, 211; 8, function_definition; 8, 9; 8, 10; 8, 12; 9, function_name:pick_ns; 10, parameters; 10, 11; 11, identifier:ag; 12, block; 12, 13; 12, 55; 13, for_statement; 13, 14; 13, 15; 13, 22; 13, 43; 14, identifier:ns; 15, list:['HGNC', 'FPLX', 'CHEMBL', 'CHEBI', 'GO', 'MESH']; 15, 16; 15, 17; 15, 18; 15, 19; 15, 20; 15, 21; 16, string:'HGNC'; 17, string:'FPLX'; 18, string:'CHEMBL'; 19, string:'CHEBI'; 20, string:'GO'; 21, string:'MESH'; 22, block; 22, 23; 23, if_statement; 23, 24; 23, 33; 24, comparison_operator:in; 24, 25; 24, 26; 25, identifier:ns; 26, call; 26, 27; 26, 32; 27, attribute; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:ag; 30, identifier:db_refs; 31, identifier:keys; 32, argument_list; 33, block; 33, 34; 33, 42; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:dbid; 37, subscript; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:ag; 40, identifier:db_refs; 41, identifier:ns; 42, break_statement; 43, else_clause; 43, 44; 44, block; 44, 45; 44, 49; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:ns; 48, string:'TEXT'; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:dbid; 52, attribute; 52, 53; 52, 54; 53, identifier:ag; 54, identifier:name; 55, return_statement; 55, 56; 56, binary_operator:%; 56, 57; 56, 58; 57, string:'%s@%s'; 58, tuple; 58, 59; 58, 60; 59, identifier:dbid; 60, identifier:ns; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:queries; 64, list:[]; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:url_base; 68, call; 68, 69; 68, 70; 69, identifier:get_url_base; 70, argument_list; 70, 71; 71, string:'statements/from_agents'; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:non_binary_statements; 75, list:[Complex, SelfModification, ActiveForm]; 75, 76; 75, 77; 75, 78; 76, identifier:Complex; 77, identifier:SelfModification; 78, identifier:ActiveForm; 79, for_statement; 79, 80; 79, 81; 79, 82; 80, identifier:stmt; 81, identifier:stmts; 82, block; 82, 83; 82, 87; 82, 156; 82, 166; 82, 173; 82, 202; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:kwargs; 86, dictionary; 87, if_statement; 87, 88; 87, 94; 87, 125; 88, comparison_operator:not; 88, 89; 88, 93; 89, call; 89, 90; 89, 91; 90, identifier:type; 91, argument_list; 91, 92; 92, identifier:stmt; 93, identifier:non_binary_statements; 94, block; 94, 95; 95, for_statement; 95, 96; 95, 99; 95, 110; 96, pattern_list; 96, 97; 96, 98; 97, identifier:pos; 98, identifier:ag; 99, call; 99, 100; 99, 101; 100, identifier:zip; 101, argument_list; 101, 102; 101, 105; 102, list:['subject', 'object']; 102, 103; 102, 104; 103, string:'subject'; 104, string:'object'; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:stmt; 108, identifier:agent_list; 109, argument_list; 110, block; 110, 111; 111, if_statement; 111, 112; 111, 115; 112, comparison_operator:is; 112, 113; 112, 114; 113, identifier:ag; 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:kwargs; 120, identifier:pos; 121, call; 121, 122; 121, 123; 122, identifier:pick_ns; 123, argument_list; 123, 124; 124, identifier:ag; 125, else_clause; 125, 126; 126, block; 126, 127; 127, for_statement; 127, 128; 127, 131; 127, 139; 128, pattern_list; 128, 129; 128, 130; 129, identifier:i; 130, identifier:ag; 131, call; 131, 132; 131, 133; 132, identifier:enumerate; 133, argument_list; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:stmt; 137, identifier:agent_list; 138, argument_list; 139, block; 139, 140; 140, if_statement; 140, 141; 140, 144; 141, comparison_operator:is; 141, 142; 141, 143; 142, identifier:ag; 143, None; 144, block; 144, 145; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 152; 147, subscript; 147, 148; 147, 149; 148, identifier:kwargs; 149, binary_operator:%; 149, 150; 149, 151; 150, string:'agent%d'; 151, identifier:i; 152, call; 152, 153; 152, 154; 153, identifier:pick_ns; 154, argument_list; 154, 155; 155, identifier:ag; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 161; 158, subscript; 158, 159; 158, 160; 159, identifier:kwargs; 160, string:'type'; 161, attribute; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:stmt; 164, identifier:__class__; 165, identifier:__name__; 166, expression_statement; 166, 167; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:kwargs; 170, identifier:update; 171, argument_list; 171, 172; 172, identifier:params; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:query_str; 176, binary_operator:+; 176, 177; 176, 178; 177, string:'?'; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, string:'&'; 181, identifier:join; 182, argument_list; 182, 183; 183, list_comprehension; 183, 184; 183, 189; 183, 198; 184, binary_operator:%; 184, 185; 184, 186; 185, string:'%s=%s'; 186, tuple; 186, 187; 186, 188; 187, identifier:k; 188, identifier:v; 189, for_in_clause; 189, 190; 189, 193; 190, pattern_list; 190, 191; 190, 192; 191, identifier:k; 192, identifier:v; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:kwargs; 196, identifier:items; 197, argument_list; 198, if_clause; 198, 199; 199, comparison_operator:is; 199, 200; 199, 201; 200, identifier:v; 201, None; 202, expression_statement; 202, 203; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:queries; 206, identifier:append; 207, argument_list; 207, 208; 208, binary_operator:+; 208, 209; 208, 210; 209, identifier:url_base; 210, identifier:query_str; 211, return_statement; 211, 212; 212, identifier:queries | def get_statement_queries(stmts, **params):
def pick_ns(ag):
for ns in ['HGNC', 'FPLX', 'CHEMBL', 'CHEBI', 'GO', 'MESH']:
if ns in ag.db_refs.keys():
dbid = ag.db_refs[ns]
break
else:
ns = 'TEXT'
dbid = ag.name
return '%s@%s' % (dbid, ns)
queries = []
url_base = get_url_base('statements/from_agents')
non_binary_statements = [Complex, SelfModification, ActiveForm]
for stmt in stmts:
kwargs = {}
if type(stmt) not in non_binary_statements:
for pos, ag in zip(['subject', 'object'], stmt.agent_list()):
if ag is not None:
kwargs[pos] = pick_ns(ag)
else:
for i, ag in enumerate(stmt.agent_list()):
if ag is not None:
kwargs['agent%d' % i] = pick_ns(ag)
kwargs['type'] = stmt.__class__.__name__
kwargs.update(params)
query_str = '?' + '&'.join(['%s=%s' % (k, v) for k, v in kwargs.items()
if v is not None])
queries.append(url_base + query_str)
return queries |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:make_statement; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:action; 6, identifier:mention; 7, block; 7, 8; 7, 23; 7, 30; 7, 34; 7, 102; 7, 108; 7, 114; 7, 122; 7, 130; 7, 158; 7, 170; 7, 182; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 13; 9, 14; 10, tuple_pattern; 10, 11; 10, 12; 11, identifier:statement_generator; 12, identifier:is_direct; 13, line_continuation:\; 14, call; 14, 15; 14, 16; 15, identifier:geneways_action_to_indra_statement_type; 16, argument_list; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:mention; 19, identifier:actiontype; 20, attribute; 20, 21; 20, 22; 21, identifier:action; 22, identifier:plo; 23, if_statement; 23, 24; 23, 27; 24, comparison_operator:is; 24, 25; 24, 26; 25, identifier:statement_generator; 26, None; 27, block; 27, 28; 28, return_statement; 28, 29; 29, None; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:text; 33, None; 34, if_statement; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:get_ft_mention; 38, block; 38, 39; 39, try_statement; 39, 40; 39, 88; 40, block; 40, 41; 40, 53; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 46; 43, pattern_list; 43, 44; 43, 45; 44, identifier:content; 45, identifier:content_type; 46, call; 46, 47; 46, 48; 47, identifier:get_full_text; 48, argument_list; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:mention; 51, identifier:pmid; 52, string:'pmid'; 53, if_statement; 53, 54; 53, 57; 54, comparison_operator:is; 54, 55; 54, 56; 55, identifier:content; 56, None; 57, block; 57, 58; 57, 66; 57, 74; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:ftm; 61, call; 61, 62; 61, 63; 62, identifier:FullTextMention; 63, argument_list; 63, 64; 63, 65; 64, identifier:mention; 65, identifier:content; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:sentences; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:ftm; 72, identifier:find_matching_sentences; 73, argument_list; 74, if_statement; 74, 75; 74, 81; 75, comparison_operator:==; 75, 76; 75, 80; 76, call; 76, 77; 76, 78; 77, identifier:len; 78, argument_list; 78, 79; 79, identifier:sentences; 80, integer:1; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:text; 85, subscript; 85, 86; 85, 87; 86, identifier:sentences; 87, integer:0; 88, except_clause; 88, 89; 88, 90; 89, identifier:Exception; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:logger; 95, identifier:warning; 96, argument_list; 96, 97; 97, binary_operator:+; 97, 98; 97, 99; 98, string:'Could not fetch full text for PMID '; 99, attribute; 99, 100; 99, 101; 100, identifier:mention; 101, identifier:pmid; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:epistemics; 105, call; 105, 106; 105, 107; 106, identifier:dict; 107, argument_list; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 113; 110, subscript; 110, 111; 110, 112; 111, identifier:epistemics; 112, string:'direct'; 113, identifier:is_direct; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:annotations; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:mention; 120, identifier:make_annotation; 121, argument_list; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 127; 124, subscript; 124, 125; 124, 126; 125, identifier:annotations; 126, string:'plo'; 127, attribute; 127, 128; 127, 129; 128, identifier:action; 129, identifier:plo; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:evidence; 133, call; 133, 134; 133, 135; 134, identifier:Evidence; 135, argument_list; 135, 136; 135, 139; 135, 144; 135, 149; 135, 152; 135, 155; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:source_api; 138, string:'geneways'; 139, keyword_argument; 139, 140; 139, 141; 140, identifier:source_id; 141, attribute; 141, 142; 141, 143; 142, identifier:mention; 143, identifier:actionmentionid; 144, keyword_argument; 144, 145; 144, 146; 145, identifier:pmid; 146, attribute; 146, 147; 146, 148; 147, identifier:mention; 148, identifier:pmid; 149, keyword_argument; 149, 150; 149, 151; 150, identifier:text; 151, identifier:text; 152, keyword_argument; 152, 153; 152, 154; 153, identifier:epistemics; 154, identifier:epistemics; 155, keyword_argument; 155, 156; 155, 157; 156, identifier:annotations; 157, identifier:annotations; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:upstream_agent; 161, call; 161, 162; 161, 163; 162, identifier:get_agent; 163, argument_list; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:mention; 166, identifier:upstream; 167, attribute; 167, 168; 167, 169; 168, identifier:action; 169, identifier:up; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:downstream_agent; 173, call; 173, 174; 173, 175; 174, identifier:get_agent; 175, argument_list; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:mention; 178, identifier:downstream; 179, attribute; 179, 180; 179, 181; 180, identifier:action; 181, identifier:dn; 182, return_statement; 182, 183; 183, call; 183, 184; 183, 185; 184, identifier:statement_generator; 185, argument_list; 185, 186; 185, 187; 185, 188; 186, identifier:upstream_agent; 187, identifier:downstream_agent; 188, identifier:evidence | def make_statement(self, action, mention):
(statement_generator, is_direct) = \
geneways_action_to_indra_statement_type(mention.actiontype,
action.plo)
if statement_generator is None:
return None
text = None
if self.get_ft_mention:
try:
content, content_type = get_full_text(mention.pmid, 'pmid')
if content is not None:
ftm = FullTextMention(mention, content)
sentences = ftm.find_matching_sentences()
if len(sentences) == 1:
text = sentences[0]
except Exception:
logger.warning('Could not fetch full text for PMID ' +
mention.pmid)
epistemics = dict()
epistemics['direct'] = is_direct
annotations = mention.make_annotation()
annotations['plo'] = action.plo
evidence = Evidence(source_api='geneways',
source_id=mention.actionmentionid,
pmid=mention.pmid, text=text,
epistemics=epistemics,
annotations=annotations)
upstream_agent = get_agent(mention.upstream, action.up)
downstream_agent = get_agent(mention.downstream, action.dn)
return statement_generator(upstream_agent, downstream_agent, evidence) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:directly_or_indirectly_related; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, identifier:self; 5, identifier:ns1; 6, identifier:id1; 7, identifier:ns2; 8, identifier:id2; 9, identifier:closure_dict; 10, identifier:relation_func; 11, block; 11, 12; 11, 35; 12, if_statement; 12, 13; 12, 25; 12, 28; 13, boolean_operator:or; 13, 14; 13, 17; 14, comparison_operator:is; 14, 15; 14, 16; 15, identifier:id2; 16, None; 17, parenthesized_expression; 17, 18; 18, boolean_operator:and; 18, 19; 18, 22; 19, comparison_operator:is; 19, 20; 19, 21; 20, identifier:id2; 21, None; 22, comparison_operator:is; 22, 23; 22, 24; 23, identifier:id1; 24, None; 25, block; 25, 26; 26, return_statement; 26, 27; 27, True; 28, elif_clause; 28, 29; 28, 32; 29, comparison_operator:is; 29, 30; 29, 31; 30, identifier:id1; 31, None; 32, block; 32, 33; 33, return_statement; 33, 34; 34, False; 35, if_statement; 35, 36; 35, 37; 35, 82; 36, identifier:closure_dict; 37, block; 37, 38; 37, 48; 37, 58; 37, 67; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:term1; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:get_uri; 45, argument_list; 45, 46; 45, 47; 46, identifier:ns1; 47, identifier:id1; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:term2; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:get_uri; 55, argument_list; 55, 56; 55, 57; 56, identifier:ns2; 57, identifier:id2; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:ec; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:closure_dict; 64, identifier:get; 65, argument_list; 65, 66; 66, identifier:term1; 67, if_statement; 67, 68; 67, 75; 67, 78; 68, boolean_operator:and; 68, 69; 68, 72; 69, comparison_operator:is; 69, 70; 69, 71; 70, identifier:ec; 71, None; 72, comparison_operator:in; 72, 73; 72, 74; 73, identifier:term2; 74, identifier:ec; 75, block; 75, 76; 76, return_statement; 76, 77; 77, True; 78, else_clause; 78, 79; 79, block; 79, 80; 80, return_statement; 80, 81; 81, False; 82, else_clause; 82, 83; 83, block; 83, 84; 83, 185; 83, 197; 84, if_statement; 84, 85; 84, 89; 84, 141; 85, not_operator; 85, 86; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:uri_as_name; 89, block; 89, 90; 89, 99; 89, 108; 89, 119; 89, 130; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:e1; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:find_entity; 97, argument_list; 97, 98; 98, identifier:id1; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:e2; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:find_entity; 106, argument_list; 106, 107; 107, identifier:id2; 108, if_statement; 108, 109; 108, 116; 109, boolean_operator:or; 109, 110; 109, 113; 110, comparison_operator:is; 110, 111; 110, 112; 111, identifier:e1; 112, None; 113, comparison_operator:is; 113, 114; 113, 115; 114, identifier:e2; 115, None; 116, block; 116, 117; 117, return_statement; 117, 118; 118, False; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:t1; 122, call; 122, 123; 122, 128; 123, attribute; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:rdflib; 126, identifier:term; 127, identifier:URIRef; 128, argument_list; 128, 129; 129, identifier:e1; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:t2; 133, call; 133, 134; 133, 139; 134, attribute; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:rdflib; 137, identifier:term; 138, identifier:URIRef; 139, argument_list; 139, 140; 140, identifier:e2; 141, else_clause; 141, 142; 142, block; 142, 143; 142, 153; 142, 163; 142, 174; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:u1; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:get_uri; 150, argument_list; 150, 151; 150, 152; 151, identifier:ns1; 152, identifier:id1; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:u2; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:get_uri; 160, argument_list; 160, 161; 160, 162; 161, identifier:ns2; 162, identifier:id2; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:t1; 166, call; 166, 167; 166, 172; 167, attribute; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:rdflib; 170, identifier:term; 171, identifier:URIRef; 172, argument_list; 172, 173; 173, identifier:u1; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:t2; 177, call; 177, 178; 177, 183; 178, attribute; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:rdflib; 181, identifier:term; 182, identifier:URIRef; 183, argument_list; 183, 184; 184, identifier:u2; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:to; 188, call; 188, 189; 188, 194; 189, attribute; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:self; 192, identifier:graph; 193, identifier:transitiveClosure; 194, argument_list; 194, 195; 194, 196; 195, identifier:relation_func; 196, identifier:t1; 197, if_statement; 197, 198; 197, 201; 197, 204; 198, comparison_operator:in; 198, 199; 198, 200; 199, identifier:t2; 200, identifier:to; 201, block; 201, 202; 202, return_statement; 202, 203; 203, True; 204, else_clause; 204, 205; 205, block; 205, 206; 206, return_statement; 206, 207; 207, False | def directly_or_indirectly_related(self, ns1, id1, ns2, id2, closure_dict,
relation_func):
if id2 is None or (id2 is None and id1 is None):
return True
elif id1 is None:
return False
if closure_dict:
term1 = self.get_uri(ns1, id1)
term2 = self.get_uri(ns2, id2)
ec = closure_dict.get(term1)
if ec is not None and term2 in ec:
return True
else:
return False
else:
if not self.uri_as_name:
e1 = self.find_entity(id1)
e2 = self.find_entity(id2)
if e1 is None or e2 is None:
return False
t1 = rdflib.term.URIRef(e1)
t2 = rdflib.term.URIRef(e2)
else:
u1 = self.get_uri(ns1, id1)
u2 = self.get_uri(ns2, id2)
t1 = rdflib.term.URIRef(u1)
t2 = rdflib.term.URIRef(u2)
to = self.graph.transitiveClosure(relation_func, t1)
if t2 in to:
return True
else:
return False |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:analyze_db_reading; 3, parameters; 3, 4; 3, 5; 4, identifier:job_prefix; 5, default_parameter; 5, 6; 5, 7; 6, identifier:reading_queue; 7, string:'run_db_reading_queue'; 8, block; 8, 9; 8, 17; 8, 21; 8, 25; 8, 29; 8, 66; 8, 80; 8, 98; 8, 108; 8, 118; 8, 239; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:log_strs; 12, call; 12, 13; 12, 14; 13, identifier:get_logs_from_db_reading; 14, argument_list; 14, 15; 14, 16; 15, identifier:job_prefix; 16, identifier:reading_queue; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:indra_log_strs; 20, list:[]; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:all_reach_logs; 24, list:[]; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:log_stats; 28, list:[]; 29, for_statement; 29, 30; 29, 31; 29, 32; 30, identifier:log_str; 31, identifier:log_strs; 32, block; 32, 33; 32, 42; 32, 49; 32, 56; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 38; 35, pattern_list; 35, 36; 35, 37; 36, identifier:log_str; 37, identifier:reach_logs; 38, call; 38, 39; 38, 40; 39, identifier:separate_reach_logs; 40, argument_list; 40, 41; 41, identifier:log_str; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:all_reach_logs; 46, identifier:extend; 47, argument_list; 47, 48; 48, identifier:reach_logs; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:indra_log_strs; 53, identifier:append; 54, argument_list; 54, 55; 55, identifier:log_str; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:log_stats; 60, identifier:append; 61, argument_list; 61, 62; 62, call; 62, 63; 62, 64; 63, identifier:get_reading_stats; 64, argument_list; 64, 65; 65, identifier:log_str; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:failed_reach_logs; 69, list_comprehension; 69, 70; 69, 71; 69, 76; 70, identifier:reach_log_str; 71, for_in_clause; 71, 72; 71, 75; 72, pattern_list; 72, 73; 72, 74; 73, identifier:result; 74, identifier:reach_log_str; 75, identifier:all_reach_logs; 76, if_clause; 76, 77; 77, comparison_operator:==; 77, 78; 77, 79; 78, identifier:result; 79, string:'FAILURE'; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:failed_id_dicts; 83, list_comprehension; 83, 84; 83, 90; 83, 93; 84, call; 84, 85; 84, 86; 85, identifier:analyze_reach_log; 86, argument_list; 86, 87; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:log_str; 89, identifier:reach_log; 90, for_in_clause; 90, 91; 90, 92; 91, identifier:reach_log; 92, identifier:failed_reach_logs; 93, if_clause; 93, 94; 94, call; 94, 95; 94, 96; 95, identifier:bool; 96, argument_list; 96, 97; 97, identifier:reach_log; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:tcids_unfinished; 101, set_comprehension; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:id_dict; 104, string:'not_done'; 105, for_in_clause; 105, 106; 105, 107; 106, identifier:id_dict; 107, identifier:failed_id_dicts; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 111; 110, identifier:print; 111, argument_list; 111, 112; 112, binary_operator:%; 112, 113; 112, 114; 113, string:"Found %d unfinished tcids."; 114, call; 114, 115; 114, 116; 115, identifier:len; 116, argument_list; 116, 117; 117, identifier:tcids_unfinished; 118, if_statement; 118, 119; 118, 120; 118, 233; 119, identifier:log_stats; 120, block; 120, 121; 120, 136; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:sum_dict; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:dict; 127, identifier:fromkeys; 128, argument_list; 128, 129; 129, call; 129, 130; 129, 135; 130, attribute; 130, 131; 130, 134; 131, subscript; 131, 132; 131, 133; 132, identifier:log_stats; 133, integer:0; 134, identifier:keys; 135, argument_list; 136, for_statement; 136, 137; 136, 138; 136, 139; 137, identifier:log_stat; 138, identifier:log_stats; 139, block; 139, 140; 140, for_statement; 140, 141; 140, 142; 140, 147; 141, identifier:k; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:log_stat; 145, identifier:keys; 146, argument_list; 147, block; 147, 148; 148, if_statement; 148, 149; 148, 156; 148, 208; 149, call; 149, 150; 149, 151; 150, identifier:isinstance; 151, argument_list; 151, 152; 151, 155; 152, subscript; 152, 153; 152, 154; 153, identifier:log_stat; 154, identifier:k; 155, identifier:list; 156, block; 156, 157; 156, 180; 157, if_statement; 157, 158; 157, 165; 158, comparison_operator:not; 158, 159; 158, 160; 159, identifier:k; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:sum_dict; 163, identifier:keys; 164, argument_list; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 171; 168, subscript; 168, 169; 168, 170; 169, identifier:sum_dict; 170, identifier:k; 171, binary_operator:*; 171, 172; 171, 174; 172, list:[0]; 172, 173; 173, integer:0; 174, call; 174, 175; 174, 176; 175, identifier:len; 176, argument_list; 176, 177; 177, subscript; 177, 178; 177, 179; 178, identifier:log_stat; 179, identifier:k; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 185; 182, subscript; 182, 183; 182, 184; 183, identifier:sum_dict; 184, identifier:k; 185, list_comprehension; 185, 186; 185, 197; 186, binary_operator:+; 186, 187; 186, 192; 187, subscript; 187, 188; 187, 191; 188, subscript; 188, 189; 188, 190; 189, identifier:sum_dict; 190, identifier:k; 191, identifier:i; 192, subscript; 192, 193; 192, 196; 193, subscript; 193, 194; 193, 195; 194, identifier:log_stat; 195, identifier:k; 196, identifier:i; 197, for_in_clause; 197, 198; 197, 199; 198, identifier:i; 199, call; 199, 200; 199, 201; 200, identifier:range; 201, argument_list; 201, 202; 202, call; 202, 203; 202, 204; 203, identifier:len; 204, argument_list; 204, 205; 205, subscript; 205, 206; 205, 207; 206, identifier:log_stat; 207, identifier:k; 208, else_clause; 208, 209; 209, block; 209, 210; 209, 225; 210, if_statement; 210, 211; 210, 218; 211, comparison_operator:not; 211, 212; 211, 213; 212, identifier:k; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:sum_dict; 216, identifier:keys; 217, argument_list; 218, block; 218, 219; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 224; 221, subscript; 221, 222; 221, 223; 222, identifier:sum_dict; 223, identifier:k; 224, integer:0; 225, expression_statement; 225, 226; 226, augmented_assignment:+=; 226, 227; 226, 230; 227, subscript; 227, 228; 227, 229; 228, identifier:sum_dict; 229, identifier:k; 230, subscript; 230, 231; 230, 232; 231, identifier:log_stat; 232, identifier:k; 233, else_clause; 233, 234; 234, block; 234, 235; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:sum_dict; 238, dictionary; 239, return_statement; 239, 240; 240, expression_list; 240, 241; 240, 242; 240, 243; 241, identifier:tcids_unfinished; 242, identifier:sum_dict; 243, identifier:log_stats | def analyze_db_reading(job_prefix, reading_queue='run_db_reading_queue'):
log_strs = get_logs_from_db_reading(job_prefix, reading_queue)
indra_log_strs = []
all_reach_logs = []
log_stats = []
for log_str in log_strs:
log_str, reach_logs = separate_reach_logs(log_str)
all_reach_logs.extend(reach_logs)
indra_log_strs.append(log_str)
log_stats.append(get_reading_stats(log_str))
failed_reach_logs = [reach_log_str
for result, reach_log_str in all_reach_logs
if result == 'FAILURE']
failed_id_dicts = [analyze_reach_log(log_str=reach_log)
for reach_log in failed_reach_logs if bool(reach_log)]
tcids_unfinished = {id_dict['not_done'] for id_dict in failed_id_dicts}
print("Found %d unfinished tcids." % len(tcids_unfinished))
if log_stats:
sum_dict = dict.fromkeys(log_stats[0].keys())
for log_stat in log_stats:
for k in log_stat.keys():
if isinstance(log_stat[k], list):
if k not in sum_dict.keys():
sum_dict[k] = [0]*len(log_stat[k])
sum_dict[k] = [sum_dict[k][i] + log_stat[k][i]
for i in range(len(log_stat[k]))]
else:
if k not in sum_dict.keys():
sum_dict[k] = 0
sum_dict[k] += log_stat[k]
else:
sum_dict = {}
return tcids_unfinished, sum_dict, log_stats |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_create_base_agent; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:agent; 6, block; 6, 7; 6, 50; 6, 216; 6, 236; 7, try_statement; 7, 8; 7, 22; 8, block; 8, 9; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:base_agent; 12, subscript; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:agents; 16, call; 16, 17; 16, 18; 17, identifier:_n; 18, argument_list; 18, 19; 19, attribute; 19, 20; 19, 21; 20, identifier:agent; 21, identifier:name; 22, except_clause; 22, 23; 22, 24; 23, identifier:KeyError; 24, block; 24, 25; 24, 37; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:base_agent; 28, call; 28, 29; 28, 30; 29, identifier:BaseAgent; 30, argument_list; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:_n; 33, argument_list; 33, 34; 34, attribute; 34, 35; 34, 36; 35, identifier:agent; 36, identifier:name; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 49; 39, subscript; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:agents; 43, call; 43, 44; 43, 45; 44, identifier:_n; 45, argument_list; 45, 46; 46, attribute; 46, 47; 46, 48; 47, identifier:agent; 48, identifier:name; 49, identifier:base_agent; 50, if_statement; 50, 51; 50, 56; 51, call; 51, 52; 51, 53; 52, identifier:isinstance; 53, argument_list; 53, 54; 53, 55; 54, identifier:agent; 55, identifier:Agent; 56, block; 56, 57; 56, 96; 56, 109; 56, 170; 56, 191; 57, for_statement; 57, 58; 57, 59; 57, 62; 58, identifier:bc; 59, attribute; 59, 60; 59, 61; 60, identifier:agent; 61, identifier:bound_conditions; 62, block; 62, 63; 62, 74; 62, 84; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:bound_base_agent; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:get_create_base_agent; 70, argument_list; 70, 71; 71, attribute; 71, 72; 71, 73; 72, identifier:bc; 73, identifier:agent; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:bound_base_agent; 78, identifier:create_site; 79, argument_list; 79, 80; 80, call; 80, 81; 80, 82; 81, identifier:get_binding_site_name; 82, argument_list; 82, 83; 83, identifier:agent; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:base_agent; 88, identifier:create_site; 89, argument_list; 89, 90; 90, call; 90, 91; 90, 92; 91, identifier:get_binding_site_name; 92, argument_list; 92, 93; 93, attribute; 93, 94; 93, 95; 94, identifier:bc; 95, identifier:agent; 96, for_statement; 96, 97; 96, 98; 96, 101; 97, identifier:mc; 98, attribute; 98, 99; 98, 100; 99, identifier:agent; 100, identifier:mods; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:base_agent; 106, identifier:create_mod_site; 107, argument_list; 107, 108; 108, identifier:mc; 109, for_statement; 109, 110; 109, 111; 109, 114; 110, identifier:mc; 111, attribute; 111, 112; 111, 113; 112, identifier:agent; 113, identifier:mutations; 114, block; 114, 115; 114, 126; 114, 137; 114, 158; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:res_from; 118, conditional_expression:if; 118, 119; 118, 122; 118, 125; 119, attribute; 119, 120; 119, 121; 120, identifier:mc; 121, identifier:residue_from; 122, attribute; 122, 123; 122, 124; 123, identifier:mc; 124, identifier:residue_from; 125, string:'mut'; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:res_to; 129, conditional_expression:if; 129, 130; 129, 133; 129, 136; 130, attribute; 130, 131; 130, 132; 131, identifier:mc; 132, identifier:residue_to; 133, attribute; 133, 134; 133, 135; 134, identifier:mc; 135, identifier:residue_to; 136, string:'X'; 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:mc; 141, identifier:position; 142, None; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:mut_site_name; 147, identifier:res_from; 148, else_clause; 148, 149; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:mut_site_name; 153, binary_operator:+; 153, 154; 153, 155; 154, identifier:res_from; 155, attribute; 155, 156; 155, 157; 156, identifier:mc; 157, identifier:position; 158, expression_statement; 158, 159; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:base_agent; 162, identifier:create_site; 163, argument_list; 163, 164; 163, 165; 164, identifier:mut_site_name; 165, keyword_argument; 165, 166; 165, 167; 166, identifier:states; 167, list:['WT', res_to]; 167, 168; 167, 169; 168, string:'WT'; 169, identifier:res_to; 170, if_statement; 170, 171; 170, 176; 171, comparison_operator:is; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:agent; 174, identifier:location; 175, None; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:base_agent; 181, identifier:create_site; 182, argument_list; 182, 183; 182, 184; 183, string:'loc'; 184, list:[_n(agent.location)]; 184, 185; 185, call; 185, 186; 185, 187; 186, identifier:_n; 187, argument_list; 187, 188; 188, attribute; 188, 189; 188, 190; 189, identifier:agent; 190, identifier:location; 191, if_statement; 191, 192; 191, 197; 192, comparison_operator:is; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:agent; 195, identifier:activity; 196, None; 197, block; 197, 198; 197, 206; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:site_name; 201, attribute; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:agent; 204, identifier:activity; 205, identifier:activity_type; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:base_agent; 210, identifier:create_site; 211, argument_list; 211, 212; 211, 213; 212, identifier:site_name; 213, list:['inactive', 'active']; 213, 214; 213, 215; 214, string:'inactive'; 215, string:'active'; 216, for_statement; 216, 217; 216, 220; 216, 227; 217, pattern_list; 217, 218; 217, 219; 218, identifier:db_name; 219, identifier:db_ref; 220, call; 220, 221; 220, 226; 221, attribute; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:agent; 224, identifier:db_refs; 225, identifier:items; 226, argument_list; 227, block; 227, 228; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 235; 230, subscript; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:base_agent; 233, identifier:db_refs; 234, identifier:db_name; 235, identifier:db_ref; 236, return_statement; 236, 237; 237, identifier:base_agent | def get_create_base_agent(self, agent):
try:
base_agent = self.agents[_n(agent.name)]
except KeyError:
base_agent = BaseAgent(_n(agent.name))
self.agents[_n(agent.name)] = base_agent
if isinstance(agent, Agent):
for bc in agent.bound_conditions:
bound_base_agent = self.get_create_base_agent(bc.agent)
bound_base_agent.create_site(get_binding_site_name(agent))
base_agent.create_site(get_binding_site_name(bc.agent))
for mc in agent.mods:
base_agent.create_mod_site(mc)
for mc in agent.mutations:
res_from = mc.residue_from if mc.residue_from else 'mut'
res_to = mc.residue_to if mc.residue_to else 'X'
if mc.position is None:
mut_site_name = res_from
else:
mut_site_name = res_from + mc.position
base_agent.create_site(mut_site_name, states=['WT', res_to])
if agent.location is not None:
base_agent.create_site('loc', [_n(agent.location)])
if agent.activity is not None:
site_name = agent.activity.activity_type
base_agent.create_site(site_name, ['inactive', 'active'])
for db_name, db_ref in agent.db_refs.items():
base_agent.db_refs[db_name] = db_ref
return base_agent |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:classify_nodes; 3, parameters; 3, 4; 3, 5; 4, identifier:graph; 5, identifier:hub; 6, block; 6, 7; 6, 18; 6, 140; 6, 144; 6, 227; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:node_stats; 10, call; 10, 11; 10, 12; 11, identifier:defaultdict; 12, argument_list; 12, 13; 13, lambda; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:defaultdict; 16, argument_list; 16, 17; 17, identifier:list; 18, for_statement; 18, 19; 18, 23; 18, 31; 19, pattern_list; 19, 20; 19, 21; 19, 22; 20, identifier:u; 21, identifier:v; 22, identifier:data; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:graph; 26, identifier:edges; 27, argument_list; 27, 28; 28, keyword_argument; 28, 29; 28, 30; 29, identifier:data; 30, True; 31, block; 31, 32; 31, 124; 32, if_statement; 32, 33; 32, 36; 32, 77; 32, 121; 33, comparison_operator:==; 33, 34; 33, 35; 34, identifier:hub; 35, identifier:u; 36, block; 36, 37; 36, 45; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 42; 39, pattern_list; 39, 40; 39, 41; 40, identifier:h; 41, identifier:o; 42, expression_list; 42, 43; 42, 44; 43, identifier:u; 44, identifier:v; 45, if_statement; 45, 46; 45, 51; 45, 64; 46, comparison_operator:!=; 46, 47; 46, 50; 47, subscript; 47, 48; 47, 49; 48, identifier:data; 49, string:'i'; 50, string:'Complex'; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, call; 53, 54; 53, 61; 54, attribute; 54, 55; 54, 60; 55, subscript; 55, 56; 55, 59; 56, subscript; 56, 57; 56, 58; 57, identifier:node_stats; 58, identifier:o; 59, string:'up'; 60, identifier:append; 61, argument_list; 61, 62; 62, unary_operator:-; 62, 63; 63, integer:1; 64, else_clause; 64, 65; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 75; 68, attribute; 68, 69; 68, 74; 69, subscript; 69, 70; 69, 73; 70, subscript; 70, 71; 70, 72; 71, identifier:node_stats; 72, identifier:o; 73, string:'up'; 74, identifier:append; 75, argument_list; 75, 76; 76, integer:0; 77, elif_clause; 77, 78; 77, 81; 78, comparison_operator:==; 78, 79; 78, 80; 79, identifier:hub; 80, identifier:v; 81, block; 81, 82; 81, 90; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, pattern_list; 84, 85; 84, 86; 85, identifier:h; 86, identifier:o; 87, expression_list; 87, 88; 87, 89; 88, identifier:v; 89, identifier:u; 90, if_statement; 90, 91; 90, 96; 90, 108; 91, comparison_operator:!=; 91, 92; 91, 95; 92, subscript; 92, 93; 92, 94; 93, identifier:data; 94, string:'i'; 95, string:'Complex'; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 106; 99, attribute; 99, 100; 99, 105; 100, subscript; 100, 101; 100, 104; 101, subscript; 101, 102; 101, 103; 102, identifier:node_stats; 103, identifier:o; 104, string:'up'; 105, identifier:append; 106, argument_list; 106, 107; 107, integer:1; 108, else_clause; 108, 109; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, call; 111, 112; 111, 119; 112, attribute; 112, 113; 112, 118; 113, subscript; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:node_stats; 116, identifier:o; 117, string:'up'; 118, identifier:append; 119, argument_list; 119, 120; 120, integer:0; 121, else_clause; 121, 122; 122, block; 122, 123; 123, continue_statement; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 133; 126, attribute; 126, 127; 126, 132; 127, subscript; 127, 128; 127, 131; 128, subscript; 128, 129; 128, 130; 129, identifier:node_stats; 130, identifier:o; 131, string:'interaction'; 132, identifier:append; 133, argument_list; 133, 134; 134, call; 134, 135; 134, 136; 135, identifier:edge_type_to_class; 136, argument_list; 136, 137; 137, subscript; 137, 138; 137, 139; 138, identifier:data; 139, string:'i'; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:node_classes; 143, dictionary; 144, for_statement; 144, 145; 144, 148; 144, 153; 145, pattern_list; 145, 146; 145, 147; 146, identifier:node_id; 147, identifier:stats; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:node_stats; 151, identifier:items; 152, argument_list; 153, block; 153, 154; 153, 173; 153, 193; 153, 208; 153, 218; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:up; 157, call; 157, 158; 157, 159; 158, identifier:max; 159, argument_list; 159, 160; 159, 166; 160, call; 160, 161; 160, 162; 161, identifier:set; 162, argument_list; 162, 163; 163, subscript; 163, 164; 163, 165; 164, identifier:stats; 165, string:'up'; 166, keyword_argument; 166, 167; 166, 168; 167, identifier:key; 168, attribute; 168, 169; 168, 172; 169, subscript; 169, 170; 169, 171; 170, identifier:stats; 171, string:'up'; 172, identifier:count; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:interactions; 176, list_comprehension; 176, 177; 176, 178; 176, 183; 177, identifier:i; 178, for_in_clause; 178, 179; 178, 180; 179, identifier:i; 180, subscript; 180, 181; 180, 182; 181, identifier:stats; 182, string:'interaction'; 183, if_clause; 183, 184; 184, not_operator; 184, 185; 185, parenthesized_expression; 185, 186; 186, boolean_operator:and; 186, 187; 186, 190; 187, comparison_operator:!=; 187, 188; 187, 189; 188, identifier:up; 189, integer:0; 190, comparison_operator:==; 190, 191; 190, 192; 191, identifier:i; 192, string:'complex'; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:edge_type; 196, call; 196, 197; 196, 198; 197, identifier:max; 198, argument_list; 198, 199; 198, 203; 199, call; 199, 200; 199, 201; 200, identifier:set; 201, argument_list; 201, 202; 202, identifier:interactions; 203, keyword_argument; 203, 204; 203, 205; 204, identifier:key; 205, attribute; 205, 206; 205, 207; 206, identifier:interactions; 207, identifier:count; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:node_type; 211, subscript; 211, 212; 211, 217; 212, subscript; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:graph; 215, identifier:nodes; 216, identifier:node_id; 217, string:'type'; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 223; 220, subscript; 220, 221; 220, 222; 221, identifier:node_classes; 222, identifier:node_id; 223, tuple; 223, 224; 223, 225; 223, 226; 224, identifier:up; 225, identifier:edge_type; 226, identifier:node_type; 227, return_statement; 227, 228; 228, identifier:node_classes | def classify_nodes(graph, hub):
node_stats = defaultdict(lambda: defaultdict(list))
for u, v, data in graph.edges(data=True):
if hub == u:
h, o = u, v
if data['i'] != 'Complex':
node_stats[o]['up'].append(-1)
else:
node_stats[o]['up'].append(0)
elif hub == v:
h, o = v, u
if data['i'] != 'Complex':
node_stats[o]['up'].append(1)
else:
node_stats[o]['up'].append(0)
else:
continue
node_stats[o]['interaction'].append(edge_type_to_class(data['i']))
node_classes = {}
for node_id, stats in node_stats.items():
up = max(set(stats['up']), key=stats['up'].count)
interactions = [i for i in stats['interaction'] if
not (up != 0 and i == 'complex')]
edge_type = max(set(interactions), key=interactions.count)
node_type = graph.nodes[node_id]['type']
node_classes[node_id] = (up, edge_type, node_type)
return node_classes |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:doi_query; 3, parameters; 3, 4; 3, 5; 4, identifier:pmid; 5, default_parameter; 5, 6; 5, 7; 6, identifier:search_limit; 7, integer:10; 8, block; 8, 9; 8, 22; 8, 47; 8, 53; 8, 68; 8, 77; 8, 93; 8, 102; 8, 117; 8, 126; 8, 141; 8, 145; 8, 155; 8, 213; 8, 235; 8, 243; 8, 247; 8, 436; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:pubmed_meta_dict; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:pubmed_client; 15, identifier:get_metadata_for_ids; 16, argument_list; 16, 17; 16, 19; 17, list:[pmid]; 17, 18; 18, identifier:pmid; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:get_issns_from_nlm; 21, True; 22, if_statement; 22, 23; 22, 35; 23, boolean_operator:or; 23, 24; 23, 27; 24, comparison_operator:is; 24, 25; 24, 26; 25, identifier:pubmed_meta_dict; 26, None; 27, comparison_operator:is; 27, 28; 27, 34; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:pubmed_meta_dict; 31, identifier:get; 32, argument_list; 32, 33; 33, identifier:pmid; 34, None; 35, block; 35, 36; 35, 45; 36, expression_statement; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:logger; 40, identifier:warning; 41, argument_list; 41, 42; 42, binary_operator:%; 42, 43; 42, 44; 43, string:'No metadata found in Pubmed for PMID%s'; 44, identifier:pmid; 45, return_statement; 45, 46; 46, None; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:pubmed_meta; 50, subscript; 50, 51; 50, 52; 51, identifier:pubmed_meta_dict; 52, identifier:pmid; 53, if_statement; 53, 54; 53, 60; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:pubmed_meta; 57, identifier:get; 58, argument_list; 58, 59; 59, string:'doi'; 60, block; 60, 61; 61, return_statement; 61, 62; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:pubmed_meta; 65, identifier:get; 66, argument_list; 66, 67; 67, string:'doi'; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:pm_article_title; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:pubmed_meta; 74, identifier:get; 75, argument_list; 75, 76; 76, string:'title'; 77, if_statement; 77, 78; 77, 81; 78, comparison_operator:is; 78, 79; 78, 80; 79, identifier:pm_article_title; 80, None; 81, block; 81, 82; 81, 91; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:logger; 86, identifier:warning; 87, argument_list; 87, 88; 88, binary_operator:%; 88, 89; 88, 90; 89, string:'No article title found in Pubmed for PMID%s'; 90, identifier:pmid; 91, return_statement; 91, 92; 92, None; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:pm_issn_list; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:pubmed_meta; 99, identifier:get; 100, argument_list; 100, 101; 101, string:'issn_list'; 102, if_statement; 102, 103; 102, 105; 103, not_operator; 103, 104; 104, identifier:pm_issn_list; 105, block; 105, 106; 105, 115; 106, expression_statement; 106, 107; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:logger; 110, identifier:warning; 111, argument_list; 111, 112; 112, binary_operator:%; 112, 113; 112, 114; 113, string:'No ISSNs found in Pubmed for PMID%s'; 114, identifier:pmid; 115, return_statement; 115, 116; 116, None; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:pm_page; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:pubmed_meta; 123, identifier:get; 124, argument_list; 124, 125; 125, string:'page'; 126, if_statement; 126, 127; 126, 129; 127, not_operator; 127, 128; 128, identifier:pm_page; 129, block; 129, 130; 129, 139; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:logger; 134, identifier:debug; 135, argument_list; 135, 136; 136, binary_operator:%; 136, 137; 136, 138; 137, string:'No page number found in Pubmed for PMID%s'; 138, identifier:pmid; 139, return_statement; 139, 140; 140, None; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:url; 144, identifier:crossref_search_url; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:params; 148, dictionary; 148, 149; 148, 152; 149, pair; 149, 150; 149, 151; 150, string:'q'; 151, identifier:pm_article_title; 152, pair; 152, 153; 152, 154; 153, string:'sort'; 154, string:'score'; 155, try_statement; 155, 156; 155, 167; 155, 193; 156, block; 156, 157; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:res; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:requests; 163, identifier:get; 164, argument_list; 164, 165; 164, 166; 165, identifier:crossref_search_url; 166, identifier:params; 167, except_clause; 167, 168; 167, 176; 168, as_pattern; 168, 169; 168, 174; 169, attribute; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:requests; 172, identifier:exceptions; 173, identifier:ConnectionError; 174, as_pattern_target; 174, 175; 175, identifier:e; 176, block; 176, 177; 176, 184; 176, 191; 177, expression_statement; 177, 178; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:logger; 181, identifier:error; 182, argument_list; 182, 183; 183, string:'CrossRef service could not be reached.'; 184, expression_statement; 184, 185; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:logger; 188, identifier:error; 189, argument_list; 189, 190; 190, identifier:e; 191, return_statement; 191, 192; 192, None; 193, except_clause; 193, 194; 193, 198; 194, as_pattern; 194, 195; 194, 196; 195, identifier:Exception; 196, as_pattern_target; 196, 197; 197, identifier:e; 198, block; 198, 199; 198, 211; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:logger; 203, identifier:error; 204, argument_list; 204, 205; 205, binary_operator:%; 205, 206; 205, 207; 206, string:'Error accessing CrossRef service: %s'; 207, call; 207, 208; 207, 209; 208, identifier:str; 209, argument_list; 209, 210; 210, identifier:e; 211, return_statement; 211, 212; 212, None; 213, if_statement; 213, 214; 213, 219; 214, comparison_operator:!=; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:res; 217, identifier:status_code; 218, integer:200; 219, block; 219, 220; 219, 233; 220, expression_statement; 220, 221; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:logger; 224, identifier:info; 225, argument_list; 225, 226; 226, binary_operator:%; 226, 227; 226, 228; 227, string:'PMID%s: no search results from CrossRef, code %d'; 228, tuple; 228, 229; 228, 230; 229, identifier:pmid; 230, attribute; 230, 231; 230, 232; 231, identifier:res; 232, identifier:status_code; 233, return_statement; 233, 234; 234, None; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:raw_message; 238, call; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:res; 241, identifier:json; 242, argument_list; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:mapped_doi; 246, None; 247, for_statement; 247, 248; 247, 251; 247, 255; 248, pattern_list; 248, 249; 248, 250; 249, identifier:result_ix; 250, identifier:result; 251, call; 251, 252; 251, 253; 252, identifier:enumerate; 253, argument_list; 253, 254; 254, identifier:raw_message; 255, block; 255, 256; 255, 275; 255, 281; 255, 291; 255, 301; 255, 308; 255, 314; 255, 323; 255, 332; 255, 346; 255, 360; 255, 375; 255, 390; 255, 405; 255, 424; 256, if_statement; 256, 257; 256, 260; 257, comparison_operator:>; 257, 258; 257, 259; 258, identifier:result_ix; 259, identifier:search_limit; 260, block; 260, 261; 260, 274; 261, expression_statement; 261, 262; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:logger; 265, identifier:info; 266, argument_list; 266, 267; 267, binary_operator:%; 267, 268; 267, 271; 268, concatenated_string; 268, 269; 268, 270; 269, string:'PMID%s: No match found within first %s results, '; 270, string:'giving up!'; 271, tuple; 271, 272; 271, 273; 272, identifier:pmid; 273, identifier:search_limit; 274, break_statement; 275, expression_statement; 275, 276; 276, assignment; 276, 277; 276, 278; 277, identifier:xref_doi_url; 278, subscript; 278, 279; 278, 280; 279, identifier:result; 280, string:'doi'; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 284; 283, identifier:m; 284, call; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:re; 287, identifier:match; 288, argument_list; 288, 289; 288, 290; 289, string:'^http://dx.doi.org/(.*)$'; 290, identifier:xref_doi_url; 291, expression_statement; 291, 292; 292, assignment; 292, 293; 292, 294; 293, identifier:xref_doi; 294, subscript; 294, 295; 294, 300; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:m; 298, identifier:groups; 299, argument_list; 300, integer:0; 301, expression_statement; 301, 302; 302, assignment; 302, 303; 302, 304; 303, identifier:xref_meta; 304, call; 304, 305; 304, 306; 305, identifier:get_metadata; 306, argument_list; 306, 307; 307, identifier:xref_doi; 308, if_statement; 308, 309; 308, 312; 309, comparison_operator:is; 309, 310; 309, 311; 310, identifier:xref_meta; 311, None; 312, block; 312, 313; 313, continue_statement; 314, expression_statement; 314, 315; 315, assignment; 315, 316; 315, 317; 316, identifier:xref_issn_list; 317, call; 317, 318; 317, 321; 318, attribute; 318, 319; 318, 320; 319, identifier:xref_meta; 320, identifier:get; 321, argument_list; 321, 322; 322, string:'ISSN'; 323, expression_statement; 323, 324; 324, assignment; 324, 325; 324, 326; 325, identifier:xref_page; 326, call; 326, 327; 326, 330; 327, attribute; 327, 328; 327, 329; 328, identifier:xref_meta; 329, identifier:get; 330, argument_list; 330, 331; 331, string:'page'; 332, if_statement; 332, 333; 332, 335; 333, not_operator; 333, 334; 334, identifier:xref_issn_list; 335, block; 335, 336; 335, 345; 336, expression_statement; 336, 337; 337, call; 337, 338; 337, 341; 338, attribute; 338, 339; 338, 340; 339, identifier:logger; 340, identifier:debug; 341, argument_list; 341, 342; 342, binary_operator:%; 342, 343; 342, 344; 343, string:'No ISSN found for DOI %s, skipping'; 344, identifier:xref_doi_url; 345, continue_statement; 346, if_statement; 346, 347; 346, 349; 347, not_operator; 347, 348; 348, identifier:xref_page; 349, block; 349, 350; 349, 359; 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; 356, binary_operator:%; 356, 357; 356, 358; 357, string:'No page number found for DOI %s, skipping'; 358, identifier:xref_doi_url; 359, continue_statement; 360, expression_statement; 360, 361; 361, assignment; 361, 362; 361, 363; 362, identifier:matching_issns; 363, call; 363, 364; 363, 370; 364, attribute; 364, 365; 364, 369; 365, call; 365, 366; 365, 367; 366, identifier:set; 367, argument_list; 367, 368; 368, identifier:pm_issn_list; 369, identifier:intersection; 370, argument_list; 370, 371; 371, call; 371, 372; 371, 373; 372, identifier:set; 373, argument_list; 373, 374; 374, identifier:xref_issn_list; 375, expression_statement; 375, 376; 376, assignment; 376, 377; 376, 378; 377, identifier:pm_start_page; 378, call; 378, 379; 378, 389; 379, attribute; 379, 380; 379, 388; 380, subscript; 380, 381; 380, 387; 381, call; 381, 382; 381, 385; 382, attribute; 382, 383; 382, 384; 383, identifier:pm_page; 384, identifier:split; 385, argument_list; 385, 386; 386, string:'-'; 387, integer:0; 388, identifier:upper; 389, argument_list; 390, expression_statement; 390, 391; 391, assignment; 391, 392; 391, 393; 392, identifier:xr_start_page; 393, call; 393, 394; 393, 404; 394, attribute; 394, 395; 394, 403; 395, subscript; 395, 396; 395, 402; 396, call; 396, 397; 396, 400; 397, attribute; 397, 398; 397, 399; 398, identifier:xref_page; 399, identifier:split; 400, argument_list; 400, 401; 401, string:'-'; 402, integer:0; 403, identifier:upper; 404, argument_list; 405, if_statement; 405, 406; 405, 412; 406, call; 406, 407; 406, 410; 407, attribute; 407, 408; 407, 409; 408, identifier:xr_start_page; 409, identifier:endswith; 410, argument_list; 410, 411; 411, string:'E'; 412, block; 412, 413; 413, expression_statement; 413, 414; 414, assignment; 414, 415; 414, 416; 415, identifier:xr_start_page; 416, binary_operator:+; 416, 417; 416, 418; 417, string:'E'; 418, subscript; 418, 419; 418, 420; 419, identifier:xr_start_page; 420, slice; 420, 421; 420, 422; 421, colon; 422, unary_operator:-; 422, 423; 423, integer:1; 424, if_statement; 424, 425; 424, 430; 425, boolean_operator:and; 425, 426; 425, 427; 426, identifier:matching_issns; 427, comparison_operator:==; 427, 428; 427, 429; 428, identifier:pm_start_page; 429, identifier:xr_start_page; 430, block; 430, 431; 430, 435; 431, expression_statement; 431, 432; 432, assignment; 432, 433; 432, 434; 433, identifier:mapped_doi; 434, identifier:xref_doi; 435, break_statement; 436, return_statement; 436, 437; 437, identifier:mapped_doi | def doi_query(pmid, search_limit=10):
pubmed_meta_dict = pubmed_client.get_metadata_for_ids([pmid],
get_issns_from_nlm=True)
if pubmed_meta_dict is None or pubmed_meta_dict.get(pmid) is None:
logger.warning('No metadata found in Pubmed for PMID%s' % pmid)
return None
pubmed_meta = pubmed_meta_dict[pmid]
if pubmed_meta.get('doi'):
return pubmed_meta.get('doi')
pm_article_title = pubmed_meta.get('title')
if pm_article_title is None:
logger.warning('No article title found in Pubmed for PMID%s' % pmid)
return None
pm_issn_list = pubmed_meta.get('issn_list')
if not pm_issn_list:
logger.warning('No ISSNs found in Pubmed for PMID%s' % pmid)
return None
pm_page = pubmed_meta.get('page')
if not pm_page:
logger.debug('No page number found in Pubmed for PMID%s' % pmid)
return None
url = crossref_search_url
params = {'q': pm_article_title, 'sort': 'score'}
try:
res = requests.get(crossref_search_url, params)
except requests.exceptions.ConnectionError as e:
logger.error('CrossRef service could not be reached.')
logger.error(e)
return None
except Exception as e:
logger.error('Error accessing CrossRef service: %s' % str(e))
return None
if res.status_code != 200:
logger.info('PMID%s: no search results from CrossRef, code %d' %
(pmid, res.status_code))
return None
raw_message = res.json()
mapped_doi = None
for result_ix, result in enumerate(raw_message):
if result_ix > search_limit:
logger.info('PMID%s: No match found within first %s results, '
'giving up!' % (pmid, search_limit))
break
xref_doi_url = result['doi']
m = re.match('^http://dx.doi.org/(.*)$', xref_doi_url)
xref_doi = m.groups()[0]
xref_meta = get_metadata(xref_doi)
if xref_meta is None:
continue
xref_issn_list = xref_meta.get('ISSN')
xref_page = xref_meta.get('page')
if not xref_issn_list:
logger.debug('No ISSN found for DOI %s, skipping' % xref_doi_url)
continue
if not xref_page:
logger.debug('No page number found for DOI %s, skipping' %
xref_doi_url)
continue
matching_issns = set(pm_issn_list).intersection(set(xref_issn_list))
pm_start_page = pm_page.split('-')[0].upper()
xr_start_page = xref_page.split('-')[0].upper()
if xr_start_page.endswith('E'):
xr_start_page = 'E' + xr_start_page[:-1]
if matching_issns and pm_start_page == xr_start_page:
mapped_doi = xref_doi
break
return mapped_doi |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_agent_rule_str; 3, parameters; 3, 4; 4, identifier:agent; 5, block; 5, 6; 5, 16; 5, 251; 5, 260; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:rule_str_list; 9, list:[_n(agent.name)]; 9, 10; 10, call; 10, 11; 10, 12; 11, identifier:_n; 12, argument_list; 12, 13; 13, attribute; 13, 14; 13, 15; 14, identifier:agent; 15, identifier:name; 16, if_statement; 16, 17; 16, 24; 17, call; 17, 18; 17, 19; 18, identifier:isinstance; 19, argument_list; 19, 20; 19, 21; 20, identifier:agent; 21, attribute; 21, 22; 21, 23; 22, identifier:ist; 23, identifier:Agent; 24, block; 24, 25; 24, 74; 24, 136; 24, 184; 24, 203; 25, for_statement; 25, 26; 25, 27; 25, 30; 26, identifier:mod; 27, attribute; 27, 28; 27, 29; 28, identifier:agent; 29, identifier:mods; 30, block; 30, 31; 30, 39; 30, 52; 30, 65; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:mstr; 34, subscript; 34, 35; 34, 36; 35, identifier:abbrevs; 36, attribute; 36, 37; 36, 38; 37, identifier:mod; 38, identifier:mod_type; 39, if_statement; 39, 40; 39, 45; 40, comparison_operator:is; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:mod; 43, identifier:residue; 44, None; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, augmented_assignment:+=; 47, 48; 47, 49; 48, identifier:mstr; 49, attribute; 49, 50; 49, 51; 50, identifier:mod; 51, identifier:residue; 52, if_statement; 52, 53; 52, 58; 53, comparison_operator:is; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:mod; 56, identifier:position; 57, None; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, augmented_assignment:+=; 60, 61; 60, 62; 61, identifier:mstr; 62, attribute; 62, 63; 62, 64; 63, identifier:mod; 64, identifier:position; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:rule_str_list; 69, identifier:append; 70, argument_list; 70, 71; 71, binary_operator:%; 71, 72; 71, 73; 72, string:'%s'; 73, identifier:mstr; 74, for_statement; 74, 75; 74, 76; 74, 79; 75, identifier:mut; 76, attribute; 76, 77; 76, 78; 77, identifier:agent; 78, identifier:mutations; 79, block; 79, 80; 79, 91; 79, 102; 79, 123; 79, 129; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:res_from; 83, conditional_expression:if; 83, 84; 83, 87; 83, 90; 84, attribute; 84, 85; 84, 86; 85, identifier:mut; 86, identifier:residue_from; 87, attribute; 87, 88; 87, 89; 88, identifier:mut; 89, identifier:residue_from; 90, string:'mut'; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:res_to; 94, conditional_expression:if; 94, 95; 94, 98; 94, 101; 95, attribute; 95, 96; 95, 97; 96, identifier:mut; 97, identifier:residue_to; 98, attribute; 98, 99; 98, 100; 99, identifier:mut; 100, identifier:residue_to; 101, string:'X'; 102, if_statement; 102, 103; 102, 108; 102, 113; 103, comparison_operator:is; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:mut; 106, identifier:position; 107, None; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:mut_site_name; 112, identifier:res_from; 113, else_clause; 113, 114; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:mut_site_name; 118, binary_operator:+; 118, 119; 118, 120; 119, identifier:res_from; 120, attribute; 120, 121; 120, 122; 121, identifier:mut; 122, identifier:position; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:mstr; 126, binary_operator:+; 126, 127; 126, 128; 127, identifier:mut_site_name; 128, identifier:res_to; 129, expression_statement; 129, 130; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:rule_str_list; 133, identifier:append; 134, argument_list; 134, 135; 135, identifier:mstr; 136, if_statement; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:agent; 139, identifier:bound_conditions; 140, block; 140, 141; 141, for_statement; 141, 142; 141, 143; 141, 146; 142, identifier:b; 143, attribute; 143, 144; 143, 145; 144, identifier:agent; 145, identifier:bound_conditions; 146, block; 146, 147; 147, if_statement; 147, 148; 147, 151; 147, 166; 148, attribute; 148, 149; 148, 150; 149, identifier:b; 150, identifier:is_bound; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:rule_str_list; 156, identifier:append; 157, argument_list; 157, 158; 158, call; 158, 159; 158, 160; 159, identifier:_n; 160, argument_list; 160, 161; 161, attribute; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:b; 164, identifier:agent; 165, identifier:name; 166, else_clause; 166, 167; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:rule_str_list; 172, identifier:append; 173, argument_list; 173, 174; 174, binary_operator:+; 174, 175; 174, 176; 175, string:'n'; 176, call; 176, 177; 176, 178; 177, identifier:_n; 178, argument_list; 178, 179; 179, attribute; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:b; 182, identifier:agent; 183, identifier:name; 184, if_statement; 184, 185; 184, 190; 185, comparison_operator:is; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:agent; 188, identifier:location; 189, None; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:rule_str_list; 195, identifier:append; 196, argument_list; 196, 197; 197, call; 197, 198; 197, 199; 198, identifier:_n; 199, argument_list; 199, 200; 200, attribute; 200, 201; 200, 202; 201, identifier:agent; 202, identifier:location; 203, if_statement; 203, 204; 203, 209; 204, comparison_operator:is; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:agent; 207, identifier:activity; 208, None; 209, block; 209, 210; 210, if_statement; 210, 211; 210, 216; 210, 232; 211, attribute; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:agent; 214, identifier:activity; 215, identifier:is_active; 216, block; 216, 217; 217, expression_statement; 217, 218; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:rule_str_list; 221, identifier:append; 222, argument_list; 222, 223; 223, subscript; 223, 224; 223, 229; 224, attribute; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:agent; 227, identifier:activity; 228, identifier:activity_type; 229, slice; 229, 230; 229, 231; 230, colon; 231, integer:3; 232, else_clause; 232, 233; 233, block; 233, 234; 234, expression_statement; 234, 235; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:rule_str_list; 238, identifier:append; 239, argument_list; 239, 240; 240, binary_operator:+; 240, 241; 240, 250; 241, subscript; 241, 242; 241, 247; 242, attribute; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:agent; 245, identifier:activity; 246, identifier:activity_type; 247, slice; 247, 248; 247, 249; 248, colon; 249, integer:3; 250, string:'_inact'; 251, expression_statement; 251, 252; 252, assignment; 252, 253; 252, 254; 253, identifier:rule_str; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, string:'_'; 257, identifier:join; 258, argument_list; 258, 259; 259, identifier:rule_str_list; 260, return_statement; 260, 261; 261, identifier:rule_str | def get_agent_rule_str(agent):
rule_str_list = [_n(agent.name)]
if isinstance(agent, ist.Agent):
for mod in agent.mods:
mstr = abbrevs[mod.mod_type]
if mod.residue is not None:
mstr += mod.residue
if mod.position is not None:
mstr += mod.position
rule_str_list.append('%s' % mstr)
for mut in agent.mutations:
res_from = mut.residue_from if mut.residue_from else 'mut'
res_to = mut.residue_to if mut.residue_to else 'X'
if mut.position is None:
mut_site_name = res_from
else:
mut_site_name = res_from + mut.position
mstr = mut_site_name + res_to
rule_str_list.append(mstr)
if agent.bound_conditions:
for b in agent.bound_conditions:
if b.is_bound:
rule_str_list.append(_n(b.agent.name))
else:
rule_str_list.append('n' + _n(b.agent.name))
if agent.location is not None:
rule_str_list.append(_n(agent.location))
if agent.activity is not None:
if agent.activity.is_active:
rule_str_list.append(agent.activity.activity_type[:3])
else:
rule_str_list.append(agent.activity.activity_type[:3] + '_inact')
rule_str = '_'.join(rule_str_list)
return rule_str |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:grounded_monomer_patterns; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:model; 5, identifier:agent; 6, default_parameter; 6, 7; 6, 8; 7, identifier:ignore_activities; 8, False; 9, block; 9, 10; 9, 43; 9, 47; 9, 126; 9, 141; 9, 145; 9, 347; 9, 406; 9, 441; 10, if_statement; 10, 11; 10, 19; 11, not_operator; 11, 12; 12, call; 12, 13; 12, 14; 13, identifier:isinstance; 14, argument_list; 14, 15; 14, 16; 15, identifier:agent; 16, attribute; 16, 17; 16, 18; 17, identifier:ist; 18, identifier:Agent; 19, block; 19, 20; 19, 33; 19, 38; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:monomer; 23, call; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:model; 27, identifier:monomers; 28, identifier:get; 29, argument_list; 29, 30; 30, attribute; 30, 31; 30, 32; 31, identifier:agent; 32, identifier:name; 33, if_statement; 33, 34; 33, 36; 34, not_operator; 34, 35; 35, identifier:monomer; 36, block; 36, 37; 37, return_statement; 38, expression_statement; 38, 39; 39, yield; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:monomer; 42, argument_list; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:monomer; 46, None; 47, for_statement; 47, 48; 47, 49; 47, 52; 48, identifier:ann; 49, attribute; 49, 50; 49, 51; 50, identifier:model; 51, identifier:annotations; 52, block; 52, 53; 52, 57; 52, 66; 52, 77; 52, 88; 52, 98; 53, if_statement; 53, 54; 53, 55; 54, identifier:monomer; 55, block; 55, 56; 56, break_statement; 57, if_statement; 57, 58; 57, 64; 58, not_operator; 58, 59; 59, comparison_operator:==; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:ann; 62, identifier:predicate; 63, string:'is'; 64, block; 64, 65; 65, continue_statement; 66, if_statement; 66, 67; 66, 75; 67, not_operator; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:isinstance; 70, argument_list; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:ann; 73, identifier:subject; 74, identifier:Monomer; 75, block; 75, 76; 76, continue_statement; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 82; 79, tuple_pattern; 79, 80; 79, 81; 80, identifier:ns; 81, identifier:id; 82, call; 82, 83; 82, 84; 83, identifier:parse_identifiers_url; 84, argument_list; 84, 85; 85, attribute; 85, 86; 85, 87; 86, identifier:ann; 87, identifier:object; 88, if_statement; 88, 89; 88, 96; 89, boolean_operator:and; 89, 90; 89, 93; 90, comparison_operator:is; 90, 91; 90, 92; 91, identifier:ns; 92, None; 93, comparison_operator:is; 93, 94; 93, 95; 94, identifier:id; 95, None; 96, block; 96, 97; 97, continue_statement; 98, for_statement; 98, 99; 98, 102; 98, 109; 99, pattern_list; 99, 100; 99, 101; 100, identifier:db_ns; 101, identifier:db_id; 102, call; 102, 103; 102, 108; 103, attribute; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:agent; 106, identifier:db_refs; 107, identifier:items; 108, argument_list; 109, block; 109, 110; 110, if_statement; 110, 111; 110, 118; 111, boolean_operator:and; 111, 112; 111, 115; 112, comparison_operator:==; 112, 113; 112, 114; 113, identifier:db_ns; 114, identifier:ns; 115, comparison_operator:==; 115, 116; 115, 117; 116, identifier:db_id; 117, identifier:id; 118, block; 118, 119; 118, 125; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:monomer; 122, attribute; 122, 123; 122, 124; 123, identifier:ann; 124, identifier:subject; 125, break_statement; 126, if_statement; 126, 127; 126, 130; 127, comparison_operator:is; 127, 128; 127, 129; 128, identifier:monomer; 129, None; 130, block; 130, 131; 130, 140; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:logger; 135, identifier:info; 136, argument_list; 136, 137; 137, binary_operator:%; 137, 138; 137, 139; 138, string:'No monomer found corresponding to agent %s'; 139, identifier:agent; 140, return_statement; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:sc_list; 144, list:[]; 145, for_statement; 145, 146; 145, 147; 145, 150; 146, identifier:mod; 147, attribute; 147, 148; 147, 149; 148, identifier:agent; 149, identifier:mods; 150, block; 150, 151; 150, 155; 150, 162; 150, 169; 150, 270; 150, 281; 150, 297; 150, 313; 150, 318; 150, 322; 150, 340; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:mod_sites; 154, dictionary; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:res_sites; 158, call; 158, 159; 158, 160; 159, identifier:set; 160, argument_list; 160, 161; 161, list:[]; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:pos_sites; 165, call; 165, 166; 165, 167; 166, identifier:set; 167, argument_list; 167, 168; 168, list:[]; 169, for_statement; 169, 170; 169, 171; 169, 174; 170, identifier:ann; 171, attribute; 171, 172; 171, 173; 172, identifier:monomer; 173, identifier:site_annotations; 174, block; 174, 175; 175, if_statement; 175, 176; 175, 190; 175, 220; 175, 245; 176, boolean_operator:and; 176, 177; 176, 182; 176, 183; 177, comparison_operator:==; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:ann; 180, identifier:predicate; 181, string:'is_modification'; 182, line_continuation:\; 183, comparison_operator:==; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:ann; 186, identifier:object; 187, attribute; 187, 188; 187, 189; 188, identifier:mod; 189, identifier:mod_type; 190, block; 190, 191; 190, 197; 190, 203; 190, 210; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:site_state; 194, attribute; 194, 195; 194, 196; 195, identifier:ann; 196, identifier:subject; 197, assert_statement; 197, 198; 198, call; 198, 199; 198, 200; 199, identifier:isinstance; 200, argument_list; 200, 201; 200, 202; 201, identifier:site_state; 202, identifier:tuple; 203, assert_statement; 203, 204; 204, comparison_operator:==; 204, 205; 204, 209; 205, call; 205, 206; 205, 207; 206, identifier:len; 207, argument_list; 207, 208; 208, identifier:site_state; 209, integer:2; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 217; 212, subscript; 212, 213; 212, 214; 213, identifier:mod_sites; 214, subscript; 214, 215; 214, 216; 215, identifier:site_state; 216, integer:0; 217, subscript; 217, 218; 217, 219; 218, identifier:site_state; 219, integer:1; 220, elif_clause; 220, 221; 220, 235; 221, boolean_operator:and; 221, 222; 221, 227; 221, 228; 222, comparison_operator:==; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:ann; 225, identifier:predicate; 226, string:'is_residue'; 227, line_continuation:\; 228, comparison_operator:==; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:ann; 231, identifier:object; 232, attribute; 232, 233; 232, 234; 233, identifier:mod; 234, identifier:residue; 235, block; 235, 236; 236, expression_statement; 236, 237; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:res_sites; 240, identifier:add; 241, argument_list; 241, 242; 242, attribute; 242, 243; 242, 244; 243, identifier:ann; 244, identifier:subject; 245, elif_clause; 245, 246; 245, 260; 246, boolean_operator:and; 246, 247; 246, 252; 246, 253; 247, comparison_operator:==; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:ann; 250, identifier:predicate; 251, string:'is_position'; 252, line_continuation:\; 253, comparison_operator:==; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:ann; 256, identifier:object; 257, attribute; 257, 258; 257, 259; 258, identifier:mod; 259, identifier:position; 260, block; 260, 261; 261, expression_statement; 261, 262; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:pos_sites; 265, identifier:add; 266, argument_list; 266, 267; 267, attribute; 267, 268; 267, 269; 268, identifier:ann; 269, identifier:subject; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 273; 272, identifier:viable_sites; 273, call; 273, 274; 273, 275; 274, identifier:set; 275, argument_list; 275, 276; 276, call; 276, 277; 276, 280; 277, attribute; 277, 278; 277, 279; 278, identifier:mod_sites; 279, identifier:keys; 280, argument_list; 281, if_statement; 281, 282; 281, 287; 282, comparison_operator:is; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:mod; 285, identifier:residue; 286, None; 287, block; 287, 288; 288, expression_statement; 288, 289; 289, assignment; 289, 290; 289, 291; 290, identifier:viable_sites; 291, call; 291, 292; 291, 295; 292, attribute; 292, 293; 292, 294; 293, identifier:viable_sites; 294, identifier:intersection; 295, argument_list; 295, 296; 296, identifier:res_sites; 297, if_statement; 297, 298; 297, 303; 298, comparison_operator:is; 298, 299; 298, 302; 299, attribute; 299, 300; 299, 301; 300, identifier:mod; 301, identifier:position; 302, None; 303, block; 303, 304; 304, expression_statement; 304, 305; 305, assignment; 305, 306; 305, 307; 306, identifier:viable_sites; 307, call; 307, 308; 307, 311; 308, attribute; 308, 309; 308, 310; 309, identifier:viable_sites; 310, identifier:intersection; 311, argument_list; 311, 312; 312, identifier:pos_sites; 313, if_statement; 313, 314; 313, 316; 314, not_operator; 314, 315; 315, identifier:viable_sites; 316, block; 316, 317; 317, return_statement; 318, expression_statement; 318, 319; 319, assignment; 319, 320; 319, 321; 320, identifier:pattern_list; 321, list:[]; 322, for_statement; 322, 323; 322, 324; 322, 325; 323, identifier:site_name; 324, identifier:viable_sites; 325, block; 325, 326; 326, expression_statement; 326, 327; 327, call; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:pattern_list; 330, identifier:append; 331, argument_list; 331, 332; 332, dictionary; 332, 333; 333, pair; 333, 334; 333, 335; 334, identifier:site_name; 335, tuple; 335, 336; 335, 339; 336, subscript; 336, 337; 336, 338; 337, identifier:mod_sites; 338, identifier:site_name; 339, identifier:WILD; 340, expression_statement; 340, 341; 341, call; 341, 342; 341, 345; 342, attribute; 342, 343; 342, 344; 343, identifier:sc_list; 344, identifier:append; 345, argument_list; 345, 346; 346, identifier:pattern_list; 347, if_statement; 347, 348; 347, 354; 348, boolean_operator:and; 348, 349; 348, 352; 349, attribute; 349, 350; 349, 351; 350, identifier:agent; 351, identifier:activity; 352, not_operator; 352, 353; 353, identifier:ignore_activities; 354, block; 354, 355; 354, 367; 354, 371; 354, 399; 355, expression_statement; 355, 356; 356, assignment; 356, 357; 356, 358; 357, identifier:rel_type; 358, conditional_expression:if; 358, 359; 358, 360; 358, 365; 358, 366; 359, string:'has_active_pattern'; 360, attribute; 360, 361; 360, 364; 361, attribute; 361, 362; 361, 363; 362, identifier:agent; 363, identifier:activity; 364, identifier:is_active; 365, line_continuation:\; 366, string:'has_inactive_pattern'; 367, expression_statement; 367, 368; 368, assignment; 368, 369; 368, 370; 369, identifier:active_form_list; 370, list:[]; 371, for_statement; 371, 372; 371, 373; 371, 376; 372, identifier:ann; 373, attribute; 373, 374; 373, 375; 374, identifier:model; 375, identifier:annotations; 376, block; 376, 377; 377, if_statement; 377, 378; 377, 389; 378, boolean_operator:and; 378, 379; 378, 384; 379, comparison_operator:==; 379, 380; 379, 383; 380, attribute; 380, 381; 380, 382; 381, identifier:ann; 382, identifier:subject; 383, identifier:monomer; 384, comparison_operator:==; 384, 385; 384, 388; 385, attribute; 385, 386; 385, 387; 386, identifier:ann; 387, identifier:predicate; 388, identifier:rel_type; 389, block; 389, 390; 390, expression_statement; 390, 391; 391, call; 391, 392; 391, 395; 392, attribute; 392, 393; 392, 394; 393, identifier:active_form_list; 394, identifier:append; 395, argument_list; 395, 396; 396, attribute; 396, 397; 396, 398; 397, identifier:ann; 398, identifier:object; 399, expression_statement; 399, 400; 400, call; 400, 401; 400, 404; 401, attribute; 401, 402; 401, 403; 402, identifier:sc_list; 403, identifier:append; 404, argument_list; 404, 405; 405, identifier:active_form_list; 406, for_statement; 406, 407; 406, 408; 406, 415; 407, identifier:pattern_combo; 408, call; 408, 409; 408, 412; 409, attribute; 409, 410; 409, 411; 410, identifier:itertools; 411, identifier:product; 412, argument_list; 412, 413; 413, list_splat; 413, 414; 414, identifier:sc_list; 415, block; 415, 416; 415, 420; 415, 431; 416, expression_statement; 416, 417; 417, assignment; 417, 418; 417, 419; 418, identifier:mp_sc; 419, dictionary; 420, for_statement; 420, 421; 420, 422; 420, 423; 421, identifier:pattern; 422, identifier:pattern_combo; 423, block; 423, 424; 424, expression_statement; 424, 425; 425, call; 425, 426; 425, 429; 426, attribute; 426, 427; 426, 428; 427, identifier:mp_sc; 428, identifier:update; 429, argument_list; 429, 430; 430, identifier:pattern; 431, if_statement; 431, 432; 431, 433; 432, identifier:mp_sc; 433, block; 433, 434; 434, expression_statement; 434, 435; 435, yield; 435, 436; 436, call; 436, 437; 436, 438; 437, identifier:monomer; 438, argument_list; 438, 439; 439, dictionary_splat; 439, 440; 440, identifier:mp_sc; 441, if_statement; 441, 442; 441, 444; 442, not_operator; 442, 443; 443, identifier:sc_list; 444, block; 444, 445; 445, expression_statement; 445, 446; 446, yield; 446, 447; 447, call; 447, 448; 447, 449; 448, identifier:monomer; 449, argument_list | def grounded_monomer_patterns(model, agent, ignore_activities=False):
if not isinstance(agent, ist.Agent):
monomer = model.monomers.get(agent.name)
if not monomer:
return
yield monomer()
monomer = None
for ann in model.annotations:
if monomer:
break
if not ann.predicate == 'is':
continue
if not isinstance(ann.subject, Monomer):
continue
(ns, id) = parse_identifiers_url(ann.object)
if ns is None and id is None:
continue
for db_ns, db_id in agent.db_refs.items():
if db_ns == ns and db_id == id:
monomer = ann.subject
break
if monomer is None:
logger.info('No monomer found corresponding to agent %s' % agent)
return
sc_list = []
for mod in agent.mods:
mod_sites = {}
res_sites = set([])
pos_sites = set([])
for ann in monomer.site_annotations:
if ann.predicate == 'is_modification' and \
ann.object == mod.mod_type:
site_state = ann.subject
assert isinstance(site_state, tuple)
assert len(site_state) == 2
mod_sites[site_state[0]] = site_state[1]
elif ann.predicate == 'is_residue' and \
ann.object == mod.residue:
res_sites.add(ann.subject)
elif ann.predicate == 'is_position' and \
ann.object == mod.position:
pos_sites.add(ann.subject)
viable_sites = set(mod_sites.keys())
if mod.residue is not None:
viable_sites = viable_sites.intersection(res_sites)
if mod.position is not None:
viable_sites = viable_sites.intersection(pos_sites)
if not viable_sites:
return
pattern_list = []
for site_name in viable_sites:
pattern_list.append({site_name: (mod_sites[site_name], WILD)})
sc_list.append(pattern_list)
if agent.activity and not ignore_activities:
rel_type = 'has_active_pattern' if agent.activity.is_active \
else 'has_inactive_pattern'
active_form_list = []
for ann in model.annotations:
if ann.subject == monomer and ann.predicate == rel_type:
active_form_list.append(ann.object)
sc_list.append(active_form_list)
for pattern_combo in itertools.product(*sc_list):
mp_sc = {}
for pattern in pattern_combo:
mp_sc.update(pattern)
if mp_sc:
yield monomer(**mp_sc)
if not sc_list:
yield monomer() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_site_pattern; 3, parameters; 3, 4; 4, identifier:agent; 5, block; 5, 6; 5, 18; 5, 22; 5, 57; 5, 141; 5, 196; 5, 214; 5, 252; 6, if_statement; 6, 7; 6, 15; 7, not_operator; 7, 8; 8, call; 8, 9; 8, 10; 9, identifier:isinstance; 10, argument_list; 10, 11; 10, 12; 11, identifier:agent; 12, attribute; 12, 13; 12, 14; 13, identifier:ist; 14, identifier:Agent; 15, block; 15, 16; 16, return_statement; 16, 17; 17, dictionary; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:pattern; 21, dictionary; 22, for_statement; 22, 23; 22, 24; 22, 27; 23, identifier:bc; 24, attribute; 24, 25; 24, 26; 25, identifier:agent; 26, identifier:bound_conditions; 27, block; 27, 28; 28, if_statement; 28, 29; 28, 32; 28, 44; 29, attribute; 29, 30; 29, 31; 30, identifier:bc; 31, identifier:is_bound; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 43; 35, subscript; 35, 36; 35, 37; 36, identifier:pattern; 37, call; 37, 38; 37, 39; 38, identifier:get_binding_site_name; 39, argument_list; 39, 40; 40, attribute; 40, 41; 40, 42; 41, identifier:bc; 42, identifier:agent; 43, identifier:ANY; 44, else_clause; 44, 45; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 56; 48, subscript; 48, 49; 48, 50; 49, identifier:pattern; 50, call; 50, 51; 50, 52; 51, identifier:get_binding_site_name; 52, argument_list; 52, 53; 53, attribute; 53, 54; 53, 55; 54, identifier:bc; 55, identifier:agent; 56, None; 57, for_statement; 57, 58; 57, 59; 57, 62; 58, identifier:mod; 59, attribute; 59, 60; 59, 61; 60, identifier:agent; 61, identifier:mods; 62, block; 62, 63; 62, 71; 62, 84; 62, 97; 62, 106; 62, 114; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:mod_site_str; 66, subscript; 66, 67; 66, 68; 67, identifier:abbrevs; 68, attribute; 68, 69; 68, 70; 69, identifier:mod; 70, identifier:mod_type; 71, if_statement; 71, 72; 71, 77; 72, comparison_operator:is; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:mod; 75, identifier:residue; 76, None; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:mod_site_str; 81, attribute; 81, 82; 81, 83; 82, identifier:mod; 83, identifier:residue; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:mod_pos_str; 87, conditional_expression:if; 87, 88; 87, 91; 87, 96; 88, attribute; 88, 89; 88, 90; 89, identifier:mod; 90, identifier:position; 91, comparison_operator:is; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:mod; 94, identifier:position; 95, None; 96, string:''; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:mod_site; 100, parenthesized_expression; 100, 101; 101, binary_operator:%; 101, 102; 101, 103; 102, string:'%s%s'; 103, tuple; 103, 104; 103, 105; 104, identifier:mod_site_str; 105, identifier:mod_pos_str; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:site_states; 109, subscript; 109, 110; 109, 111; 110, identifier:states; 111, attribute; 111, 112; 111, 113; 112, identifier:mod; 113, identifier:mod_type; 114, if_statement; 114, 115; 114, 118; 114, 129; 115, attribute; 115, 116; 115, 117; 116, identifier:mod; 117, identifier:is_modified; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 124; 121, subscript; 121, 122; 121, 123; 122, identifier:pattern; 123, identifier:mod_site; 124, tuple; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:site_states; 127, integer:1; 128, identifier:WILD; 129, else_clause; 129, 130; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 136; 133, subscript; 133, 134; 133, 135; 134, identifier:pattern; 135, identifier:mod_site; 136, tuple; 136, 137; 136, 140; 137, subscript; 137, 138; 137, 139; 138, identifier:site_states; 139, integer:0; 140, identifier:WILD; 141, for_statement; 141, 142; 141, 143; 141, 146; 142, identifier:mc; 143, attribute; 143, 144; 143, 145; 144, identifier:agent; 145, identifier:mutations; 146, block; 146, 147; 146, 158; 146, 169; 146, 190; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:res_from; 150, conditional_expression:if; 150, 151; 150, 154; 150, 157; 151, attribute; 151, 152; 151, 153; 152, identifier:mc; 153, identifier:residue_from; 154, attribute; 154, 155; 154, 156; 155, identifier:mc; 156, identifier:residue_from; 157, string:'mut'; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:res_to; 161, conditional_expression:if; 161, 162; 161, 165; 161, 168; 162, attribute; 162, 163; 162, 164; 163, identifier:mc; 164, identifier:residue_to; 165, attribute; 165, 166; 165, 167; 166, identifier:mc; 167, identifier:residue_to; 168, string:'X'; 169, if_statement; 169, 170; 169, 175; 169, 180; 170, comparison_operator:is; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:mc; 173, identifier:position; 174, None; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:mut_site_name; 179, identifier:res_from; 180, else_clause; 180, 181; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:mut_site_name; 185, binary_operator:+; 185, 186; 185, 187; 186, identifier:res_from; 187, attribute; 187, 188; 187, 189; 188, identifier:mc; 189, identifier:position; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 195; 192, subscript; 192, 193; 192, 194; 193, identifier:pattern; 194, identifier:mut_site_name; 195, identifier:res_to; 196, if_statement; 196, 197; 196, 202; 197, comparison_operator:is; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:agent; 200, identifier:location; 201, None; 202, block; 202, 203; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 208; 205, subscript; 205, 206; 205, 207; 206, identifier:pattern; 207, string:'loc'; 208, call; 208, 209; 208, 210; 209, identifier:_n; 210, argument_list; 210, 211; 211, attribute; 211, 212; 211, 213; 212, identifier:agent; 213, identifier:location; 214, if_statement; 214, 215; 214, 220; 215, comparison_operator:is; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:agent; 218, identifier:activity; 219, None; 220, block; 220, 221; 220, 229; 220, 246; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:active_site_name; 224, attribute; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:agent; 227, identifier:activity; 228, identifier:activity_type; 229, if_statement; 229, 230; 229, 235; 229, 240; 230, attribute; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:agent; 233, identifier:activity; 234, identifier:is_active; 235, block; 235, 236; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:active_site_state; 239, string:'active'; 240, else_clause; 240, 241; 241, block; 241, 242; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:active_site_state; 245, string:'inactive'; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 251; 248, subscript; 248, 249; 248, 250; 249, identifier:pattern; 250, identifier:active_site_name; 251, identifier:active_site_state; 252, return_statement; 252, 253; 253, identifier:pattern | def get_site_pattern(agent):
if not isinstance(agent, ist.Agent):
return {}
pattern = {}
for bc in agent.bound_conditions:
if bc.is_bound:
pattern[get_binding_site_name(bc.agent)] = ANY
else:
pattern[get_binding_site_name(bc.agent)] = None
for mod in agent.mods:
mod_site_str = abbrevs[mod.mod_type]
if mod.residue is not None:
mod_site_str = mod.residue
mod_pos_str = mod.position if mod.position is not None else ''
mod_site = ('%s%s' % (mod_site_str, mod_pos_str))
site_states = states[mod.mod_type]
if mod.is_modified:
pattern[mod_site] = (site_states[1], WILD)
else:
pattern[mod_site] = (site_states[0], WILD)
for mc in agent.mutations:
res_from = mc.residue_from if mc.residue_from else 'mut'
res_to = mc.residue_to if mc.residue_to else 'X'
if mc.position is None:
mut_site_name = res_from
else:
mut_site_name = res_from + mc.position
pattern[mut_site_name] = res_to
if agent.location is not None:
pattern['loc'] = _n(agent.location)
if agent.activity is not None:
active_site_name = agent.activity.activity_type
if agent.activity.is_active:
active_site_state = 'active'
else:
active_site_state = 'inactive'
pattern[active_site_name] = active_site_state
return pattern |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:make_model; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:policies; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:initial_conditions; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:reverse_effects; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:model_name; 16, string:'indra_model'; 17, block; 17, 18; 17, 27; 17, 38; 17, 44; 17, 53; 17, 61; 17, 69; 17, 77; 17, 85; 17, 91; 17, 259; 17, 265; 17, 274; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:ppa; 21, call; 21, 22; 21, 23; 22, identifier:PysbPreassembler; 23, argument_list; 23, 24; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:statements; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:processed_policies; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:process_policies; 36, argument_list; 36, 37; 37, identifier:policies; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:ppa; 42, identifier:replace_activities; 43, argument_list; 44, if_statement; 44, 45; 44, 46; 45, identifier:reverse_effects; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:ppa; 51, identifier:add_reverse_effects; 52, argument_list; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:statements; 58, attribute; 58, 59; 58, 60; 59, identifier:ppa; 60, identifier:statements; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:model; 66, call; 66, 67; 66, 68; 67, identifier:Model; 68, argument_list; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 76; 71, attribute; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:model; 75, identifier:name; 76, identifier:model_name; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:agent_set; 82, call; 82, 83; 82, 84; 83, identifier:BaseAgentSet; 84, argument_list; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:_monomers; 90, argument_list; 91, for_statement; 91, 92; 91, 95; 91, 102; 92, pattern_list; 92, 93; 92, 94; 93, identifier:agent_name; 94, identifier:agent; 95, call; 95, 96; 95, 101; 96, attribute; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:agent_set; 100, identifier:items; 101, argument_list; 102, block; 102, 103; 102, 119; 102, 127; 102, 136; 102, 171; 102, 191; 102, 211; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:m; 106, call; 106, 107; 106, 108; 107, identifier:Monomer; 108, argument_list; 108, 109; 108, 113; 108, 116; 109, call; 109, 110; 109, 111; 110, identifier:_n; 111, argument_list; 111, 112; 112, identifier:agent_name; 113, attribute; 113, 114; 113, 115; 114, identifier:agent; 115, identifier:sites; 116, attribute; 116, 117; 116, 118; 117, identifier:agent; 118, identifier:site_states; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:m; 123, identifier:site_annotations; 124, attribute; 124, 125; 124, 126; 125, identifier:agent; 126, identifier:site_annotations; 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:self; 132, identifier:model; 133, identifier:add_component; 134, argument_list; 134, 135; 135, identifier:m; 136, for_statement; 136, 137; 136, 140; 136, 147; 137, pattern_list; 137, 138; 137, 139; 138, identifier:db_name; 139, identifier:db_ref; 140, call; 140, 141; 140, 146; 141, attribute; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:agent; 144, identifier:db_refs; 145, identifier:items; 146, argument_list; 147, block; 147, 148; 147, 157; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:a; 151, call; 151, 152; 151, 153; 152, identifier:get_annotation; 153, argument_list; 153, 154; 153, 155; 153, 156; 154, identifier:m; 155, identifier:db_name; 156, identifier:db_ref; 157, if_statement; 157, 158; 157, 161; 158, comparison_operator:is; 158, 159; 158, 160; 159, identifier:a; 160, None; 161, block; 161, 162; 162, expression_statement; 162, 163; 163, call; 163, 164; 163, 169; 164, attribute; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:model; 168, identifier:add_annotation; 169, argument_list; 169, 170; 170, identifier:a; 171, for_statement; 171, 172; 171, 173; 171, 176; 172, identifier:af; 173, attribute; 173, 174; 173, 175; 174, identifier:agent; 175, identifier:active_forms; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, call; 178, 179; 178, 184; 179, attribute; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:model; 183, identifier:add_annotation; 184, argument_list; 184, 185; 185, call; 185, 186; 185, 187; 186, identifier:Annotation; 187, argument_list; 187, 188; 187, 189; 187, 190; 188, identifier:m; 189, identifier:af; 190, string:'has_active_pattern'; 191, for_statement; 191, 192; 191, 193; 191, 196; 192, identifier:iaf; 193, attribute; 193, 194; 193, 195; 194, identifier:agent; 195, identifier:inactive_forms; 196, block; 196, 197; 197, expression_statement; 197, 198; 198, call; 198, 199; 198, 204; 199, attribute; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:self; 202, identifier:model; 203, identifier:add_annotation; 204, argument_list; 204, 205; 205, call; 205, 206; 205, 207; 206, identifier:Annotation; 207, argument_list; 207, 208; 207, 209; 207, 210; 208, identifier:m; 209, identifier:iaf; 210, string:'has_inactive_pattern'; 211, for_statement; 211, 212; 211, 213; 211, 216; 212, identifier:at; 213, attribute; 213, 214; 213, 215; 214, identifier:agent; 215, identifier:activity_types; 216, block; 216, 217; 216, 224; 216, 238; 216, 245; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:act_site_cond; 220, dictionary; 220, 221; 221, pair; 221, 222; 221, 223; 222, identifier:at; 223, string:'active'; 224, expression_statement; 224, 225; 225, call; 225, 226; 225, 231; 226, attribute; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:self; 229, identifier:model; 230, identifier:add_annotation; 231, argument_list; 231, 232; 232, call; 232, 233; 232, 234; 233, identifier:Annotation; 234, argument_list; 234, 235; 234, 236; 234, 237; 235, identifier:m; 236, identifier:act_site_cond; 237, string:'has_active_pattern'; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:inact_site_cond; 241, dictionary; 241, 242; 242, pair; 242, 243; 242, 244; 243, identifier:at; 244, string:'inactive'; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 252; 247, attribute; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:self; 250, identifier:model; 251, identifier:add_annotation; 252, argument_list; 252, 253; 253, call; 253, 254; 253, 255; 254, identifier:Annotation; 255, argument_list; 255, 256; 255, 257; 255, 258; 256, identifier:m; 257, identifier:inact_site_cond; 258, string:'has_inactive_pattern'; 259, expression_statement; 259, 260; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:self; 263, identifier:_assemble; 264, argument_list; 265, if_statement; 265, 266; 265, 267; 266, identifier:initial_conditions; 267, block; 267, 268; 268, expression_statement; 268, 269; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:self; 272, identifier:add_default_initial_conditions; 273, argument_list; 274, return_statement; 274, 275; 275, attribute; 275, 276; 275, 277; 276, identifier:self; 277, identifier:model | def make_model(self, policies=None, initial_conditions=True,
reverse_effects=False, model_name='indra_model'):
ppa = PysbPreassembler(self.statements)
self.processed_policies = self.process_policies(policies)
ppa.replace_activities()
if reverse_effects:
ppa.add_reverse_effects()
self.statements = ppa.statements
self.model = Model()
self.model.name = model_name
self.agent_set = BaseAgentSet()
self._monomers()
for agent_name, agent in self.agent_set.items():
m = Monomer(_n(agent_name), agent.sites, agent.site_states)
m.site_annotations = agent.site_annotations
self.model.add_component(m)
for db_name, db_ref in agent.db_refs.items():
a = get_annotation(m, db_name, db_ref)
if a is not None:
self.model.add_annotation(a)
for af in agent.active_forms:
self.model.add_annotation(Annotation(m, af,
'has_active_pattern'))
for iaf in agent.inactive_forms:
self.model.add_annotation(Annotation(m, iaf,
'has_inactive_pattern'))
for at in agent.activity_types:
act_site_cond = {at: 'active'}
self.model.add_annotation(Annotation(m, act_site_cond,
'has_active_pattern'))
inact_site_cond = {at: 'inactive'}
self.model.add_annotation(Annotation(m, inact_site_cond,
'has_inactive_pattern'))
self._assemble()
if initial_conditions:
self.add_default_initial_conditions()
return self.model |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_modifications; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 10; 5, 21; 5, 27; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:qstr; 9, string:"$.events.frames[(@.type is 'protein-modification')]"; 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, if_statement; 21, 22; 21, 25; 22, comparison_operator:is; 22, 23; 22, 24; 23, identifier:res; 24, None; 25, block; 25, 26; 26, return_statement; 27, for_statement; 27, 28; 27, 29; 27, 30; 28, identifier:r; 29, identifier:res; 30, block; 30, 31; 30, 40; 30, 49; 30, 58; 30, 69; 30, 75; 30, 81; 30, 85; 30, 89; 30, 125; 30, 136; 30, 159; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:modification_type; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:r; 37, identifier:get; 38, argument_list; 38, 39; 39, string:'subtype'; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:epistemics; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:_get_epistemics; 47, argument_list; 47, 48; 48, identifier:r; 49, if_statement; 49, 50; 49, 56; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:epistemics; 53, identifier:get; 54, argument_list; 54, 55; 55, string:'negated'; 56, block; 56, 57; 57, continue_statement; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 63; 60, pattern_list; 60, 61; 60, 62; 61, identifier:annotations; 62, identifier:context; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:_get_annot_context; 67, argument_list; 67, 68; 68, identifier:r; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:frame_id; 72, subscript; 72, 73; 72, 74; 73, identifier:r; 74, string:'frame_id'; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:args; 78, subscript; 78, 79; 78, 80; 79, identifier:r; 80, string:'arguments'; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:site; 84, None; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:theme; 88, None; 89, for_statement; 89, 90; 89, 91; 89, 92; 90, identifier:a; 91, identifier:args; 92, block; 92, 93; 93, if_statement; 93, 94; 93, 102; 93, 109; 94, comparison_operator:==; 94, 95; 94, 101; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:_get_arg_type; 99, argument_list; 99, 100; 100, identifier:a; 101, string:'theme'; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:theme; 106, subscript; 106, 107; 106, 108; 107, identifier:a; 108, string:'arg'; 109, elif_clause; 109, 110; 109, 118; 110, comparison_operator:==; 110, 111; 110, 117; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:_get_arg_type; 115, argument_list; 115, 116; 116, identifier:a; 117, string:'site'; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:site; 122, subscript; 122, 123; 122, 124; 123, identifier:a; 124, string:'text'; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 130; 127, pattern_list; 127, 128; 127, 129; 128, identifier:theme_agent; 129, identifier:theme_coords; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:_get_agent_from_entity; 134, argument_list; 134, 135; 135, identifier:theme; 136, if_statement; 136, 137; 136, 140; 136, 150; 137, comparison_operator:is; 137, 138; 137, 139; 138, identifier:site; 139, None; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:mods; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:self; 147, identifier:_parse_site_text; 148, argument_list; 148, 149; 149, identifier:site; 150, else_clause; 150, 151; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:mods; 155, list:[(None, None)]; 155, 156; 156, tuple; 156, 157; 156, 158; 157, None; 158, None; 159, for_statement; 159, 160; 159, 161; 159, 162; 160, identifier:mod; 161, identifier:mods; 162, block; 162, 163; 162, 169; 162, 177; 162, 188; 162, 195; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 168; 165, pattern_list; 165, 166; 165, 167; 166, identifier:residue; 167, identifier:pos; 168, identifier:mod; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:qstr; 172, binary_operator:+; 172, 173; 172, 174; 173, string:"$.events.frames[(@.type is 'regulation') and "; 174, binary_operator:%; 174, 175; 174, 176; 175, string:"(@.arguments[0].arg is '%s')]"; 176, identifier:frame_id; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:reg_res; 180, call; 180, 181; 180, 186; 181, attribute; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:self; 184, identifier:tree; 185, identifier:execute; 186, argument_list; 186, 187; 187, identifier:qstr; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:reg_res; 191, call; 191, 192; 191, 193; 192, identifier:list; 193, argument_list; 193, 194; 194, identifier:reg_res; 195, for_statement; 195, 196; 195, 197; 195, 198; 196, identifier:reg; 197, identifier:reg_res; 198, block; 198, 199; 198, 207; 198, 250; 198, 259; 198, 288; 198, 294; 198, 304; 198, 330; 198, 339; 198, 348; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 204; 201, pattern_list; 201, 202; 201, 203; 202, identifier:controller_agent; 203, identifier:controller_coords; 204, expression_list; 204, 205; 204, 206; 205, None; 206, None; 207, for_statement; 207, 208; 207, 209; 207, 212; 208, identifier:a; 209, subscript; 209, 210; 209, 211; 210, identifier:reg; 211, string:'arguments'; 212, block; 212, 213; 213, if_statement; 213, 214; 213, 222; 214, comparison_operator:==; 214, 215; 214, 221; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:self; 218, identifier:_get_arg_type; 219, argument_list; 219, 220; 220, identifier:a; 221, string:'controller'; 222, block; 222, 223; 222, 232; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:controller; 226, call; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:a; 229, identifier:get; 230, argument_list; 230, 231; 231, string:'arg'; 232, if_statement; 232, 233; 232, 236; 233, comparison_operator:is; 233, 234; 233, 235; 234, identifier:controller; 235, None; 236, block; 236, 237; 236, 249; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 242; 238, 243; 239, pattern_list; 239, 240; 239, 241; 240, identifier:controller_agent; 241, identifier:controller_coords; 242, line_continuation:\; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:self; 246, identifier:_get_agent_from_entity; 247, argument_list; 247, 248; 248, identifier:controller; 249, break_statement; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:reg_subtype; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:reg; 256, identifier:get; 257, argument_list; 257, 258; 258, string:'subtype'; 259, if_statement; 259, 260; 259, 263; 260, comparison_operator:==; 260, 261; 260, 262; 261, identifier:reg_subtype; 262, string:'negative-regulation'; 263, block; 263, 264; 263, 274; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 267; 265, 268; 266, identifier:modification_type; 267, line_continuation:\; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:modtype_to_inverse; 271, identifier:get; 272, argument_list; 272, 273; 273, identifier:modification_type; 274, if_statement; 274, 275; 274, 277; 275, not_operator; 275, 276; 276, identifier:modification_type; 277, block; 277, 278; 277, 287; 278, expression_statement; 278, 279; 279, call; 279, 280; 279, 283; 280, attribute; 280, 281; 280, 282; 281, identifier:logger; 282, identifier:warning; 283, argument_list; 283, 284; 284, binary_operator:%; 284, 285; 284, 286; 285, string:'Unhandled modification type: %s'; 286, identifier:modification_type; 287, continue_statement; 288, expression_statement; 288, 289; 289, assignment; 289, 290; 289, 291; 290, identifier:sentence; 291, subscript; 291, 292; 291, 293; 292, identifier:reg; 293, string:'verbose-text'; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 301; 296, subscript; 296, 297; 296, 300; 297, subscript; 297, 298; 297, 299; 298, identifier:annotations; 299, string:'agents'; 300, string:'coords'; 301, list:[controller_coords,
theme_coords]; 301, 302; 301, 303; 302, identifier:controller_coords; 303, identifier:theme_coords; 304, expression_statement; 304, 305; 305, assignment; 305, 306; 305, 307; 306, identifier:ev; 307, call; 307, 308; 307, 309; 308, identifier:Evidence; 309, argument_list; 309, 310; 309, 313; 309, 316; 309, 319; 309, 324; 309, 327; 310, keyword_argument; 310, 311; 310, 312; 311, identifier:source_api; 312, string:'reach'; 313, keyword_argument; 313, 314; 313, 315; 314, identifier:text; 315, identifier:sentence; 316, keyword_argument; 316, 317; 316, 318; 317, identifier:annotations; 318, identifier:annotations; 319, keyword_argument; 319, 320; 319, 321; 320, identifier:pmid; 321, attribute; 321, 322; 321, 323; 322, identifier:self; 323, identifier:citation; 324, keyword_argument; 324, 325; 324, 326; 325, identifier:context; 326, identifier:context; 327, keyword_argument; 327, 328; 327, 329; 328, identifier:epistemics; 329, identifier:epistemics; 330, expression_statement; 330, 331; 331, assignment; 331, 332; 331, 333; 332, identifier:args; 333, list:[controller_agent, theme_agent, residue, pos, ev]; 333, 334; 333, 335; 333, 336; 333, 337; 333, 338; 334, identifier:controller_agent; 335, identifier:theme_agent; 336, identifier:residue; 337, identifier:pos; 338, identifier:ev; 339, expression_statement; 339, 340; 340, assignment; 340, 341; 340, 342; 341, identifier:ModStmt; 342, call; 342, 343; 342, 346; 343, attribute; 343, 344; 343, 345; 344, identifier:modtype_to_modclass; 345, identifier:get; 346, argument_list; 346, 347; 347, identifier:modification_type; 348, if_statement; 348, 349; 348, 352; 348, 362; 349, comparison_operator:is; 349, 350; 349, 351; 350, identifier:ModStmt; 351, None; 352, block; 352, 353; 353, expression_statement; 353, 354; 354, call; 354, 355; 354, 358; 355, attribute; 355, 356; 355, 357; 356, identifier:logger; 357, identifier:warning; 358, argument_list; 358, 359; 359, binary_operator:%; 359, 360; 359, 361; 360, string:'Unhandled modification type: %s'; 361, identifier:modification_type; 362, else_clause; 362, 363; 363, block; 363, 364; 363, 377; 364, if_statement; 364, 365; 364, 368; 365, comparison_operator:==; 365, 366; 365, 367; 366, identifier:modification_type; 367, string:'autophosphorylation'; 368, block; 368, 369; 369, expression_statement; 369, 370; 370, assignment; 370, 371; 370, 372; 371, identifier:args; 372, list:[theme_agent, residue, pos, ev]; 372, 373; 372, 374; 372, 375; 372, 376; 373, identifier:theme_agent; 374, identifier:residue; 375, identifier:pos; 376, identifier:ev; 377, expression_statement; 377, 378; 378, call; 378, 379; 378, 384; 379, attribute; 379, 380; 379, 383; 380, attribute; 380, 381; 380, 382; 381, identifier:self; 382, identifier:statements; 383, identifier:append; 384, argument_list; 384, 385; 385, call; 385, 386; 385, 387; 386, identifier:ModStmt; 387, argument_list; 387, 388; 388, list_splat; 388, 389; 389, identifier:args | def get_modifications(self):
qstr = "$.events.frames[(@.type is 'protein-modification')]"
res = self.tree.execute(qstr)
if res is None:
return
for r in res:
modification_type = 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']
site = None
theme = None
for a in args:
if self._get_arg_type(a) == 'theme':
theme = a['arg']
elif self._get_arg_type(a) == 'site':
site = a['text']
theme_agent, theme_coords = self._get_agent_from_entity(theme)
if site is not None:
mods = self._parse_site_text(site)
else:
mods = [(None, None)]
for mod in mods:
residue, pos = mod
qstr = "$.events.frames[(@.type is 'regulation') and " + \
"(@.arguments[0].arg is '%s')]" % frame_id
reg_res = self.tree.execute(qstr)
reg_res = list(reg_res)
for reg in reg_res:
controller_agent, controller_coords = None, None
for a in reg['arguments']:
if self._get_arg_type(a) == 'controller':
controller = a.get('arg')
if controller is not None:
controller_agent, controller_coords = \
self._get_agent_from_entity(controller)
break
reg_subtype = reg.get('subtype')
if reg_subtype == 'negative-regulation':
modification_type = \
modtype_to_inverse.get(modification_type)
if not modification_type:
logger.warning('Unhandled modification type: %s' %
modification_type)
continue
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, residue, pos, ev]
ModStmt = modtype_to_modclass.get(modification_type)
if ModStmt is None:
logger.warning('Unhandled modification type: %s' %
modification_type)
else:
if modification_type == 'autophosphorylation':
args = [theme_agent, residue, pos, ev]
self.statements.append(ModStmt(*args)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.